|
|
|
|
|
- 2003-10-27 : It seems that several people out there are interested in
my Syndicate level viewer. I've scraped together all of my Syndicate-related code
and packaged it in one tidy tarball; you can download it from the sourceforge
file-release page. If you download it, make sure to read the README file.
Also, the RNC decompressor can be found at
this site. Enjoy.
BTW - SIGGRAPH went over well, but I'm still unemployed.
- 2003-07-09 : I've been working on CityBuilder a great deal recently.
This is because of a very interesting (and very recent) development: CityBuilder
will be shown at SIGGRAPH 2003! WooHoo! By "shown" I don't mean that
it will be one of the projects shown in one of the main auditoriums; you need to
be really good to get your stuff shown there (there's a selection
process, etc). My video will instead be shown at RIT's booth, along with two of my
classmates' projects. The CityBuilder video is nearly 7 minutes long, and
features a 3-minute tour of a city created with CityBuilder, followed by a 4-minute
"how does one create a city using CityBuilder" section.
- 2003-07-09 (continued) : In preparation for creating the video, I've made
many changes to the CityBuilder utilities and the related tools. The lot-division
code was re-written; "named channels" were implemented; the ability to have streets
of various widths was added; the ability to have streets with no width
was added; various fixes were made. Additionally, the GraphThing, KludgeBuilder,
and CityViewer programs were enhanced. I also wrote several new utilities to help
with creating the video.
I have uploaded the new versions of the utilities. Also, the KludgeBuilder and
CityViewer programs have been publically released for the first time. The versions
of the utilities that are currently on SourceForge are the same versions that I used
to create the SIGGRAPH video. The documentation hasn't been updated to reflect the
recent changes, and some of the documentation is missing entirely. The new docs,
as well as two new utilities, will be uploaded eventually.
- NOTE - Currently, the data files are not distributed with CityBuilder.
(The data files include the building models, textures, etc.) As such, the user will
have to create their own data files in order to create cities. There are several
reasons for my not distributing the data files:
- Size concerns - The data files are currently 75 MB total. I access the internet
via dial-up. You do the math.
- Philosophical concerns - Were I to distribute my data files, users would be
tempted to simply copy my artwork and pass it off as their own (not that it's all
that great, but...). I would like to encourage people to create their own artwork.
In the future, I will likely put together a small set of data files. It would be a
"sample" or "demonstration" city, to get people started. However, the "full" set
of data files will not, for the moment, be released.
|
|
|
|
|
|
CityBuilder is an attempt to automate much of the work involved in creating
very large virtual urban landscapes. The system takes a street map as input,
and produces street geometry and a scene graph containing the building models
as output. The user has control over the types of buildings placed in the city
through the use of image maps. The potential applications for this system
include video game content (think GTA*), visualization, etc.
It is well known to most of those in the field of computer graphics that
mountainous terrain can be generated programmatically. A good deal of
research has been done in this area, focused for the most part on the use of
fractals to generate landscapes. While these techniques produce some
impressive results, they are restricted in the kinds of terrain that they can
generate. For example, these techniques are not appropriate for the creation
of urban terrain.
This is unfortunate, as there are many benefits to being able to
programmatically generate urban landscapes. Many recent video games, for
example, feature very large urban environments. Finding little research on
the topic of urban terrain generation, I decided to create my own utilities
for that purpose.
Note - I have recently been made aware that a very similar project was
published at SIGGRAPH 2001, entitled "Procedural Modeling of Cities".
That project made use of L-systems to generate the street topographies
(mine uses a user-created node graph) and (from the description) is
considerably more complex. I haven't seen their output. If you're interested
in this sort of thing, you might want to take a look at their work, too.
With the CityBuilder system, there are three stages in the creation of a city.
The first stage is to create the street map, the building models, and some
miscellaneous support files used by the second stage. The second stage is
where CityBuilder takes control. Street geometry is created using the
StreetBuilder component, building models are placed in the city by the
BlockBuilder component, and miscellaneous items like traffic lights are placed
in the city by the ClutterBuilder component. The third stage is to fine-tune
the output using a scene-graph editor or by hand-editing the output files.
The city is then ready to be viewed.
|
|
|
|
|
|
Recent video games featuring large city-scapes, such as the GTA series, were
produced by trained professionals, over the course of months/years. The
cities they have produced are stunning in their size and complexity.
In contrast, the cities produced by CityBuilder can be completed in an
afternoon. The
system was written by a single undergraduate over the course of 3 months.
As a consequence, one should not expect the same level of quality as
that of the GTA cities.
Then what good is it, you ask?
One possible use would be rapid prototyping for game engine testing. It
may or may not surprise you to
know that game engines, such as that used by GTA3, are developed
simultaneously as the content for the game is being developed.
CityBuilder-generated cities can provide game programmers with
a useful test-bed for testing the engine while it is under development, and the
primary game content is unavailable. A "stand-in" of sorts.
Don't let this discourage you, though. You can, of course, produce much
higher quality cities than the demo city that I've put together for this
system. It all depends on how much time you're willing to put into it.
And, since it's open-source, you can make improvements to any of the
components of CityBuilder. Want curved sidewalk corners, just like GTA3's?
Modify Streetbuilder.
|
|
|
|
|
|
My motivation for writing this system stems from my obsession with a computer
game published by Bullfrog Software in the early 1990's. The game is
Syndicate. The titles published by Bullfrog Software (now part of the
Electronic Arts empire) were, for the most part, what are called "god sims,"
and Syndicate was no exception. As the player, one is given control over
a squad of 4 agents, and the goal is to use these agents to accomplish various
goals throughout the 20-odd cities, located around the world. These city
levels were the central attraction of the game. They were absolutely
huge levels for the time; keep in mind that this was 1992, and the
average PC was a 386 with about 2 MB of RAM.
I liked the level artwork for Syndicate so much that I actually
reverse-engineered the file formats (which took a considerable amount of time,
as the image files were stored with the bits all mixed up and out-of-order).
I even wrote a level viewer for Syndicate. However, times have changed.
Isometric games, using 2D sprites, have gone the way of the dodo
(The Sims being the exception).
The current trend is 3D. Indeed, the sequel to Syndicate, Syndicate Wars,
used 3D graphics for the buildings, streets, and vehicles. For a while, I
toyed with the idea of reverse-engineering the file format for the
Syndicate Wars levels, but unlike the Syndicate files, there doesn't seem to
be any discernable pattern or logic behind the structure of the files.
Since then, I've been toying around with the idea of creating my own city
levels, rather than using others'. My other major software project, the
kludge3d modeler was, in part, the result
of some of my early efforts to create virtual urban terrain. I needed a
3d editor and, dissatisfied with most of the free linux modelers of the time,
decided to hack together my own. Kludge3d is adequate for simple model
creation, but it wasn't really designed for creating very large, complex
models.
As a result, I decided that a better way to go would be to create the larger
environments from smaller components, and use a scene-graph-style layout for
storing the world. So I took the then-current version of kludge3d and tore
out the guts. By "guts" I mean the texture-editing, vertex manipulation, and
so forth. I then added the ability to load and place multiple, external
geometry files in the scene, resulting in a utility not unlike a scene graph
editor. Similar utilities exist... I remember a Java utility that did
something similar, and I believe that at least one of the major 3d-editor
vendors (the Lightwave people, possibly?) had such a product as well.
When I was given the opportunity to choose my topic for my quarter-long
Computer Graphics II project, I decided to pursue the idea of eliminating
much of the work required to create urban environments. CityBuilder is the
result.
|
|
|
|
|
