Procedural Game Environment Design Practices for Visual Effects Artists
Jennifer McSpadden
Submitted in Partial Fulfillment of the Requirements
For the Degree of Master of Fine Arts in Visual Effects
at
The Savannah College of Art & Design
© November 2013, Jennifer McSpadden
The author hereby grants SCAD permission to reproduce and to distribute publicly paper and
electronic thesis copies of document in whole or part in any medium now known or hereafter created.
Signature of Author and Date: ____________________________ /______________________
_____________________________________________________ /______________________
Deborah R. Fowler
Committee Chair
_____________________________________________________ /______________________
Charles Shami
Committee Member
_____________________________________________________ /______________________
Patricia G. Perrone
Committee Member
Procedural Game Environment Design Practices for Visual Effects Artists
A Thesis Submitted to the Faculty of the Visual Effects Department
in Partial Fulfillment of the Requirements for the
Degree of Master of Fine Arts in Visual Effects
at
The Savannah College of Art and Design
By
Jennifer McSpadden
Savannah, GA
November 2013
Acknowledgments
To my family, my father, mother, and sister, for their unrelenting support.
To Professor Deborah Fowler, for years of guidance and continued encouragement.
To Professor Stuart Robertson, Professor Malcolm Kesson, Professor Bridget Gaynor, and
Professor Pat Perrone, who helped to start me along this journey and allowed me to continue to
move forward.
To Professor Charles Shami and Professor Aram Cookson, who were willing to step out of their
department to offer their expertise and advice.
To Connor Scott, for his years of friendship, loyalty, and tough love.
To Kenn Wood, for his insight into succeeding at such a formidable task.
To Joey Kowalewicz, for his technical support and patience.
Table of Contents
List of Figures ….........................….........................….........................….........................…..................….........................…...................... 1
Thesis Abstract ….........................….........................….........................…..….........................….........................….........................…….... 2
1. Introduction ….........................….........................….........................…..….........................….........................….........................…...... 3
1.1 The Houdini Engine ….........................….........................….........................…..….........................…........................ 4
1.2 The Goal: a New Design Methodology ….........................….........................….........................…............ 5
2. Differences in Designing for Games ….........................….........................….........................…........................................ 6
2.1 Polycount and Texturing ….........................….........................….........................…..….........................…............. 6
2.2 The Benefits of Proceduralism ….........................….........................….........................…............................... 8
2.3 The Need for a New Outlook ….........................….........................….........................…..….........................….. 11
3. Game Analysis ….........................….........................….........................…..….........................….........................….........................…. 12
4. The Methodology, Demonstrated by an Interior Design Proof-of-Concept .............….................... 16
4.1 Trial and Error ….........................….........................….........................…..….........................….........................…......... 17
4.2 Troubleshooting: Building the Walls ….........................….........................….........................…..…............. 23
4.3 Some Things to Consider in Illustrator ................................................................................................... 24
4.4 Testing Results in Engine ….........................….........................….........................…..….........................…............ 27
4.5 Building a Familiar Building ….........................….........................….........................…..….........................…...... 28
5. Comparing This Method to a More Traditional Approach ........................….........................…..…................ 30
5.1 Best Practices for Interior Design ...........….........................…..….........................…..................................... 32
6. Houdini Engine Potential .........................….........................…..….........................…....................................…......................... 35
6.1 In Conclusion ….........................….........................…........................…..….........................….........................…............ 36
Works Cited ….........................….........................….........................…..….........................….........................….........................…..…......... 39
Inventory of Visual Aids ….........................….........................….........................…..….........................….........................….............. 40
1
List of Figures
Fig. 1.1 - Houdini Engine in Unity ….........................….........................….........................…..….........................…................... 5
Fig. 1.2 - Houdini Engine in Maya ….........................….........................….........................…..….........................…................... 5
Fig. 2.1 - High poly mesh detail baked onto a low poly mesh ….........................….........................…................ 7
Fig. 2.2 - Using a Houdini tool to place lights, pick-ups, encounters, etc. ….........................…................ 9
Fig. 3.1 - Rogue Encampment with Western Exit ….........................….........................….........................…..….......... 13
Fig. 3.2 - Diablo 3 starting region ….........................….........................….........................…..….........................…................... 14
Fig. 3.3 - “Fields of Misery”, Diablo 3, Blizzard Entertainment ….........................….........................…............ 15
Fig. 3.4 - “Old Tristram Road / Old Ruins”, Diablo 3, Blizzard Entertainment ….........................…....... 15
Fig. 3.5 - Starting zone (on the left) rearranged (on the right) ….........................….........................…............. 16
Fig. 4.1 - Floor plan sketch ….........................….........................….........................…..….........................….........................…........ 17
Fig. 4.2 - Floors stacked via the ForEach SOP ….........................….........................….........................…..…..................... 18
Fig. 4.3 - Door distribution not working ….........................….........................….........................…..….........................…..... 20
Fig. 4.4 - Intended result, working without using the ForEach ….........................….........................…............. 20
Fig. 4.5 - Painting the placement of the doors and windows ….........................….........................…................. 21
Fig. 4.6 - Uneven walls from the extrusion ….........................….........................….........................…..….......................... 22
Fig. 4.7 - Uneven doorway results from uneven walls ….........................….........................…................................ 22
Fig. 4.8 - Rooms arranged like pieces of a puzzle ….........................….........................….........................…..…........... 23
Fig. 4.9 - Curves in Illustrator .................................................................................................................................................... 25
Fig. 4.10 - Window arrangement in Illustrator ............................................................................................................ 26
Fig. 4.11 - Preparing the Illustrator file for exporting ............................................................................................. 26
Fig. 4.12 - The structure in Unity ….........................….........................….........................…..….........................…..................... 27
Fig. 4.13 - Testing the building scale in Unity ….........................…..….........................….......….........................….......…. 27
Fig. 4.14 - Wall and window thickness, controlled in Houdini ….........................….......….........................…..... 27
Fig. 4.15 - Montgomery Hall floor plan, first floor, sketched in Illustrator ….........................…............... 29
Fig. 4.16 - Model of Montgomery Hall ….........................….........................….........................….….........................…......... 29
Fig. 5.1 - Modular walls forming a portion of the perimeter ...................…............................…....................... 31
Fig. 5.2 - An interface for a modular approach …............................…..…............................…..…............................…... 31
Fig. 5.3 - Seven floor layouts ............................…..…....................................…..…....................................…..…........................... 34
Fig. 6.1 - Fracture text digital asset ….........................….........................…......................….........................…....................... 35
2
Procedural Game Environment Design Practices for Visual Effects Artists
Jennifer McSpadden
November 2013
Side Effects' Houdini Engine is meant to facilitate the exchange of information between Houdini
and other Digital Content Creation (DCC) applications, allowing for Houdini tools to be used in
multiple software environments.
A new methodology of design within Houdini is necessary in order for artists to
effectively use the Houdini Engine. The example discussed here focuses on creating custom
building floor plans and interior spaces. The relevance of this new outlook is justified by
examining current games (Blizzard Entertainment's dungeon crawlers Diablo II and Diablo III)
featuring interiors lacking in variety that could benefit from a procedural approach. Floor plans,
generated from sketches created in Adobe Illustrator, are traced in Houdini and used to
generate a building. Then, that building is imported into the Unity game engine. The workflow
highlights the ability of the artist to alter the results quickly and frequently.
Such a process will contribute a new methodology of environment design to the realm of
digital game production, useful to the visual effects community of Houdini users and to the
community of game environment artists alike.
3
1. Introduction
The gap between cinematic and in-game visuals is ever narrowing as gaming consoles
and personal computers steadily become more powerful. Pre-rendered cinematics in games
(opening cinematics or in-game cut scenes) are already competing with film quality effects,
made possible by teams of digital artists that use techniques seen in any Hollywood
blockbuster.
Side Effects' Houdini is an industry-standard procedural production software package.
Its ability to iterate through complex calculations that generate geometrically heavy scenes is
what makes it such a valuable tool. It is widely used for its effects capability, including
sophisticated particle systems and rigid-body dynamics, simulated and rendered with ease.
Side Effects is also marketing Houdini as a viable tool for game asset creation by highlighting its
application to the video game industry, as well as its already established procedural power in
creating detailed and dynamic 3D environments.1
In order for Houdini to become integrated into a variety of pipelines, there needs to exist
a method of smoothly exchanging content without having to compromise functionality; a way
for Houdini users to employ their workflow in a variety of environments. The solution would
mean a plugin that could incorporate anything Houdini-created into another software package –
thus, the Houdini Engine was created.
1 “Go Procedural: Video Games”. sidefx.com. <http://www.sidefx.com/index.php?
option=com_content&task=view&id=1590&Itemid=337>
4
1.1 The Houdini Engine
The Houdini Engine is “a compact API [application programming interface] which
extracts Houdini's core technologies into a powerful procedural engine for film and game
studios to integrate into proprietary applications.”2 It is meant to facilitate the exchange of
information between Houdini and other Digital Content Creation (DCC) applications. This
means that Houdini users will be able to create digital assets, or custom tools, that can be
exchanged with other software. When the beta version is released to the public, Autodesk’s
Maya and the Unity game engine will be the first packages that will be participating in this
exchange. The Houdini Engine will appear as a plugin within their interfaces, and digital asset
files (.otl) will be able to be imported, functioning as they do in Houdini. Any custom
parameters or snippets of code used in the tool will be retained, allowing a Houdini user to
operate familiarly outside of Houdini. Jacinda Chew, Studio Art Director at Insomniac Games,
states that “artists and designers can use the interface they are most familiar with to create
assets procedurally or use their regular toolset to create or customize assets and instances
manually. This means we can build and iterate faster.”3
With the introduction of the Houdini Engine, all aspects of Houdini will eventually be
able to be accessed in other software packages. Side Effects released two demonstration videos
that detail the extent of the Houdini Engine’s capabilities. In the first (Toronto - July 11, 2013),
the Houdini Engine is shown as a plugin in Maya and Unity. [Fig. 1.1 & Fig. 1.2]
2 “SideFX Labs: Game Art in Unity”. sidefx.com. August 26, 2013. <labs.sidefx.com>
3 “News Articles: Houdini Engine”. sidefx.com. July 11, 2013. <http://www.sidefx.com/index.php?
option=com_content&task=view&id=2525&Itemid=66>
5
Fig. 1.1 - Houdini Engine in Unity
Fig. 1.2 - Houdini Engine in Maya
Two digital assets are shown, one with procedurally generated geometry, the other
incorporating rigid body dynamics. In both instances, the results could continue to be modified
using any of the custom parameters that were defined in Houdini. The second video (Unite
2013, Vancouver - August 26, 2013), covers a more in-depth look at level creation. It steps
through “a low resolution 'set-up' mode where a level designer can quickly mock-up a level,
then a 'testing' mode and higher resolution 'gameplay' mode.”4
1.2 The Goal: a New Design Methodology
In light of the possibilities that the Houdini engine will provide, artists must begin to
consider how they will have to alter their workflow within Houdini in order to maximize its
effectiveness in other contexts. For example, if Houdini is going to be used for the creation of
assets that will be used in a game engine, then they will need to cater to the capabilities of the
target engine, as well as to the creative needs of the user. Changes to the design pipeline will
need to be made in stride.
The process documented here will expound upon a methodology of digital asset design
that takes into consideration the demands of game environment design. As an example of how
4 “SideFX Labs: Game Art in Unity”.
6
to use Houdini for quick, cost-effective design, a proof-of-concept method is developed in order
to create custom building floor plans, generated from sketches created in Illustrator, imported
into Unity, and updated as quickly and frequently as the artist chooses. Such a methodology
will contribute greatly to the visual effects community of Houdini users and to the community
of game environment artists alike, as it opens the door for extensive cooperation between the
industries.
2. Differences in Designing for Games
Game engines must render environments in real time so that players have the ability to
observe everything around them at all times. 360° accessibility means instant access to
geometry, shaders, lighting effects, and particle and character animation. Especially in the case
of PC games, frame rate within a game is dependent upon individual computer specifications as
well as the complexity of what is visible on the screen at any given moment. A character
moving through a simple interior will make for a less graphically demanding situation on a
system than would a character running through an outdoor battle scene, complete with
hundreds of animated meshes and particle effects, creating a dense atmosphere. As a result,
definite restrictions are placed on the complexity of the geometry and effects that can be
displayed while in game.
2.1 Polycount, Lightmapping, and Texturing
One of the most significant differences between designing for pre-rendered frames and
7
for real-time rendering is the attention given to poly-count. Characters and environment
elements that are hundreds of thousands of polys or more will greatly reduce performance in
an engine; most engines have a poly limit when importing geometry in order to maximize
performance. While this restriction is becoming ever more lenient, there are ways to optimize
geometry to improve its appearance in a scene.5
Even though high poly meshes can be very taxing on performance, it does not mean that
high density meshes are not created for game characters. They are modeled to the same levelof-detail as those for film. A lower poly version, which is used in engine, is created in addition
to the high poly one. To simulate a high level-of-detail, texture artists bake the detail from the
high density mesh into a normal map. When combined with the rest of the geometry's texture
maps, the result is a highly detailed appearance on a low density mesh. 6 [Fig. 2.1]
Fig. 2.1 - High poly mesh detail baked onto a low poly mesh
Lightmaps are also generated and baked into the texture information. Typically when
objects are lit and rendered, the light and shadow information on the object's surface is
calculated at the time of the render. By lightmapping, the surface's highlights and lowlights are
5 “Unity Manual – Optimizing for integrated graphics cards”. Unity Manual. October 12, 2012.
<http://docs.unity3d.com/Documentation/Manual/OptimizeForIntegratedCards.html>
6 For more information on this process, here is a brief synopsis <http://blender.stackexchange.com/questions/2466/how-does-normal-baking-work>
8
added to the texture, giving the illusion of light being cast from a source. This is usually
generated in engine once the lights are placed. When an object is moved, the lightmap must be
recalculated to account for the change in the pattern of the light on the object's surface.
Lightmapping removes the need for real time lighting calculations.
Texturing as a whole is a process that would be able to be modified when transferring
assets from Houdini to engine. Traditional means of creating texture maps – painting diffuse
maps, and generating specular and normal maps from them – can continue to be used, so long
as the geometry's UVs are laid out at some point. But as long as Houdini is part of the pipeline,
procedural shading can be integrated as well. Shaders that fluctuate, such as a candle's flame
or a clock face, can be imported into the engine and subsequently altered as needed. The
lightmaps could be modified within the texture structure, producing more high resolution,
realistic results. This will allow for texture artists to work outside of the bounds of the
sometimes limited functionality found in current engine's material editors.
2.2 The Benefits of Proceduralism
Procedural, in terms of computer graphics and digital design, refers to “anything
generated algorithmically, rather than being created manually by the hand of the artist.” 7
Houdini is known as a “procedural, node-based workflow” 8, so it is important to discuss the
benefits of a procedural approach to game environment design in order to fully appreciate what
7 Slick, Justin. “7 Common Modeling Techniques for Film and Games: An Introduction to 3D Modeling
Techniques”. About.com 3D. <http://3d.about.com/od/3d-101-The-Basics/a/Introduction-To-3d-ModelingTechniques.htm>
8 “Product Overview”. sidefx.com. <http://www.sidefx.com/index.php?
option=com_content&task=view&id=1021&Itemid=270>
9
Houdini can offer as a game design tool.
Proceduralism in games is nothing new, but in the past, technological development
limited its presence to “niche roles and/or niche games, and most methods used in early
examples were, by today's standards, rather simplistic.” 9 Now, a procedural workflow can offer
many benefits to a production pipeline. The most significant improvement that it boasts is
time-saving.
Instead of having to hand place every piece of geometry and every player
encounter, an environment designer can use Houdini tools to procedurally lay out, and in effect,
orchestrate the player's experience (see Fig. 2.2). Simple adjustments in the scene can have
very dramatic effects on the
finished level.
And thanks to
Houdini's node-based workflow,
which allows for non-destructive
changes to be made along the
node tree, these adjustments can
Fig. 2.2 - Using a Houdini tool to place lights, pick-ups,
encounters, etc.
be made quickly and with little
consequence.
Procedural tools are able to do all of the heavy-lifting for the artist. They must be
programmed with the ability to provide random variance in object creation and placement, as
well as constrained within the realm of what is possible (why allow a digital asset to generate
hundreds of thousands of trees, when it is meant to populate only a small forest?) and what is
probable (an office building would never have hundreds of windows per floor, so give the
9 Bidarra, Rafael. “Guest Editorial: Procedural Content Generation in Games”. IEEE Transactions on Computational
Intelligence and AI in Games, vol. 3, no. 3, September 2011.
<http://www.academia.edu/1578545/Procedural_content_generation_in_games>
10
parameters a reasonable limit).
10
Kim Goossens, a professor at NHTV University of Applied Sciences in Holland, speaks
about the benefits of Houdini's procedural power in an article found on the Side Effects
website:
Houdini is a workhorse when dealing with painstaking repetitive tasks. Imagine…
(MMORPG’s) where thousands of characters are populating a world that needs
variation and detail. In level design where hundreds or thousands of objects need
to be placed, Houdini is a formidable tool for creating custom procedural
placement methods. … Sometimes there are procedural systems that need to be
built into the game engine itself. This is primarily for games that have a gamer to
design their worlds, or for games that adjust their environment depending on the
actions of the gamer. Designing these procedures is a difficult task that requires a
technical artist to make many variations. Houdini is the ideal tool for this type of
rapid prototyping. … Probably the most powerful aspect of Houdini as a whole is
the fact that it gives both small and big game companies a formidable control over
their production pipeline in which elements can be parallelized that would
otherwise have been impossible.11
Another prominent way in which procedural calculations can speed up production
10 For more information on procedural content in games and how it's changing the face of level design, check out
<http://pcg.wikidot.com/>. Though some of the articles are a few years old, they offer varied perspective on
the benefits, as well as the frustrations (Sicart, Miguel. “Against Procedurality”. 2010.
<http://gamestudies.org/1103/articles/sicart_ap>), of incorporating procedurally generated content into a
pipeline.
11 “Procedural Game Development: Kim Goossens”. <http://www.sidefx.com/index.php?
option=com_content&task=view&id=2139&Itemid=68>
11
time is in terrain generation. The Mountain node instantly creates a deformed mesh, and
with controls over subdivisions, smoothness, amplitude, and random seed, it is very easy
to quickly achieve the desired effect. The Paint node can further enhance the creative
process of terrain sculpting, as can the incorporation of user-defined VEX (vector
expression) operators. In Guerrilla Games' Killzone 2, for example, custom Houdini VEX
operators were used for terrain creation, as well as for texture assignment. 12
2.3 The Need for a New Outlook
Digital assets that will be integrated into a game engine, via the Houdini Engine, must be
designed in such a way that both Houdini users and game engine users can operate them with
ease. The tools being created must be versatile enough to fulfill design needs, as well as
conscientious of the game engine’s rendering limitations. It is important to keep in mind userfriendly interface design. Custom parameters need to have meaningful names and intelligible
descriptions. These tools will be used by Houdini users and game developers alike, so they
need to cater toward both audience's needs. With the potential that the Houdini Engine
presents, it is possible for the tool to change hands numerous times throughout the
development process.
The Houdini artists developing the tools must be in constant
communication with the level designer so that any and all engine needs are met. Consequently,
a thorough understanding of engine functionality would be beneficial; if Houdini artists are
going to create for a gaming environment, they will need a new outlook on tool design. A new
outlook means a new methodology – a new way of designing. Such a methodology will be
12 “Guerilla Games Killzone 2“. <http://www.sidefx.com/index.php?
option=com_content&task=view&id=1454&Itemid=68>
12
explored here, through the use of an interior design tool example. The conclusions that were
arrived at during its course of development will shed light on the necessity of the design
methodology and how its facets are to be applied during conception.
3. Game Analysis
In order to diagnose how diversified this methodology's usefulness will prove to be,
existing games must be examined; particularly ones that feature interiors lacking in both variety
and procedural approach. Genre plays a key role in this investigation. Dungeon crawlers (such
as Blizzard’s Diablo series or Runic’s Torchlight series) and MMORPGs (massively multiplayer
online role playing games, like Blizzard’s World of Warcraft) are two genres that provide
excellent examples of repetitive interior design. Sidescrollers (such as classic Mario or Donkey
Kong), for example, would not be able to employ the interior design process discussed in this
paper, but facets of the methodology that are being developed could prove to be beneficial in
the future. For the sake of effectiveness, Diablo 3 (2012), as well as Diablo 2 (2000), will be
used as an example of a game that could be improved upon by the use of Houdini-generated
interior design.
Blizzard's Diablo franchise is an exemplary entry in the “dungeon crawler” genre. In
addition to being categorized as “action/role playing” and “hack-and-slash”, Diablo’s notoriety
really comes in the form of complex dungeons, laden with enemies, resources and weapon
pickups, and a story that promotes exploration and replayability. Once the game is completed,
it can be replayed in more difficult modes. While the story does not change, the strength and
frequency of enemy encounters scales up significantly, making the rewards equally more
13
satisfying.
There is a marked difference
between Diablo 2 and Diablo 3
in regards to the random quality
of the environments. In Diablo
2, the exit to each city changes
Fig. 3.1 – Rogue Encampment with Western Exit, Diablo 2,
Blizzard Entertainment
location each time the game is
loaded.
This
alters
the
orientation of the environment around the player, making it very difficult to simply memorize
where everything is located. [Fig. 3.1] Each experience with the game feels unique and each
enemy encounter is a welcomed surprise, so that “even the most experienced player would still
have to explore without an absolute sense of where to go.”13 Such variety adds challenge in the
form of the unknown. The player must be ready for anything. As they traverse the world
around each city and between each plot point, they feel a true sense of discovery and
meaningful exploration.
In Diablo 3, “the boundaries of the maps remain consistent while everything within the
boundaries is a randomized collection of predesigned chunks (that also have further
randomized elements within). As a result, on each subsequent playthrough, the player will have
a growing sense of direction until it becomes clear that the boundaries of the maps never
change and can in fact be memorized. Then, instead of wandering throughout the many
impressive environments, playing through the game is simply a matter of making a beeline
towards the known destination. … Diablo 3 feels linear by contrast [to Diablo 2], and linear is
13 Margo, Ari. “5 Ways the Diablo III Expansion Could Improve Upon Its Predecessor”. gamerhorizon.com, 2013.
<http://gamerhorizon.com/5-ways-the-diablo-iii-expansion-could-improve-upon-its-predecessor/>
14
not a word you want associated with a game series that is known for its randomly generated
dungeons.”14
Each time a player logs into the
game, the surrounding regions have a set
layout. All of the terrain and set pieces
have fixed locations, unlike in Diablo 2.
Fig. 3.2 shows the layout of the first region
of the game. The locations of health wells
and blessing shrines will move about the
map each time it refreshes, and enemy
mobs will spawn randomly as the player
explores the world. But that is the extent
of the random generation throughout
most of the game's environments. Figs.
3.3 and 3.4 provide examples of how
Fig. 3.2 – Diablo 3 starting region
these random pickups are placed on the
board. The blocks that are marked as different sizes and types indicate where enemy mobs
might be found. Potential locations of quest specific objects are marked as well. 15 The most
obvious consistency is the placement of the dungeon entrances, having set locations in the
world, whether they be large winding passageways or small storage cellars. Each time the game
is played through at increasing levels of difficulty, they still remain in a fixed location. For a
14 Ibid.
15 Amaranth, Tobias. “A Full Guide to the First 4 Overworld Maps: An Overview of Map Creation and Block Types”.
incgamers.com, July 2011. <http://diablo.incgamers.com/forums/showthread.php?824245-A-Full-Guide-to-theFirst-4-Overworld-Maps>
15
game belonging to a series that boasts its randomly-generated dungeons, this is not a good
choice. However, if the zones are not quest-related, then they will appear at random locations
on the map, as seen in the variable blocks in [Fig. 3.3].
Fig. 3.3 - “Old Tristram Road / Old Ruins”,
Diablo 3, Blizzard Entertainment
Fig. 3.4 - “Fields of Misery”, Diablo 3,
Blizzard Entertainment
If Diablo 3 had followed the example that Diablo 2 had set, then it would have been truly
groundbreaking in its capacity for immersion. The world maps in Diablo 2, as aforementioned,
simply rotate each time they are loaded. A constant feeling of the unknown and losing progress
toward exploration goals makes for a real penalty when a player dies and respawns. Diablo 3
could have been improved by incorporating a more extensive random content generator. Then,
the surrounding world could not only rotate, but be assembled in a whole new way. Smaller
regions of pathways, terrain, and dungeon entrances could be seeded and dynamically
16
connected to make a new experience for the player every each time it is explored. [Fig. 3.5]
Fig. 3.5 - Starting zone (on the left) rearranged (on the right), offering an example of potential
random construction. Areas highlighted in red were used to piece together the map on the right.
Such changes to Diablo 3's environment design could have been made possible with
Houdini. A Houdini digital asset could have been developed that would have generated random
maps, providing a much more challenging and disorienting effect for the player.
The following methodology will continue to demonstrate how Houdini can enhance a
game environment design pipeline.
4. The Methodology, Demonstrated by an Interior Design Proof-of-Concept
The best way to demonstrate the validity of a methodology is to implement it for a
17
specific outcome, thereby testing its usefulness, its potential, and its limitations. The decision
to focus on interior design was based on a marked need found amongst currently available
tutorials. There is little documentation available on the process of generating custom building
interiors. Various building facade tutorials exist, resulting in vast cities and road systems. But
rarely are interior spaces created, let alone fully designed and explorable. Therefore, the
interior design proof-of-concept, that will be henceforth discussed and demonstrated, serves as
a way to communicate the design methodology that this paper proposes.
4.1 Trial and Error
Fig. 4.1 - Floor plan sketch, used in first iteration of interior design method,
sketched in Houdini
The first and most important problem that needed to be solved was a straightforward,
rapid way of inputting wall orientation and window and door locations. Keeping in mind that
the workflow was meant to be followed by Houdini users and non-Houdini users alike, there
needed to be a way to sketch the maps that everyone could understand. At first, the “img”
18
context of Houdini was explored, where an artist could import an image of a map and trace it
with roto shapes. The shapes could then be used to generate curves. Those curves could be
extruded and resampled, resulting in walls. But problems arose when it came to making
changes to the layout. Manipulating existing roto shapes in Houdini requires skills that not
every designer possesses - not to mention, it can be a tedious and often less-than precise task.
Fig. 4.2 - Floors stacked via the ForEach SOP
As the pipeline was developed, it became clear that certain SOPs (Surface Operators 16)
would have to be used, or conversely omitted, in order to achieve the intended effect. An
example of trial and error, leading to an eventual omission, was the use of the ForEach SOP.
Each of the floor plans were wired into the ForEach, traced, extruded, and scaled, and
translated up, accounting for their order in sequence and the thickness of the floor/ceiling. This
worked as planned, as seen in Fig. 4.2.
16 “Nodes: Surface nodes”. Houdini 12.5 Docs. <http://www.sidefx.com/docs/houdini12.5/nodes/sop/>
19
➔ Before the ForEach SOP, all of the Trace nodes for each floor of the building are joined
with a Merge node. That node is wired into the input of the ForEach SOP.
➔ In the ForEach SOP, set the “For” parameter to “Each Primitive/Point”.
➔ For the “Max Iterations” value, either add the number of floors that you want the
building to have, or insert a custom parameter (created in the “Custom Parameter
Interface”) that can control this value from the top-level of the digital asset. All top
level parameters will be part of the asset's UI, which will appear in the target
software application.
➔ Within the ForEach SOP:
➔ A Transform node is the first to be appended to the Each SOP. All of the Each SOP's
parameters are left at their default values.
➔ A uniform scaling factor can be incorporated here to control the size of the walls.
➔ In the Translate Y region, each Trace (referred to by the Group parameter within
the Each SOP) is distributed vertically, based on the floor number that it
corresponds to. Space was left between the floors to represent the physical
thickness of the floor geometry. Custom parameters were made to control this
and vertical distribution (seen here as “floorThickness” and “storyHeight”).
An example of the resulting entry:
(ch("../../floorThickness") + ch("../each1/group")) + (ch("../../storyHeight") *
ch("../each1/group"))
➔ An Extrude SOP follows the Transform node.
➔ In the Values pane, set Fuse Points to “Clamp individual face”. This will help to
reduce any overlapping points.
➔ Set Front Face and Back Face to “No Output”. Outputting this geometry is
unnecessary, as it will be hidden by the floors and ceilings. And because it is
important to keep poly-count in mind, these faces can be omitted.
➔ Depth Offset and Depth Scale should be set to a value that will control the height
of the windows. These too can be optimized by using a custom parameter,
visible at the top-level of the digital asset.
➔ The Cusp Polygonal Sides and Side Cusp Angle values are used to manipulate side
20
faceting. This can help to smooth out the resulting geometry's edges.
➔ For organizational purposes, a Point SOP can be appended to add color to each floor
as seen in Fig. 4.2. The same color values can be added to wall and window
geometry, if preferred.
The same process was attempted in order to distribute the maps of the doors for each
floor. Like the floor plan maps, these maps were also created in Illustrator and imported into
Houdini via a Trace SOP. They created boxes that would be used with a Cookie SOP to cut holes
in the walls. So if there were ten doors on a floor, ten primitives would be generated from the
map and ten holes would be cut. Unfortunately, when these maps were wired into the ForEach
SOP, each closed primitive was translated individually. The ForEach SOP does not distribute
primitive groups in the same way that it does individual primitives. The result was either that
each door was placed on a different level, instead of groups of doors that corresponded to the
location of each floor, or all of the doors were placed on a single level. Figs. 4.3 and 4.4 show
these results.
Fig. 4.3 - Door distribution not working, using the ForEach
Fig. 4.4 - Intended result, working without
using the ForEach
A Group node was inserted into the stream in the hope that the ForEach would arrange
the primitive groups in the same way that it did the individual primitives. After further
research, it was concluded that the ForEach does not recognize primitive groups, and therefore
21
does not retain their contents as data that can be accessed within its parameters. Though much
was learned about its functionality, the ForEach SOP was, ultimately, removed from the
prototype.
Another process that was experimented with, but ultimately omitted, was the idea of
painting directly onto the geometry the locations of the doors and windows. The Paint SOP
allows the user to interactively paint on the surface of geometry at the location of the vertices,
as Fig. 4.5 demonstrates.
Fig. 4.5 - Painting the placement of the doors and windows
➔ The locations of the doors and windows are defined by adding a color value to the
vertices via a Paint SOP.
➔ An AttributePromote SOP is added to convert the vertex selection to faces.
➔ Give the name of the color attribute (“Cd”) for the Original Name parameter.
➔ The vertex selection is being converted to primitives, so the Original Class parameter
should be “Point”, and the New Class parameter should be “Primitive”.
➔ Promotion Method is set to “Maximum”, so that the points are precisely converted
to complete face selections. All faces are either painted or colorless.
➔ An AttributeCreate SOP follows.
➔ A Local Variable called “color” is created to give the faces red, green, and blue
22
values. The Class is set to “Primitive” and Write Values is selected, with a value of
“0”. This turns the selected faces black, as shown in Fig. 4.5.
➔ Append a Delete SOP to blast holes in the geometry. In this case, a color value is
assigned to the selected faces with RGB values of “0 0 0”. This means that the Delete
SOP can use the black faces as a guideline of what should be deleted.
➔ In the “Number” pane, set Operation to “Delete by Expression” and the Filter
Expression to “ $CR < 0.2 ”. This will delete every face that has a red value that is less
than 0.2, which equates to all of the faces painted black.
There were two distinct issues with this workflow. First, the result of the extruded
curves to create the walls was an uneven placement of edges, as demonstrated in Fig. 4.6.
When the door and window locations where painted and cut, the resulting entryways were
uneven. There was no way around this, due to the fact that there is not a way to align geometry
when extruding.
The second issue was with the entryways themselves.
The extrusion
operation left space between the walls, but the Delete node did not fill in the resulting gaps.
[Fig. 4.7] If a player were to decide to pause in a doorway and look to the left or right, he would
see between the walls. Consequently, this problem with the Paint + Convert + Delete process
rendered it unusable.
Fig. 4.6 - Uneven walls from the extrusion
Fig. 4.7 - Uneven doorway results from uneven
walls
23
4.2 Troubleshooting: Building the Walls
It was important to step back and evaluate how the wall geometry was being built. The
process of blocking together various room sizes, and then puzzle-piecing them together seemed
too clunky. While it would help to keep poly count under control and follow a modular
approach to asset creation, it did not seem to be the most intuitive solution. The issue of wall
thickness also arose when exploring this method. In a video game, players are actually moving
through and experiencing an environment. They need to believe that their surroundings are as
real as possible. As seen in Fig. 4.8, if the rooms were constructed with boxes of predetermined
dimensions and puzzle-pieced together, then the thickness of the doorways would not be
uniform, as it would fluctuate based on the presence of adjoining rooms.
Fig. 4.8 - Rooms arranged like pieces of a puzzle
24
The user needs to be able to input a floor plan in an artistic manner, allowing for quick
results and easily executed changes. The Trace SOP seemed to be the logical solution. The user
could block out a floor plan of his design and reference that image file in the trace node. All
that would need to be done to implement changes would be to save a new version of the
reference image file and refresh the Houdini session.
An external graphic design package proved to be a valid alternative. Adobe’s Creative
Suite is used in dozens of creative industries, and Illustrator is an ideal software package for
producing precise vector-based images. Maps were created in Illustrator, making sure that all
corners were joined to remove any gaps in the walls. Doors and windows, which were added
later, were placed on separate layers so that they could be exported as separate images. In
Houdini, the Illustrator-generated maps were fed into a Trace SOP, the resulting curves were
extruded, and the wall geometry was created.
➔ In the Trace node: Select "Hole Faces" and increase the resampling value in the trace
parameters, being careful not to round out the corners of the rooms.
➔ Append a Fuse SOP to fuse the corner points together, followed by an Extrude SOP to
create the wall geometry. Transform before extruding if necessary.
➔ If a uniform scaling factor is necessary, it can be added here with a Transform SOP.
4.3 Some Things to Consider in Illustrator
In order to generate sketches in Illustrator that will give way to a solid structure in
Houdini, there are certain practices that can be followed to ensure successful results. The
“snap-to-grid” option keeps all of the curves aligned to the grid, and holding the shift key while
25
drawing them maintains that they are perfectly straight. Once all of the lines are drawn for the
walls, they need to be joined. This will lead to neat corners after the extrusion is initialized in
Houdini. Using a perfect square for the placement of the doors will lead to evenly proportioned
doorways. This is achieved by holding the shift key when drawing the square, along with
keeping “snap-to-grid” toggled on.
Fig. 4.9 - Curves in Illustrator, unjoined on the left, joined on the right
The locations of the door and window rectangles will correspond to the geometry in
Houdini that will be used in the cookie operation. As long as they are given a color in Illustrator,
other than white, they will function appropriately in Houdini. Fig. 4.10 shows the window
locations, color coded and aligned in relation to the walls. Holding the alt key while resizing the
windows will proportionately scale them either left-to-right or top-to-bottom. The windows
were placed and scaled in such a way that they would not overlap with any intersecting interior
walls, while remaining uniform when viewed from the outside of the building. To monitor this,
all of the wall and door locations for each floor are viewed at once (as the image below shows).
If desired, separate window plans can be sketched for each floor of the building. This will allow
for unique arrangements per floor, while sacrificing exterior symmetry.
26
Fig. 4.10 - Window arrangement in Illustrator
The last point that needs to be considered when preparing the Illustrator file for
exporting is how to keep each plan to scale. When a .png image file is generated for each wall,
door, and window plan, the software attempts to shrink the file to only include the area of the
image that contains information. The plans for the walls remain to scale, but the door and
window images' dimensions end up varying. To remedy this, a box is drawn to encompass all of
the maps. It is colored white so that when each file is exported, its presence determines the file
dimensions, but its color makes it invisible in the result. When the plans are used in the Trace
nodes in Houdini, they remain perfectly in scale.
Fig. 4.11 - Preparing the Illustrator file for exporting
27
4.4 Testing Results in Engine
Once the walls were built and the door
and window cutouts were appropriately
placed, the building needed to be
imported
into
dimensions.
Unity
In
most
to
test
its
first-person
shooter or role-playing games, the
Fig. 4.12 – The structure in Unity
camera follows the character either in
their point of view or at a short
distance over their shoulder.
Such
perspectives require an environment
that is big enough to be widely viewed
by the player as well as roomy enough
to be traversed, making it fully
explorable.
In the case of the workflow that is
Fig. 4.13 - Testing the building scale in Unity
discussed here, the building was made to scale in Houdini, and then the overall scale was
increased so that the player could move
through the doorways and down the
hallways without experiencing a feeling of
claustrophobia.
Fig. 4.13 shows the
building in Unity with only two stories
present. The trees are Unity assets and
Fig. 4.14 – Wall and window thickness, controlled in
Houdini
28
were placed to test the scale as well. Instead of the first-person controller that is seen in Fig.
4.12, a third-person controller is added. This forces the camera over the shoulder of the player
character, providing a wider viewing angle of the environment and a more accurate visualization
of the functionality of the building scale.
Window and wall thickness also needed to be considered. When the building scale was
adjusted in the engine, the doorways and window cutouts were also scaled up. If the player
were to look out of a window, the gap he would see would be very wide. If the building were
meant to be a warehouse or a prison, then this result may be acceptable. If it is not, then either
the geometry being used to cookie the windows in Houdini will need to be reduced, or the
building will need to be scaled in Houdini before the cookie operation is introduced. The same
holds true for the doorways. [Fig. 4.14]
4.5 Building a Familiar Building
To push the process a bit farther, the workflow was tested by using floor plans from a
real-world building. The Savannah College of Art and Design's Montgomery Hall in Savannah,
Georgia was used as a basis for the geometry seen in Fig. 4.15. The maps of each of the four
floors was accessed online17 and traced in Illustrator [Fig. 4.14], following the same process that
was described above. The windows and doors were placed on separate layers, as were the
interior and exterior walls.
17 “SDM: Montgomery Hall, Montgomery Hall Map”. <http://www.sfdm.scad.edu/intranet/student/ >
29
Fig. 4.15 - Montgomery Hall floor plan, first floor, sketched in Illustrator
Fig. 4.16 – Model of Montgomery Hall, SCAD Savannah, GA
In Unity, the building was added and a texture was assigned to it, as well as collision, so
that the player could run around inside. The scale was altered in Unity because, as mentioned
before, the hallways and doorways needed to be wide enough to be explored, even though this
sacrificed staying true to actual proportions. Some small changes were made to the original
map – some rooms and doorways were omitted to make building navigation more logical. The
structure would need to be fine-tuned before it would be ready to be set dressed and textured,
but the process that it underwent offered an exceptionally fast way to generate a mock up of
the area. This could be used to gauge how much space the building would take up in an
environment and how game play would flow around and throughout it.
30
5. Comparing This Method to a More Traditional Approach
It is an established practice to build game environments with a modular approach.
Modularity, in terms of game design, refers to the practice of arranging a scene with pieces of
scenery or building materials of a set size and texture. In this way, the game engine does not
have to work as hard when it builds a scene. Each instance of a piece can be called and
rendered without overtaxing the graphics. “Modular design is concerned with making lots of
high-quality chunks of levels and reusing those chunks intelligently, as opposed to attempting to
make an entire level out of unique assets that won't be reused.”18 In order to appreciate how
much a new approach to interior design will contribute as a time saver and as a more intuitive
solution to interior design, it needs to be compared to a fully modular pipeline.
Fig. 4.8 showed an example of using a modular workflow to arrange the rooms of the
building. The most significant issue with that approach was the varying thickness of the walls
and the subsequently disproportionate width of the doorways. Fig. 5.1 below brings up another
drawback to a modular method of room placement. The walls were made by creating two
room sizes, one on a 1x1 scale, the other 2x1. They were arranged within a designated
perimeter, leaving a central hallway to connect them all. While the rooms were neatly placed
and the poly-count of the geometry was kept to a minimum, the method used did not account
for the remaining wall sections. They would have to be placed individually, and in effect, they
could not be incorporated into a puzzle-pieced type method of construction.
18 “Using Workflow Techniques and Modularity”. udn.epicgames.com.
<http://udn.epicgames.com/Two/WorkflowAndModularity.html#Using Workflow Techniques and Modularity >
31
Fig. 5.1 - Modular walls forming a portion of the perimeter
The same holds true for the handling of the doors and windows. Each placeholder
would need to be individually manipulated. The doors would need to be made with varying
widths, considering the varying walls widths. Fig. 5.2 shows what a custom interface would
have to look like in order for an artist to add, color-code, and place each room and door. Such
considerations push a modular approach further and further away from categorizing it as a
logical solution.
Fig. 5.2 - An interface for a modular approach
32
5.1 Best Practices for Interior Design
It is important to keep in mind the experience that a player is intended to have while
they explore the environment that is being designed. In order to take advantage of the benefits
that Houdini can offer to a pipeline, artists will need to design assets that are optimized for their
purpose. As mentioned before, if the goal of an asset is to design a small, cluttered, confined
space, then there is no need to give it the ability to generate a grand hall or a wide passageway.
Houdini can create very complex scenes, but designing with a game engine goal in mind means
that Houdini's capabilities need to be reasonably constrained.
➔ Poly-count
Performance in a game engine is highly attributed to the geometry's poly-count.
Subdividing the geometry for a smoother result is not recommended. When extruding the
traced floor plans to create the walls, there is no need to output front and back faces. If an
asset is going to be placed against a wall, or if the environment around it will prevent a player
from seeing it from the back, then it is not necessary to retain such excess geometry. In an
MMO, there can be hundreds of players visible at once on the screen, with each of their
systems having to display the environment at once. It is more important for poly-count to be
kept to a minimum in such an instance than it is, for example, in a single player experience, such
as in Naughty Dog's action-adventure shooter franchise Uncharted. In the third installment in
this series, Uncharted 3: Drake's Deception, instead of adding more detail through a higher polycount, which could have been successfully achieved due to improved graphical capability and
engine capacity, the decision was made to instead reduce poly-count, in order to optimize
assets and maximize overall performance.
19
33
Making these decisions will allow for users to
create the most useful assets possible.
➔ Scale
This point has been made, emphasized by the discussion in section 4.4. Scale can make
or break an interior space - it can completely change the impact that the space has on the
player. Knowing the use of the space that is being designed can help a designer place necessary
restrictions on a digital asset's output. If the interior space is going to house a great hall, meant
to hold multiple players or to serve as a central landmark, then the digital asset used to create it
will need to have adequate controls to create high ceilings, wide doorways, and tall windows. If
the space is meant to be a tight maze, cluttered with set dressing that provides obstacles for the
player to maneuver through, then the asset will need to include a limit on wall height and, as
the floor plans are developed, they will need to feature multiple rooms connected with winding
hallways and, potentially, hidden rooms and dead ends.
Details added to the interior space can help to emphasize the intended scale. If a room
is supposed to appear in a home, then adding floorboards, window sills, ceiling molding, and
doorknobs can help to reiterate an established sense of space. Lighting fixtures, chairs and
tables, even mirrors and hanging pictures can further enhance the believability of a finished
room. All of these details can be included and utilized by a digital interior designer.
19 “Uncharted 3 with Naughty Dog”. AREA: Digital Entertainment & Visualization Community.
<http://area.autodesk.com/inhouse/bts/uncharted_3_with_naughty_dog>
34
➔ Layout
The layout of an interior space
needs to be straightforward enough to
be explored by the player while being
interesting and varied, able to hold the
player's attention. The floor plans in Fig.
5.3 are the ones used in the structure
seen in Figs. 4.2 and 4.13. In each plan,
the small room to the far left is
Fig. 5.3 - Seven floor layouts
consistent, designating it as the central stairwell and acting as a means for the player to
acclimate to the space. This is a necessary element of level design, and seeing as how the
Houdini methods mentioned here allow for Houdini artists to fill the roles of level and
environment designers, it is important for level design tenants to be considered and
implemented while working in Houdini.
➔ The space between spaces
As mentioned in section 4.1, window and door jambs need to be present so that the
space appears to be as realistic as possible. Simply using the Delete or Blast SOP is not enough
to create these spaces. The Cookie SOP leaves the overlapping geometry behind when the door
and window rectangles are cut, bringing about more acceptable results. Variable wall thickness
affects these results and can be readily manipulated if its control is incorporated into the digital
asset's custom user interface. The thickness of the floors is also a feature to consider. Just as
the space between walls can be observed from pausing in a doorway, so can the space between
the different levels of the building when pausing on a ramp or in a stairwell. Adding floor
35
geometry with noticeable height can remove this anomaly and ground the building in reality, as
well as lift it off of the ground plane, giving motivation to exterior landings or entryways. Paying
attention to the space between spaces can also help to drive home the importance of scale, as
discussed above.
6. Houdini Engine Potential
The first iteration of the Houdini Engine
will allow for the exchange of geometry,
instanced or
otherwise, between software
packages. When the Houdini Engine installs an
asset into another package (for the time being,
only in Maya or Unity), it creates “a full session of
Houdini, complete with a scene and node
network, directly inside of the host application.”20
Fig. 6.1 is composed of images that can be
seen in demonstration videos currently posted on
the Side Effects site.
It shows a digital asset
functioning in Houdini that creates geometry
from text, fractures it, and calculates a rigid-body
simulation of it falling onto a ground plane. The
asset is saved and imported into both Unity and
Fig. 6.1 – Fracture text digital asset,
in Houdini, Unity, and Maya
20 “SideFX Labs: Houdini Engine FAQ”. sidefx.com. <http://www.sidefx.com/index.php?
option=com_content&task=view&id=2566&Itemid=387>
36
Maya, where it functions just the same as it did in Houdini.
By the time the Houdini Engine launches, it will be possible for multiple digital assets to
be imported into other packages.21 In essence, an entire environment can be built with Houdini
tools. There will no longer be a distinction between game environment artists and Houdini
artists: they can be one and the same.
The Houdini Engine will provide new possibilities for Houdini designers to work in a
multitude of arenas. It will also allow for game environment designers to utilize Houdini's
procedural power to create more sophisticated gaming experiences. However, for these new
opportunities to be exploited to their fullest, the digital assets that will be used will need to be
designed in a way that meets the needs of the game artist, while capitalizing on what Houdini
can do. Once Houdini users have made such a transition, they can design for a multitude of
projects in varying creative industries. Game design and film production will no longer be so
different. Artists will be able to focus on the construction of tools that can be used in both
pipelines. Houdini's versatility is ever expanding, and to take advantage of its possibilities,
artists must remain ahead of the curve. Adjusting to a new methodology of workflow
construction will aid users in such a transition.
6.1 In Conclusion
To demonstrate the potential of the Houdini Engine, interior spaces were chosen to be
designed and analyzed; the process by which they were created exemplifies the
design
methodology that has been discussed. It is important to note that constructing building
21 Ibid.
37
interiors requires that certain structural aspects are taken into consideration; aspects that differ
from those that prioritized when designing for a pre-rendered scene. For a gaming experience
to feel real to a player, the surroundings must propagate an illusion of realism and
probable/practical spatial design. Even if the scene is meant to be set in an unreal universe, the
space around the player needs to conform to what is accepted as the “norm”.
The most significant features that have to be addressed differently when designing
interiors for a game engine are:
➔ Poly-count : In-engine performance is based in part on the poly-count of the scene.
Keeping this to a minimum by only including what is vital or visible to the scene will help
to maximize execution.
➔ Scale (of set dressing, as well as of the space itself) : Scale can make or break immersion,
as well as determine whether or not the environment can be traversed.
➔ Overall layout and flow (the path that the player will follow during the experience) :
Orientation is just as crucial as maintaining interest and promoting challenge. The player
needs to be motivated to explore with a clear path ahead, while always being able to
backtrack, if necessary.
➔ Door and window jambs (the space between spaces) : As in the real world, the player
needs to experience every aspect of the scene, including the details that make it seem
real. Appropriately proportioned jambs add to this effect.
Once these elements of interior design are factored into the developmental process, Houdini
users can effectively create digital assets that will yield ideal results for a game engine.
38
Approaching interior design from a new angle serves to outfit Houdini users with a
means of applying their skills to a variety of digital creation venues. As the real-time rendering
power of gaming consoles and PCs escalates, studios can produce games that more closely
resemble the visual quality of major motion pictures. Keeping abreast of these changes and
remaining flexible with their workflow development, while employing new methodologies, such
as the one detailed here, will ensure that Houdini users remain in high demand.
39
Works Cited
Amaranth, Tobias. “A Full Guide to the First 4 Overworld Maps: An Overview of Map Creation
and Block Types”. incgamers.com, July 2011. <http://diablo.incgamers.com/forums/
showthread.php?824245-A-Full-Guide-to-the-First-4Overworld-Maps>
Bidarra, Rafael. “Guest Editorial: Procedural Content Generation in Games”. IEEE Transactions
on Computational Intelligence and AI in Games, vol. 3, no. 3, September 2011.
<http://www.academia.edu/1578545/Procedural_content_generation_in_games>
“Go Procedural: Video Games”. sidefx.com. <http://www.sidefx.com/index.php?
option=com_content&task=view&id=1590&Itemid=337>
“Guerilla Games Killzone 2“. <http://www.sidefx.com/index.phpoption=com_content&task
=view&id=1454&Itemid=68>
Margo, Ari. “5 Ways the Diablo III Expansion Could Improve Upon Its Predecessor”.
gamerhorizon.com, 2013. <http://gamerhorizon.com/5-ways-the-diablo-iii-expansioncould-improve-upon-its-predecessor/>
“News Articles: Houdini Engine”. sidefx.com. July 11, 2013. <http://www.sidefx.com/index.php?
option=com_content&task=view&id=2525&Itemid= 66>
“Nodes: Surface nodes”. Houdini 12.5 Docs.
<http://www.sidefx.com/docs/houdini12.5/nodes/sop/>
“Procedural Content Generation Wiki”. <http://pcg.wikidot.com/>
“Procedural Game Development: Kim Goossens”. <http://www.sidefx.com/index.phpoption=
com_content&task= view&id=2139&Itemid=68>
“Product Overview”. sidefx.com. <http://www.sidefx.com/index.php?
option=com_content&task=view&id=1021&Itemid=270>
Sicart, Miguel. “Against Procedurality”. 2010. <http://gamestudies.org/1103/articles/sicart_ap>
“SideFX Labs: Game Art in Unity”. sidefx.com. August 26, 2013. <http://www.sidefx.com/index.php
?option=com_content&task=view&id=2555&Itemid=387 >
“SideFX Labs: Houdini Engine FAQ”. sidefx.com. <http://www.sidefx.com/index.php?
option=com_content&task=view&id=2566&Itemid=387>
Slick, Justin. “7 Common Modeling Techniques for Film and Games: An Introduction to 3D
Modeling Techniques”. About.com 3D. <http://3d.about.com/od/3d-101-TheBasics/a/Introduction-To-3d- Modeling-Techniques.htm>
“SDM: Montgomery Hall, Montgomery Hall Map”. <http://www.sfdm.scad.edu/intranet/student/ >
“Uncharted 3 with Naughty Dog”. AREA: Digital Entertainment & Visualization Community.
December 6, 2011. <http://area.autodesk.com/inhouse/bts/uncharted_3_with_
naughty_dog>
“Unity Manual – Optimizing for integrated graphics cards”. Unity Manual. October 12, 2012.
<http://docs.unity3d.com/Documentation/Manual/OptimizeForIntegratedCards.html>
WChargin. “How does normal baking work?”. Blender beta. 08-20-2013.
<http://blender.stackexchange.com/questions/2466/how-does-normal-baking-work>
40
List of Visual Aids
“Houdini to Unity Workflow”
Duration: 11:38
“Part 1 – Generating Plans in Illustrator”
Duration: 02:40
Format: .mp4, H.264
➔ 7 floors, Walls and Doors
➔ Un-joined corners, View + Snap-to-Grid, Uniform Scale
➔ White border for scale
➔ Save a version and Join corners
➔ View White Border and each Layer
➔ File + Export + .png
➔ Export Settings
“Part 2 – Constructing the Building in Houdini”
Duration: 05:31
Format: .mp4, H.264
➔ Trace walls, ForEach (Extrude, Scale, ID Color)
➔ Trace doors, Extrude, Scale, ForEach (Translate)
➔ Trace windows, Extrude, Scale, Copy
➔ Cookie Doors from Windows
➔ Cookie Doors and Windows from Walls
➔ Cookie for Ramps
➔ Add Ramps and Entryway
➔ Export
“Part 3 – Testing Results in Unity”
Duration: 02:54
Format: .mp4, H.264
➔ Import New Asset
➔ Add to Scene
➔ Add Component (Mesh + Mesh Renderer, Physics + Mesh Collider)
➔ Texture
➔ Add Player Controller (Scale, Walk and Jump, Camera Angle)
➔ Test