Virtual Worlds on the Internet

Contents

• Introduction
• Virtual Reality Modeling Language (VRML)
• VRML versions
• Scene Graph Structure
• Event Architecture
• Sensors
• Scripts & Interpolators
• Prototyping
• Distributed Scenes
• Navigation in a VRML scene
• Virtual worlds on the Internet
• Introduction
• Requirements
• Characteristics of a multi user virtual world
• Virtual Worlds
• Designing a virtual community
• Installing the blaxxun community server
• Apache Webserver
• Blaxxun Community Server
• Publishing a virtual world
• VRML Tools
• preprocessor
• bmp2map
• vrmlgen
• Vrmlpad
• Spazz3D
• Designing worlds
• Case: Virtual VU Campus
• Science building
• Main building
• Provisorium
• VU square
• Flying disc animations
• Evaluation
• References
• Appendices

Introduction

This thesis is part of the RIF-project [1], which is a research project on Retrieval of Information in Virtual Worlds Using Feature Detectors. This project is a co-operation between the VU and the CWI (Centre for Mathematics and Computer Science). Members of the RIF-team are Anton Eliëns (projectleader, VU/CWI), Alex van Ballegooij (researcher,CWI) and Roland Blom (student,VU/CWI). Some of the tools I have used for the creation of the virtual world of the VU Campus were made by Alex and Roland.

My thanks go out to my parents and brother for supporting me in every possible way to help me finish this project. I would also like to thank my supervisors Anton Eliëns, Zhisheng Huang (VU) and Alex van Ballegooij for their advice and support during the time I worked on my thesis. I also thank all other people who have commented on my work in progress and gave me new ideas and tips about the virtual world.

Structure of the document

Virtual Reality Modeling Language (VRML)

VRML versions

VRML offers the following major features [2][3][6]:

Scene Graph Structure

The VRML file structure is a directed acyclic graph. This is a tree where all leaf entities are children nodes and all intermediate entities are group nodes. This scene graph structure makes it simple to create complex scenes out of more simple subparts.

VRML uses a coordinate system with three axes (x, y and z axis). These axes are related in the way as shown in the following figure. Linear distances are measured in metres and angles in radians. Colors are specified in RGB (red-green-blue) values in the interval [0..1]. Time units are specified in seconds. Every VRML 97 or VRML 2.0 file must begin with this line: #VRML V2.0 utf8

coordinate system in VRML

The 54 different VRML nodes can be divided in three groups, Grouping nodes, Children nodes, Field nodes. The Grouping nodes are a subset of the Children nodes. Field nodes are nodes that can only be used to describe the contents of a field. The standard VRML nodes can be extended from within a VRML file by using the Prototype mechanism [see Prototyping]. The following tables will show the nodes that are available in VRML.

Grouping Nodes

Children Nodes

Field Nodes

Every node can (and usually does) contain fields. These fields are the parameters of a node that distinguish it from other nodes of the same type. These parameters might be, for example, the size of a box defined by a Box node or the intensity of a DirectionalLight node. Every parameter has a default value that is used if no value for the parameter is specified in the VRML file.
Two kinds of fields are present in VRML:

• field

A field is a private parameter that will define (part of) the initial state of a node and cannot be changed.
• exposedField

An exposedField is a public parameter that also defines the initial state of a node and can be modified by other nodes (through events (see next paragraph)).

Field Types

The field types can be divided in two general classes, the single-valued fields (SF) and the multivalued fields (MF). The only difference is that single-valued fields contain a single value and multivalued fields can contain multiple values. All fields have strong type-checking, also between SF and MF fields.

When creating VRML scenes, it becomes usually necessary to be able to reference a previously used node (in the same file). Node referencing can be achieved
by using DEF and USE keywords. The DEF keyword defines a name to a node. The USE keyword can be used in every place where an instance of a previously DEF'ed node is wanted. There are several reasons for this reference mechanism. It can be used to make connections between nodes [see Event Architecture] and to lower the number of resources (texture files, sound files etc.) that need to be loaded, which results in a better performance. It also happens often that nodes are repeated in a VRML scene (for example, a scene of a forest of trees). Using DEF and USE prevents the author of a scene to retype the exact same code for every single object. Prototyping can also be used to prevent this.

Event Architecture

Sensors

#VRML V2.0 utf8

Viewpoint {
  position 0 0 15
}
DEF PROXSENSOR ProximitySensor {
  size 10 10 10
}
DEF TIMER TimeSensor {
  cycleInterval 5
}
Shape {
  appearance Appearance {
    material DEF BOX_COLOR Material {
      diffuseColor 1 1 1
      transparency 0
    }
  }
  geometry Box {
  }
}
Shape {
  appearance Appearance {
    material Material {
      diffuseColor 1 0 0
    }
  }
  geometry Sphere {
    radius 0.25
  }
}

ROUTE PROXSENSOR.enterTime TO TIMER.startTime
ROUTE TIMER.fraction_changed TO BOX_COLOR.transparency
ROUTE PROXSENSOR.exitTime TO TIMER.stopTime

Scripts & Interpolators

An Interpolator node is a node that is needed for stepwise keyframe animation. It contains a list of keys and a corresponding list of keyValues. An interpolator is often used together with a Timesensor node of which time values will be routed to the interpolator. The interpolator will use a time value as a key and the matching keyValue will be send to an eventOut. Key and keyValue pairs that are not listed in the interpolator are automatically generated by the interpolator. When combining an Interpolator with a Timesensor the keys have to be in the interval [0, 1], because the Timesensor uses values within this interval. When an Interpolator is getting its eventIns from a Script Node there is no value restriction. Six different types of interpolator nodes exist, each with a different type of value to be interpolated: ColorInterpolator, CoordinateInterpolator, NormalInterpolator, OrientationInterpolator, PositionInterpolator and ScalarInterpolator.

The following code is an example of a ColorInterpolator node and a Scipt node. The resulting VRML scene shows a sphere that changes colors continuously. It cycles through the colors that are listed in the ColorInterpolator. Each time the sphere is clicked with the mouse the Script node will receive an eventIn after which it will construct a string which is routed to the Text node:

#VRML V2.0 utf8

DEF COUNTER Script {
  eventIn SFTime touchTime
  field SFInt32 touchCount 0
  eventOut MFString outputString
  url "javascript:
  function initialize() {
    outputString = new MFString('Click sphere','to increase count');
  }
  function touchTime(value, time) {
    touchCount++;
    outputString = 'Count: ' + touchCount.toString();
  }
  "
}

Shape {
  appearance  Appearance {
    material  Material {
      diffuseColor  0 0 1
    }
  }
  geometry DEF TEXT Text {
    fontStyle FontStyle {
      justify "MIDDLE"
      size  0.5
    }
  }
}

DEF TIMER TimeSensor {
  cycleInterval 10
  loop TRUE
}

Transform {
  translation 0 -1 0
  children [
    DEF SENSOR TouchSensor {
    }
    Shape {
      appearance Appearance {
        material DEF SPHERECOL Material {
          diffuseColor 0 1 0
        }
      }
      geometry Sphere {
        radius 0.2
      }
    }
    DEF CI ColorInterpolator {
      key [0, 0.33, 0.66, 1]
      keyValue [ 0 1 0,
        0 0 1,
        1 0 0,
        0 1 0 ]
    }
  ]
}

ROUTE SENSOR.touchTime TO COUNTER.touchTime
ROUTE COUNTER.outputString TO TEXT.string

ROUTE TIMER.fraction_changed TO CI.set_fraction
ROUTE CI.value_changed TO SPHERECOL.set_diffuseColor

Prototyping

PROTO ColorBox [
  field SFColor boxColor 1 1 1
]
{
  Shape {
    appearance Appearance {
      material Material {
        diffuseColor IS boxColor
      }
    }
    geometry Box {
    }
  }
}

Distributed Scenes

The use of an Inline node is straightforward as can be seen in the following example.

Inline {
  url "http://www.cs.vu.nl/justaname.wrl"
  bboxCenter 0 0 0
  bboxSize 25 25 25
}

The EXTERNPROTO is not very different from the Inline node. Suppose a file with url http://www.cs.vu.nl/justaname2.wrl lists the ColorBox PROTO discussed earlier and some other prototypes. When the following piece of code is processed, it will load the ColorBox PROTO.

EXTERNPROTO ColorBox [ field SFColor boxColor ]
  url "http://www.cs.vu.nl/justaname2.wrl#ColorBox"
}

Navigation in a VRML scene

1. Walk

The Walk mode is one of the most natural ways to navigate through a VRML scene. In this mode the user will experience a sense of gravity which means that the user can't move into the sky, but is able to walk up and down on elevations. A staircase can be ascended or descended because height differences of no more than 0.5 metres will be crossed. The avatar will bump into any other objects.
2. Fly

Navigation by flying is a movement mode that is unaffected by gravitation. Movement can be done in any direction, until an object blocks the way.
3. Examine

Examine mode is an extended Rotate mode. Examine will not only rotate objects around the y-axis, but is also capable of rotating them around the other axes. It offers a good way to examine objects from all sides because it is a lot easier than having to walk around an object and keeping it in your line of sight. Be aware however that this navigation type could easily disorientate the user, because it is also possible to pass through objects and thus wind up inside one.
4. None

This navigation mode is actually no navigation mode at all. It tells the browser to make the other navigation modes unavailable. This is very useful if the author of a scene wants complete control over where the user is and can go to. For this purpose a viewpoint tour or an own system of movement controls inside the scene (in the form of buttons in VRML, for example) can be created.

1. Slide

Sliding is a type of navigation where the user will always face the same direction. Left and right will, instead of  turning the user left or right as in Walk mode, make the user move to the left or right. Forward and back will operate as expected.
2. Pan

Forward and back will make the user look up and down instead of moving forwards and backwards. This is a good mode for looking up and down a large object just in front of the user.
3. Rotate

Rotate mode will rotate around the point where the mouse pointer is at, around the y-axis using the left and right controls. Forward and back will operate normally.

• Gravity

The Gravity option controls the existence of gravity in the scene. When on, a user that walks off a ledge will fall down on a lower object (if any). When gravity is off, that same user will be floating in air and thus be capable of just stepping on the ledge again.
• Collision

The Collision options control whether the viewer will check for collision. With this options on, a user will be blocked by objects and will have to go around them to pass them. Collision turned off will result in the user being able to move through objects.

Virtual worlds on the Internet

Introduction

In this chapter a description will be given of several of these multi-user virtual worlds. The focus will be on virtual worlds that show their 3D content in VRML.

Requirements

Software

Virtual multi-user worlds need a server that distributes the changes in the virtual worlds to all users. One of the major servers at this moment is Blaxxun Community Server [8]. Other Servers are Helios [9], DeepMatrix [10], VNET [11] and Active Worlds Server [12].
For a list of existing VRML browsers and servers see [Appendix B].

Hardware

Characteristics of a multi user virtual world

Interaction

Support for multiple users

Immersion

Virtual Worlds

Blaxxun Community Server

• 3D Places and Avatars

Large parts of these communities consist of 3D places, created in VRML, which can be visited by users. Each 3D place has a Java-based chatbox where people can interact with each other. Each user is represented by an 3D avatar, which can be chosen from an avatar library or created by the user himself. A basic set of avatar gestures (wave, smile, laugh etc.) is available to animate the avatars.
• Membership

Users may enter a community for the first time as guests. This gives them the opportunity to find out what goes on in the community. If a user wants to join a community he can become a member of this community. Virtual communities offer additional features to their members, for example members may own a (3D) virtual home, which also serves as a private chatbox.
• Economy and Social Status

Members who participate actively in the community earn virtual money and experience points. The money can be spend in virtual shops where furniture for houses can be purchased. Experience points may give a member additional rights and privileges, such as access to elite member areas and the opportunity to apply for virtual jobs in the community. These jobs vary from security guard to groundskeeper and from shopkeeper to major.
• Objects

Objects in communities are virtual items that can be created, traded, dropped, picked up and deleted. If a member wants to decorate his home with furniture he can buy items in a virtual shop. These items are then placed in the member's 'backpack'. In certain parts of the community like the member's home these items can be dropped and moved around. Because these objects are 'shared' other users can immediately see the manipulations performed on the objects.

Cybertown

Cybertown [13] is one of the largest (VRML) communities on the Internet at this moment, both in size and in number of members. Cybertown consists of a vast amount of 3D places, among which are a casino, pool, city hall and stadium. In the casino several (mostly Java) games can be played as well as a VRML-based bowling game. Cybertown offers also multi user games where users have to interact with each other to play it. In the stadium a multi user VRML 'soccer' game between two teams can be played. Members can also join in a multi user adventure game where two teams of players compete in missions and battles. Cybertown has more than 3000 interest clubs where members may discuss special topics of interest.


Cybertown community

Soccercity

Soccercity [14] is a virtual community specifically meant for soccerfans. The language used here is german. It consists of some rather small VRML environments and has the normal features of the Blaxxun worlds, like the membership, homes and shops where some soccer-related objects can be bought. A little VRML soccer game can be played here and there is a small amount of information about soccer available on html-pages.


Soccercity community

Learnetix

Learnetix [15] is a community adressing German schoolchildren who can, besides moving in not very large virtual places and chat with each other, ask other users for help with their homework. This community also supports membership, housing and shared objects. Learnetix offers more than 1000 clubs which can be joined by members. A large part of this world consists of 2D information in the form of puzzles, quizes and information about classes like math, german and english.


Learnetix community

Canal Plus Second world

 The Canal Plus Second World community [16] is a place for artists and art fans. The main language used here is french. Several real world places that are located in Paris can be explored in this community. For example the Louvre Museum is completely build in VRML, where people can see lots of art and often can get additional information about pieces of art on an html-page. There are several commercial areas, where people can examine products in 3D. A nice example is the Peugeot showroom where several cars can be viewed.


Canal + Second World community

DeepMatrix

VNET

Helios

Active Worlds

Designing a virtual community

Installing the Blaxxun Community Server

Apache Webserver

ServerAdmin you@your.address

DocumentRoot "C:/Program Files/Apache Group/Apache/htdocs"

<Directory "C:/Program Files/Apache Group/Apache/htdocs">
    Options Indexes FollowSymLinks MultiViews
    AllowOverride None
    Order allow,deny
    Allow from all
</Directory>

The above text should be replaced by a text that looks similar to the text below (with the correct emailadress, hostname and directories). Note that these texts do not appear entirely the same in httpd.conf, because all options are explained in that file.

ServerAdmin fedozzi@cs.vu.nl

ServerName bruin011.cs.vu.nl

DocumentRoot "C:/blaxxun/CommServ/commserv/community"
<Directory "C:/blaxxun/CommServ/commserv/community">
    Options Indexes FollowSymLinks MultiViews ExecCGI
    AllowOverride None
    Order allow,deny
    Allow from all
</Directory>

Alias /csadmin c:/blaxxun/CommServ/csadmin
ScriptAlias /csadmbin c:/blaxxun/CommServ/csadmbin
Alias /commserv c:/blaxxun/CommServ/commserv
ScriptAlias /csbin c:/blaxxun/CommServ/csbin

<Directory "C:/blaxxun/CommServ/">
Options Indexes FollowSymLinks MultiViews
AllowOverride None
Order allow,deny
Allow from all
</Directory>

<Directory "C:/blaxxun/CommServ/csadmin">
Options Indexes FollowSymLinks MultiViews ExecCGI
AllowOverride None
Order allow,deny
Allow from bruin011.cs.vu.nl
</Directory>
 

The last step in installing Apache is to start it. This can be done in the Services menu that can be found on the Control Panel of Windows. Apache can be started manually each time, but it is best to select automatic install which will start Apache whenever the computer is booting.

Blaxxun Community Server

• idserver

The ID server handles logins and logoffs by users.
• mnserver

The Motion server handles the locations and location changes of users in the scenes.
• txserver

The Text server handles all text interaction between users.
• auserver

The Authentication server handles user registration and authentication.
• cpserver

The Proxy server handles TCP connections by clients (to work through firewalls). Normally clients use UDP connections.
• haserver

The HTML Access server handles client connections of Blaxxun's HTML chat client.
• mdserver

The Moderation server takes care of moderation of the users that are chatting.

After all necessary services are started the community can be accessed by entering the hostname as an URL (Uniform Resource Locator) in a webbrowser. The administrative tools of the community can be accessed at http://bruin011.cs.vu.nl/csadmin.
 

Publishing a virtual world

SHOWSCENE http://bruin011.cs.vu.nl/commserv/communityplace?plc=VUCampus&ID=000000000000000b&ac=3D&IE=x.bxx Vu Campus

After doing all of the above, the virtual world should now be accessable for everyone on the Internet.
 

VRML Tools

Preprocessor

bmp2map

input bmp-file

output of bmp2map

The following colormap file will generate a map-file where all 'a' characters are substituted by 'r' characters. Note that the colormap is in BGR (blue-green-red) format instead of RGB.

. 0.000000 0.000000 0.000000
r 0.000000 0.972549 0.972549

Vrmlgen

In a map-file every character represents a building block. The attributes of the building blocks will depend on the various options that can be specified in the configuration file. In principal every printable ASCII-character can be used, but some characters have a special purpose. For every '.' in the map vrmlgen will not generate anything, because the '.' means there is an empty place on the map. An option can be turned on that will instruct vrmlgen to generate viewpoints where a '<', '>', '^' or a 'v' is on the map. The '<' will become a viewpoint with orientation to the left and so on.

The first thing that has to be determined is the unitsize you want to use for a basic building block. A block must be of the form x * y * z (where x = z and y = 1.5x). So a unitsize of 0.5 will result in a block that measures 0.5 by 0.75 by 0.5.

After the tag [colors] every character in the map file can be assigned a color. The default color is yellow. The color should be given in RGB format, just like in VRML. The following example will let vrmlgen generate a gray block for every 'a' in the map, a blue block for every 'b' and a green(ish) block for every 'c':

[colors] {
  a 0.72 0.72 0.72 0
  b 0.00 0.00 1.00 0
  c 0.06 0.55 0.06 0
}

Vrmlgen offers the ability to map textures on objects. At most 6 different textures can be added to an object. On the top, bottom, left, right, front and back faces of an object textures can be mapped by specifying the filename (and pathname) of the image file and on how much horizontal and vertical building blocks one instance of the texture image should be mapped. For example, suppose the top face of an object is build up out of 20 (horizontal) by 15 (vertical) blocks and in the vrmlgen configuration is specified:

[toptextures] {
  c 5 5 0 "grass.png"
}

This will result in a top face where the texture image is mapped to 12 times (four rows of three images). For the other faces the according tags ([fronttextures], [bottomtextures], [righttextures], [fronttextures] and [backtextures]) can be used. In case the four sidetextures all should be the same, the tag [sidetextures] can be applied.

The largest part of the configuration file consists of the maps of the object(s) that vrmlgen will generate. The size and amount of the maps that follow must be specified first. A map can be used repeatedly by using the repeat statement. repeat 2 means that the previous map will is repeated twice.

[maps]
  dx 20
  dz 15
  nrmaps 10

/* maps 1 to 3 listed here */
repeat 6
/* map 10 listed here */

An extra feature of vrmlgen is that objects, that already were created as prototypes, can be inserted in the world by adding a character in the map-file for each instance of that object you want in a world and add some lines to the corresponding vrmlgen configuration file. Vrmlgen will place these objects in the appropriate locations in the world. For example, you may want to include a tree on several places in the map. By including the following lines to the configuration file and adding the 't' character to the right places of the map file this can be done. Anything in between the [literal] and [/literal] tags behind the [litincludes] tag will exactly be added to the generated VRML file. The first number (1 or 0) after the t in the [specialnodes] tag indicates whether the t does or does not also represent a block on the map. The second number (1 or 0) indicates whether an offset is or is not specified after the map the t occurs in. If so, this offset will replace the variables in the translation field. The third number specifies the number of extra parameters that are specified after the map. In the (simple) example of the shed the tree will have an extra translation to position the bottom of the tree on the grass.

[litincludes]
[literal]
# VRML code for the Tree PROTO is added here
[/literal]

[specialnodes] {
  t 0 1 0
  [literal]
    Tree {
      translation   %.2f %.2f %.2f
      woodtexture   ImageTexture {url "treewood.jpg"}
      leavetexture  ImageTexture {url "treeleaves.jpg"}
    }
  [/literal]
}

The bmp-files and configuration file that are needed for the example of a shed can be seen in [appendix C]. The resulting VRML scene is shown in the following picture.

Vrmlpad

Spazz3D

Designing worlds

Creating maps of the world

Texture mapping objects

The filesize of a VRML file is usually the smallest part of a large VRML scene. The texture files on the other hand are often quite large. The larger the files are, the longer of course the loading time of a VRML scene will become. Another disadvantage is the fact that the world will render a lot slower while the user is moving around the scene. So it is recommended to try to keep the filesizes of the textures as small as possible. However, (smaller) images that are used as textures on larger faces will blow up the pixels. The choice has to be made here between a fast(er) or a nice(r) scene. There are two techniques that will help in combining these two choices:

• Repeating textures

Some objects with large faces need textures that have some kind of repetitive structure. For example, a brick wall or a side of an office building covered with the same windows can very well be mapped with a relatively small texture. For the brick wall a texture of about five rows of five bricks could be used. The texture should not be taken to small, because it will look monotonic and unreal if ,for example, just one brick is repeated over and over again. It should be avoided that it is easily visible for the user that the same texture is repeated. By using these smaller texture images the quality of the scene remains as good as unaffected, but loading time and render time will improve.
• Using grayscale images

In VRML grayscale images can be used for colored textures by assigning a color and a grayscale texture to the object that is to be mapped. VRML will display both the texture and the color so it will look as if a colored texture is used. The restriction that applies here is that only one color can be assigned to an object, so this can only be done by texture with one color. The use of grayscale images is, for example, very useful for the brick wall textures or the texture of a grassland.

Limiting a virtual world

Limiting a virtual world as described above is not foolproof. As long as a user stays in Walk mode he will indeed stay caught inside the world. However if a user turns on the Examine mode, collision detection is no longer applied which will result in the user's avatar being able to move through objects which in turn can lead to the avatar ending up outside the world limits or even worse inside an object. The Rotate navigation mode creates the same problem although collision detection is still applied for most objects except the object that the user is rotating around, so if the user for example rotates around the 'floor' of the world he might get stuck beneath the world. If the virtual world is not only limited by 'walls' but also by a 'ceiling' the Fly mode poses no problem at all. The nature of the virtual world that is being build is important in determining whether it is necessary to limit the world. When you are building part of the real world as a virtual one, boundaries are a good addition to your world. If the world however is a imaginary place there are no arguments against positioning it floating in a large empty sky.

CASE: Virtual VU Campus

General

The main directory stores the files Makefile, vu.prewrl and vrmlgenoptions.lego and the following subdirectories:

• bmp: All bitmaps that will be converted into maps are contained in this directory.
• colormaps: I have chosen to supply every bitmap its own colormap that will be used to generate the correct map files with bmp2map. Another option would have been to use a single colormap for all bitmaps, but this results in a large number of characters in the map files.
• include: The include directory contains all VRML prototypes and other VRML code that are not generated by vrmlgen, but is needed to build the world.
• intermediate: The use of the Makefile, bmp2map and vrmlgen result in the generation of several intermediate and temporary files. These files are stored in this directory.
• prelego: The prelego directory is used for the configuration files of vrmlgen.
• release: In this directory the final VRML file is stored. All VRML code, including the prototypes, is written in this single file.
• textures: All textures that will be mapped on one or more objects are stored in this directory in the Portable Network Graphics (PNG) format.

Science building

When several bitmap images with a lot of different colors are used in one configuration file it might become difficult to keep using colors that can be easily distinguished from each other by the human eye. This can be solved by using the same color more than once in different images and mapping different characters to it with the colormaps of bmp2map. Doing this will keep the editing of the images relatively simple and keep it possible to map lots of colors and textures to the 3D objects.

The next step was to 'paint' the building with the appropriate colors and textures. It is always useful to even color the parts that have textures, so it will have that color when for some reason the texture image doesn't load. It's quite simple with vrmlgen to assign colors and textures to the objects and scale the textures in the right way.

When texture mapping 3D objects it is of course necessary to have the texture images that are needed available. A lot of more or less standard textures like bricks, grass and water can quite easily be found on the Internet. The more specific textures like the windows of the top floor of the science building I had to photograph myself. I could borrow a digital photo camera through one of my supervisors, Zhizheng Huang, that I used to take many photos of the VU Campus. The problem with taking photos to be used as textures is that you have to try to stand directly straight in front of the object in order to get good quality photographs. Otherwise the photos might get a distorted effect in them. For example, the top floors on some of the texture mapped buildings seem to topple forwards, because the textures were photographed under a sometimes rather large angle from the ground. Editing with Paint Shop Pro can help a little to decrease the effects of these distortions, but it will remain visible for the trained eye.

Main building

Provisorium

VU Square

Trees & Lampposts

Flying Disk Animations

Limiting the virtual world

Evaluation

Creating a virtual world with vrmlgen is a task that doesn't require a lot of 3D design knowledge, because the program works only with 2D maps. On the other hand, it is necessary to have some knowledge about computers, because vrmlgen has to be operated from the command prompt and works with configurationfiles that have to be edited. A nice graphical user interface would help to lower the level of computer knowledge that is needed to work with vrmlgen.
Vrmlgen is very much suited for modeling rectangular 3D objects. Other  (non-rectangular) objects will have to be created with other programs, but can be integrated quite simply within the generating process of vrmlgen. The ability to map textures on the 3D objects is another useful feature of the program.

In the future the VU Campus virtual world will serve as a basic 3D environment that can be improved and extended by students that take part in a VRML course on the Vrije Universiteit. Particularly in the areas of interactivity and immersion the current world might be enhanced.

References

[2] Carey R., Bell G., The annotated VRML 2.0 reference manual (1997) ISBN: 0-201-41974-2
    (website: http://www.best.com/~rikk/Book/)
[3] Hartman J., Wernecke J., The VRML 2.0 Handbook - Building Moving Worlds on the Web (1996) ISBN: 0-201-47944-3

[4] VRML97 Specification (ISO/IEC 14772-1:1997) - http://www.web3d.org/Specifications/VRML97/
[5] Vu Campus World (will be closed somewhere in september 2000) - http://bruin011.cs.vu.nl
[6] Floppy's VRML Guide - http://www.vapourtech.com/vrml
[7] Bob Crispen's VRML Site - http://home.hiwaay.net/~crispen/vrmlworks/

[8] Blaxxun (Contact, Community Server) - http://www.blaxxun.com
[9] Parallel Graphics (Helios, Islands, Cortona VRML Browser, Vrmlpad) - http://www.parallelgraphics.com
[10] Geometrek (Deepmatrix) - http://www.geometrek.com
[11] VNET - http://ariadne.iz.net/~jeffs/vnet/
[12] Active Worlds - http://www.activeworlds.com
[13] Cybertown  - http://www.cybertown.com
[14] Soccercity  - http://www.soccercity.de
[15] Learnetix  - http://www.learnetix.de
[16] Canal + 2nd World - http://virtuel.cplus.fr

[17] Apache Software Foundation - http://www.apache.org
[18] Blaxxun Instant Community Help - http://www.blaxxun.com/products/server/docs/41/ntv4.1/overview.html
[19] VRML preprocessor webpage - http://www.cwi.nl/blaxxun/software/preprocessor/preprocessor.html
[20] Vrmlgen webpage - http://www.cwi.nl/reblom/vrmlgen.html
[21] Spazz3D - http://www.spazz3d.com

[22] Shout3D - http://www.shout3d.com
[23] Pulse3D - http://www.pulse3d.com
[24] Blendo - http://www.web3d.org/TaskGroups/x3d/sony/Blendo.html
[25] Lego - http://www.lego.com

Appendices

Appendix A

Virtual Worlds - Table of Properties

Appendix B

Virtual Worlds browsers

Virtual Worlds servers

Appendix C: vrmlgen example of a shed

bmp-files:

map 1

map 2

map 3 - 9

map 10

configuration file:

[options]
unitsize             0.25
usedefaultlights     1
usedefaultviewpoints 1
showgroundplane      0
uselegoshape         0
showknobs            0
combinefaces         1
legofaceincfile      ""
legoshapeincfile     ""
legoknobsincfile     ""

[litincludes]
[literal]
PROTO Tree [
  exposedField SFVec3f translation      0 0 0
  exposedField SFInt32 size             1
  exposedField SFNode  woodtexture      NULL
  exposedField SFNode  leavetexture     NULL
]
{
  Transform {
    translation IS translation
    children [
      Transform {
        translation 0 1.8 0
        children [
          Shape {
            appearance Appearance {
              material Material {diffuseColor 0 .6 0}
              texture IS leavetexture
            }
            geometry Sphere {
              radius 1
            }
          }
        ]
      }
      Shape {
        appearance Appearance {
          material Material {diffuseColor .6 .3 0}
          texture IS woodtexture
        }
        geometry Cylinder {
          radius .2
          height 2
          top    FALSE
          bottom FALSE
        }
      }
    ]
  }
}
[/literal]

[colors] {
/*  a 1.00 0.33 0.06 0 */
  a 0.72 0.72 0.72 0
  b 0.00 0.00 1.00 0
  c 0.06 0.55 0.06 0
}

[toptextures] {
  b 10 6 0 "roof.png"
  c 5 5 0 "grass.png"
}

[sidetextures] {
  a 4 4 0 "brick.png"
}

[specialnodes] {
t 0 1 0
[literal]
Tree {
  translation    %.2f %.2f %.2f
  woodtexture   ImageTexture {url "treewood.jpg"}
  leavetexture  ImageTexture {url "treeleaves.jpg"}
}
[/literal]
}

[maps]
dx 20
dz 15
nrmaps 10

/* 1st map */
/*
dx 20
dz 15
*/
cccccccccccccccccccc
cccccccccccccccccccc
cccccccccccccccccccc
cccccccccccccccccccc
cccccccccccccccccccc
cccccccccccccccccccc
cccccccccccccccccccc
cccccccccccccccccccc
cccccccccccccccccccc
cccccccccccccccccccc
cccccccccccccccccccc
cccccccccccccccccccc
cccccccccccccccccccc
cccccccccccccccccccc
cccccccccccccccccccc
/*
 .  0.000000 0.000000 0.000000
 a  0.000000 0.000000 0.972549
 t  0.000000 0.972549 0.000000
 b  0.000000 0.972549 0.972549
 c  0.972549 0.000000 0.000000
*/

/* 2nd map*/
/*
dx 20
dz 15
*/
....................
.aaaaaaaaaaaaa......
.a...........a......
.a...........a......
.a...........a......
.a...........a......
.a...........a......
.a...........a....t.
.a...........a......
.a...........a......
.a...........a......
.a...........a......
.a...........a......
.aaaaa....aaaa......
....................
/*
 .  0.000000 0.000000 0.000000
 a  0.000000 0.000000 0.972549
 t  0.000000 0.972549 0.000000
 b  0.000000 0.972549 0.972549
 c  0.972549 0.000000 0.000000
*/
/* offset for tree */

0 1.4 0
 

/* 3th map */
/*
dx 20
dz 15
*/
....................
.aaaaaaaaaaaaa......
.a...........a......
.a...........a......
.a...........a......
.a...........a......
.a...........a......
.a...........a......
.a...........a......
.a...........a......
.a...........a......
.a...........a......
.a...........a......
.aaaaa....aaaa......
....................
/*
 .  0.000000 0.000000 0.000000
 a  0.000000 0.000000 0.972549
 t  0.000000 0.972549 0.000000
 b  0.000000 0.972549 0.972549
 c  0.972549 0.000000 0.000000
*/

/* 4th map to 9th map */
repeat 6

/* 10th map */
/*
dx 20
dz 15
*/
bbbbbbbbbbbbbbb.....
bbbbbbbbbbbbbbb.....
bbbbbbbbbbbbbbb.....
bbbbbbbbbbbbbbb.....
bbbbbbbbbbbbbbb.....
bbbbbbbbbbbbbbb.....
bbbbbbbbbbbbbbb.....
bbbbbbbbbbbbbbb.....
bbbbbbbbbbbbbbb.....
bbbbbbbbbbbbbbb.....
bbbbbbbbbbbbbbb.....
bbbbbbbbbbbbbbb.....
bbbbbbbbbbbbbbb.....
bbbbbbbbbbbbbbb.....
bbbbbbbbbbbbbbb.....
/*
 .  0.000000 0.000000 0.000000
 a  0.000000 0.000000 0.972549
 t  0.000000 0.972549 0.000000
 b  0.000000 0.972549 0.972549
 c  0.972549 0.000000 0.000000
*/