Christoph AnthesRoland LandertshamerMarina Lenger Tutorial I - Medieval Town

Christoph Anthes Roland Landertshamer Marina Lenger

Tutorial ITutorial I--

Medieval TownMedieval Town

12.06.09 inVRs - Tutorial I - Medieval Town 2

OverviewOverview

• IntroductionIntroduction• Architecture OverviewArchitecture Overview• TutorialTutorial

– OverviewOverview

– Step 1 – Basic Application DevelopmentStep 1 – Basic Application Development

– Step 2 – Navigation and SkyboxStep 2 – Navigation and Skybox

– Step 3 – Transformation ManagementStep 3 – Transformation Management

– Step 4 – InteractionStep 4 – Interaction

– Step 5 – Using Network CommunicationStep 5 – Using Network Communication

– Step 6 – Developing own Application LogicStep 6 – Developing own Application Logic

• OutlookOutlook• AcknowledgementsAcknowledgements


Introduction andIntroduction andArchitecture OverviewArchitecture Overview


IntroductionIntroduction

• inVRsinVRs ((iinteractive nteractive nnetworked etworked VVirtual irtual RReality eality ssystem)ystem)– PronouncedPronounced

– C++ Application Framework for Networked Virtual Environments (NVEs)C++ Application Framework for Networked Virtual Environments (NVEs)

• Publicly available under Publicly available under www.invrs.orgwww.invrs.org (under LGPL) (under LGPL)– Uses Trac system for distribution Uses Trac system for distribution

• Alternatively latest stable release as zipAlternatively latest stable release as zip

– Available for Linux, Windows, Mac OS X and maybe IRIXAvailable for Linux, Windows, Mac OS X and maybe IRIX

• Variety of out-of-the-box FeaturesVariety of out-of-the-box Features– Network communication supporting close coupled collaborationNetwork communication supporting close coupled collaboration

– Clear definition for navigation and interaction (with many techniques provided)Clear definition for navigation and interaction (with many techniques provided)

– Designed for reusability of developed componentsDesigned for reusability of developed components

– Easy-to-use configuration for immersive devicesEasy-to-use configuration for immersive devices



• Documentation available on Trac SystemDocumentation available on Trac System– Several publications (BiBTex files)Several publications (BiBTex files)

– Tutorial examplesTutorial examples

– Medieval Town Tutorial (on which these slides are based on)Medieval Town Tutorial (on which these slides are based on)

– Programmers’ Guide (coming soon)Programmers’ Guide (coming soon)

– Doxygen (Doxygen (http://http://doxygendoxygen.invrs.org.invrs.org//))

• LibrariesLibraries– RequiredRequired

• OpenSG v1.8 (OpenSG v1.8 (http://http://www.opensg.orgwww.opensg.org//))

• GMTL distributed with source (GMTL distributed with source (http://http://ggt.sourceforge.netggt.sourceforge.net))

• IrrXML distributed with source (IrrXML distributed with source (http://www.ambiera.com/irrxml/http://www.ambiera.com/irrxml/))

• CMake (CMake (http://http://www.cmake.orgwww.cmake.org//))

– OptionalOptional

• OpenAL and ALUT (OpenAL and ALUT (http://http://www.openal.orgwww.openal.org//))

• ODE (ODE (http://http://www.ode.orgwww.ode.org//))

• trackD (comes with CAVELib)trackD (comes with CAVELib)



• Where to position Where to position inVRsinVRs in the development approaches for VR in the development approaches for VR applicationsapplications– Graphical Editors (using software components)Graphical Editors (using software components)

• (e.g. EON, VirTools, Quest3D)(e.g. EON, VirTools, Quest3D)

– VR systems incorporating scripting languages VR systems incorporating scripting languages

• (e.g. DIVE, ALICE, AVOCADO) (e.g. DIVE, ALICE, AVOCADO)

– Application Frameworks Application Frameworks

• (e.g. VRJuggler)(e.g. VRJuggler)

– Scene Graphs Scene Graphs

• (e.g. OpenSG, OpenSceneGraph)(e.g. OpenSG, OpenSceneGraph)

– Full development from scratch via C or C++Full development from scratch via C or C++

• OpenGL presents comparably high effort for new development of VR OpenGL presents comparably high effort for new development of VR applicationsapplications



• Application AreasApplication Areas

Safety TrainingSafety Training Collaborative WorkCollaborative Work EntertainmentEntertainment

ArtArt Scientific VisualizationScientific Visualization

Architecture VisualizationArchitecture Visualization Product PresentationProduct Presentation

EducationEducation

World LayoutWorld Layout


Architecture OverviewArchitecture Overview

• Overview – 3 different types of Overview – 3 different types of inVRsinVRs components components– System Core (blue)System Core (blue)

– Modules (cyan)Modules (cyan)

– Interfaces (grey)Interfaces (grey)

– Communication typically happening top down in the diagramCommunication typically happening top down in the diagram

– Strong dependencies between Interfaces and System CoreStrong dependencies between Interfaces and System Core

– Weak dependencies between Modules and other componentsWeak dependencies between Modules and other components


Architecture OverviewArchitecture Overview

• System CoreSystem Core– System Core contains databases and communication mechanismsSystem Core contains databases and communication mechanisms

– Offers interface between external modules and databasesOffers interface between external modules and databases

– Core functionality (data types, configuration handling, logging, timer, etc.)Core functionality (data types, configuration handling, logging, timer, etc.)

• ModulesModules– Implemented as pluginsImplemented as plugins

– Follow a structured approach (init, loadConfig, cleanup, etc. )Follow a structured approach (init, loadConfig, cleanup, etc. )

– Standard package contains modules for interaction, navigation, and network Standard package contains modules for interaction, navigation, and network communicationcommunication

– Physics simulation and animation are available as additional modulesPhysics simulation and animation are available as additional modules

• InterfacesInterfaces– Abstraction of input devicesAbstraction of input devices

– Abstraction of graphical and audio outputAbstraction of graphical and audio output

– On the graphics side only OpenSG is supported so far, plans to support On the graphics side only OpenSG is supported so far, plans to support OpenSceneGraph exist as wellOpenSceneGraph exist as well


Tutorial StructureTutorial Structure

• The tutorial is based on many copy and paste operations in order to safe The tutorial is based on many copy and paste operations in order to safe timetime

• Four basic file classes are needed for this tutorialFour basic file classes are needed for this tutorial– MedievalTown.cppMedievalTown.cpp

• Contains the application parts from where the development can startContains the application parts from where the development can start

– Configuration FilesConfiguration Files

• Stored in the config subdirectorysStored in the config subdirectorys

• Have to be altered through snippets (only in offline version with manual)Have to be altered through snippets (only in offline version with manual)

– CodeFile - SnippetsCodeFile - Snippets

• Contain code snippets which should be copied into the MedievalTown.cpp Contain code snippets which should be copied into the MedievalTown.cpp source filesource file

• Can be found under the subdirectory snipptesCan be found under the subdirectory snipptes

– ConfigFile - SnippetsConfigFile - Snippets

• Contain XML configuration which has to be copied in the actual Contain XML configuration which has to be copied in the actual configuration files (only in offline version with manual)configuration files (only in offline version with manual)

• Can be found under the subdirectory snipptesCan be found under the subdirectory snipptes

• Open the file Open the file MedievalTown.cppMedievalTown.cpp with the editor of your choice with the editor of your choice


Where a simple OpenSG application makes use of the Where a simple OpenSG application makes use of the WorldDatabase in order to load the scene graph of a Medieval WorldDatabase in order to load the scene graph of a Medieval Town.Town.

Chapter 1Chapter 1Basic Application DevelopmentBasic Application Development


Basic Application DevelopmentBasic Application Development

• Predefined FunctionsPredefined Functions– void cleanup()void cleanup()

• System cleanup for OpenSG and later for inVRs System cleanup for OpenSG and later for inVRs – void display(void)void display(void)

• Main display loop which is invoked by a GLUT callback.Main display loop which is invoked by a GLUT callback.– void reshape(int w, int h)void reshape(int w, int h)

• The method is used for reaction on changing of the window size.The method is used for reaction on changing of the window size.– void mouse(int button, int state, int x, int y)void mouse(int button, int state, int x, int y)

• This method reacts to button presses of the mouse.This method reacts to button presses of the mouse.– void motion(int x, int y)void motion(int x, int y)

• Forwards the coordinates of the mouse during mouse motion.Forwards the coordinates of the mouse during mouse motion.– void keyboard(unsigned char k, int x, int y)void keyboard(unsigned char k, int x, int y)

• This method reacts to keyboard input.This method reacts to keyboard input.– void keyboardUp(unsigned char k, int x, int y)void keyboardUp(unsigned char k, int x, int y)

• Reacts on keyboard input. It is invoked when a key is released.Reacts on keyboard input. It is invoked when a key is released.– int setupGLUT(int *argc, char *argv[])int setupGLUT(int *argc, char *argv[])

• Sets up the GLUT system and registers required callback functions.Sets up the GLUT system and registers required callback functions.



• Writing a simple Writing a simple inVRsinVRs application using OpenSG and GLUT application using OpenSG and GLUT– OpenSG and a GLUT Window have to be initialized firstOpenSG and a GLUT Window have to be initialized first

– Create a simple OpenSG Node and set a Group Core. Attach it to the scene.Create a simple OpenSG Node and set a Group Core. Attach it to the scene.

MedievalTown.cppMedievalTown.cppMedievalTown.cppMedievalTown.cpp

MedievalTown.cppMedievalTown.cpp



• Configuring Configuring inVRsinVRs

– XML FilesXML Files

– DTDs are available, but are not checked by the systemDTDs are available, but are not checked by the system



• Configuring Configuring inVRsinVRs– general.xmlgeneral.xml sets up sets up inVRsinVRs components (in <general>) and all system paths components (in <general>) and all system paths

(in <paths>), you have to update your own plugin path here.(in <paths>), you have to update your own plugin path here.

– Paths refer to other configurations, models and toolsPaths refer to other configurations, models and tools

general.xmlgeneral.xml



• Loading Loading inVRsinVRs Configuration Data Configuration Data– Load the general configuration of the Load the general configuration of the inVRsinVRs framework framework

– Call the loadConfig method with the configuration setup at which we had a look Call the loadConfig method with the configuration setup at which we had a look at on the previous slideat on the previous slide

– After having set the paths of the needed components the core configuration is After having set the paths of the needed components the core configuration is to be triggeredto be triggered

– Triggering this configuration in general results in subsequent internal configure Triggering this configuration in general results in subsequent internal configure calls, for example for the individual core components, the components of the calls, for example for the individual core components, the components of the interfaces or the registered modulesinterfaces or the registered modules

Snippet 1-1Snippet 1-1



• Triggering the Configuration and Adding a SceneTriggering the Configuration and Adding a Scene– This call causes the This call causes the inVRsinVRs system to fill the WorldDatabase with its data system to fill the WorldDatabase with its data

– The medieval town is loaded at this stageThe medieval town is loaded at this stage

– The interface to the OpenSG scene graph is established in this step as wellThe interface to the OpenSG scene graph is established in this step as well

• Interconnecting OpenSG and Interconnecting OpenSG and inVRsinVRs– Request the SceneGraphInterface from the OutputInterfaceRequest the SceneGraphInterface from the OutputInterface

– Retrieve the root node of the scene graph interface Retrieve the root node of the scene graph interface

– Attach it to the to the root node of our so far empty OpenSG sceneAttach it to the to the root node of our so far empty OpenSG scene




• Cleaning UpCleaning Up– Since we have instantiated the Since we have instantiated the inVRsinVRs SystemCore, including its sub- SystemCore, including its sub-

components we have to clean up at exitcomponents we have to clean up at exit– Insert the following snippet in the cleanup methodInsert the following snippet in the cleanup method

• Recompile and RunRecompile and Run– You should now see a medieval town behind a black backgroundYou should now see a medieval town behind a black background– A basic navigation is provided by the OpenSG SimpleSceneManagerA basic navigation is provided by the OpenSG SimpleSceneManager





• Working with the World DatabaseWorking with the World Database– An An inVRsinVRs VE consists of Environments, Entities and Tiles VE consists of Environments, Entities and Tiles

– They are typically used for partitioning and functionality (Entities) in the VEThey are typically used for partitioning and functionality (Entities) in the VE

– Configurations for these types are stored in Configurations for these types are stored in worldDatabase.xmlworldDatabase.xml

worldDatabase.xmlworldDatabase.xml



• Scene Graph Representation Scene Graph Representation




Where new Where new inVRsinVRs components will be added, the user is components will be added, the user is able to travel through the scene and the environment is able to travel through the scene and the environment is lightened up.lightened up.

Chapter 2Chapter 2Navigation and SkyboxNavigation and Skybox


Navigation and SkyboxNavigation and Skybox

• Adding Adding inVRsinVRs Components Components– In order to use the navigation several components are neededIn order to use the navigation several components are needed

• The Navigation module – to provide new user or camera coordinatesThe Navigation module – to provide new user or camera coordinates

• The InputInterface – to gather input from devices and expose it to the The InputInterface – to gather input from devices and expose it to the Navigation moduleNavigation module

• The UserDatabase – to set camera and user transformationsThe UserDatabase – to set camera and user transformations

• The TransformationManager – to pass the transformations generated by The TransformationManager – to pass the transformations generated by the Navigation module to the UserDatabasethe Navigation module to the UserDatabase

– This requiresThis requires

• Setting up the configurations of these components if they are not already Setting up the configurations of these components if they are not already providedprovided

• Registering these components unless they are core componentsRegistering these components unless they are core components

• Implementing callbacks to access these components during the Implementing callbacks to access these components during the initializationinitialization



• Adding Adding inVRsinVRs Components Components– The configuration-files for the two component types, the InputInterface and the The configuration-files for the two component types, the InputInterface and the

modules, have to be set as well at the top of general.xmlmodules, have to be set as well at the top of general.xml

– Interfaces and modules are available as individual librariesInterfaces and modules are available as individual libraries

– They can be loaded as pluginsThey can be loaded as plugins

– The paths provided in this snippet define the location where the configuration The paths provided in this snippet define the location where the configuration files for these component types are locatedfiles for these component types are located





• Adding Adding inVRsinVRs Components Components– The paths for the configurations of the individual components, not to be mixed The paths for the configurations of the individual components, not to be mixed

up with the component types, have to be provided in general.xmlup with the component types, have to be provided in general.xml

– More configuration paths have to be set, since we are working in this chapter More configuration paths have to be set, since we are working in this chapter with the UserDatabase and later on with the representation of the user toowith the UserDatabase and later on with the representation of the user too

– In the module configuration file the Navigation modules configuration file has to In the module configuration file the Navigation modules configuration file has to be providedbe provided

– The configuration of the system might seem cumbersome so far, typically The configuration of the system might seem cumbersome so far, typically standard configurations are used and only single parts for components are to standard configurations are used and only single parts for components are to be exchangedbe exchanged


modules.xmlmodules.xml

userDatabase.xmluserDatabase.xml



• Adding Adding inVRsinVRs Components Components– Initialization process has to be changedInitialization process has to be changed

• Paths for modules and interfaces are requestedPaths for modules and interfaces are requested

• The interfaces and the modules have to be configured as wellThe interfaces and the modules have to be configured as well

• Thus the overloaded configure function is usedThus the overloaded configure function is used

– Watch out with inserting this snippet code, parts above have to be removed Watch out with inserting this snippet code, parts above have to be removed




• Adding Adding inVRsinVRs Components Components– Both callbacks request pointers to the components at the initializationBoth callbacks request pointers to the components at the initialization

– Watch out when inserting this snippet, it contains cross references to othersWatch out when inserting this snippet, it contains cross references to others





• Adding Adding inVRsinVRs Components Components– Finally the callback functions for the interfaces and the modules have to be Finally the callback functions for the interfaces and the modules have to be

registeredregistered

– As with the XML configuration this approach might seem cumbersome, but is As with the XML configuration this approach might seem cumbersome, but is very generic and can be avoided by using an additional helper classvery generic and can be avoided by using an additional helper class

– This helper class is introduced in the following tutorial the This helper class is introduced in the following tutorial the Going Immersive Going Immersive TutorialTutorial




• Navigation ConceptsNavigation Concepts– Navigation or travel consists of three independent modelsNavigation or travel consists of three independent models

• SpeedSpeed

• OrientationOrientation

• TranslationTranslation

– Are composed by the Navigation module in order to create a resulting Are composed by the Navigation module in order to create a resulting transformationtransformation

– This transformation is to be passed on an object (e.g. camera, avatar)This transformation is to be passed on an object (e.g. camera, avatar)

– Typically the camera is used, but effects like dangling camera as known from Typically the camera is used, but effects like dangling camera as known from third-person VEs can be implemented easilythird-person VEs can be implemented easily

– Each model takes data from an abstract controller which is part of the input Each model takes data from an abstract controller which is part of the input interfaceinterface

• The controller takes input from devices and exposes it asThe controller takes input from devices and exposes it as

– Buttons (boolean values)Buttons (boolean values)

– Axes (linear values)Axes (linear values)

– Sensors (6DOF position and orientation values)Sensors (6DOF position and orientation values)



• Implementing NavigationImplementing Navigation– At first gather pointers to the relevant objectsAt first gather pointers to the relevant objects

• UserUser

• CameraCamera

• AvatarAvatar

– The camera and the avatar object are retrieved from the user objectThe camera and the avatar object are retrieved from the user object

– In our case we are working with the local user In our case we are working with the local user

• These objects can be retrieved as well from remote users once they are These objects can be retrieved as well from remote users once they are connect and the data is stored in the UserDatabaseconnect and the data is stored in the UserDatabase

– The display of the avatar is set to false The display of the avatar is set to false

– The initial transformation of the user is retrieved from the environmentThe initial transformation of the user is retrieved from the environment

• The entryPoint as described in the previous chapter is taken into accountThe entryPoint as described in the previous chapter is taken into account

– This transformation is then set on the navigated transformation of the user This transformation is then set on the navigated transformation of the user objectobject



• Implementing NavigationImplementing Navigation




• Implementing NavigationImplementing Navigation– The OpenSG SimpleSceneManger functionality has to be decoupledThe OpenSG SimpleSceneManger functionality has to be decoupled

– Pointer to the Navigator is retrieved from the manager and disabledPointer to the Navigator is retrieved from the manager and disabled

– A Timer is initializedA Timer is initialized

– The camera matrix is initializedThe camera matrix is initialized

– Navigation and input processing, as well as timer updates and transformation Navigation and input processing, as well as timer updates and transformation management has to take place on a per-frame basismanagement has to take place on a per-frame basis

– The display() - method which was registered as GLUT callback has to be The display() - method which was registered as GLUT callback has to be alteredaltered




• Implementing NavigationImplementing Navigation– The timestamp is updated and a delta value describing the time difference from The timestamp is updated and a delta value describing the time difference from

the last update is setthe last update is set

– The abstract controller is updatedThe abstract controller is updated

• Devices are polled and their values are exposedDevices are polled and their values are exposed

– Navigation is updated based on these valuesNavigation is updated based on these values

– The TransformationManager processes the navigation The TransformationManager processes the navigation

– The transformation matrix of the The transformation matrix of the inVRsinVRs camera is requested camera is requested




• Implementing NavigationImplementing Navigation– The The inVRsinVRs camera matrix is converted in to a OpenSG camera matrix camera matrix is converted in to a OpenSG camera matrix

– The navigator of the SimpleSceneManager is requestedThe navigator of the SimpleSceneManager is requested

– The converted matrix is set in the navigatorThe converted matrix is set in the navigator

– The TransformationManager is invoked to process the remaining The TransformationManager is invoked to process the remaining transformations (more detail on this in the next chapter)transformations (more detail on this in the next chapter)

– The timeStamp is kept as the previous timeStampThe timeStamp is kept as the previous timeStamp




• Decoupling the OpenSG Input – Integrating Decoupling the OpenSG Input – Integrating inVRsinVRs Input Handling Input Handling– Alter the predefined GLUT – callback functionsAlter the predefined GLUT – callback functions

– Data is now passed to Data is now passed to inVRsinVRs (GlutMouseDevice and GlutKeyboardDevice) (GlutMouseDevice and GlutKeyboardDevice) instead of the SimpleSceneManagerinstead of the SimpleSceneManager

– Gather knowledge on current window size for calculation of the cursor positionGather knowledge on current window size for calculation of the cursor position

– Poll the mouse button statePoll the mouse button state

– Gather input on the mouse movementGather input on the mouse movement

– Gather input on pressed keyboard keysGather input on pressed keyboard keys







• Decoupling the OpenSG Input – Integrating Decoupling the OpenSG Input – Integrating inVRsinVRs Input Handling Input Handling– Additional keys should be checked to trap the mouse cursor in the active Additional keys should be checked to trap the mouse cursor in the active

window window

– Gather input on released keyboard keys Gather input on released keyboard keys

• Configuring the NavigationConfiguring the Navigation– Each model has its specific configurationEach model has its specific configuration

– Typically the arguments passed to the models perform a mapping from the Typically the arguments passed to the models perform a mapping from the abstract input into model specific parametersabstract input into model specific parameters

– Setup in navigation.xmlSetup in navigation.xml

– Many predefined models existMany predefined models exist





• Configuring the NavigationConfiguring the Navigation

navigation.xmlnavigation.xml



• Skybox ToolSkybox Tool– Skyboxes are used to represent scene surroundingsSkyboxes are used to represent scene surroundings

– Skyboxes move with the cameraSkyboxes move with the camera

– The Skybox orientation is always fixed to the sceneThe Skybox orientation is always fixed to the scene

– Typically 6 textures mapped on cubes, Typically 6 textures mapped on cubes, inVRsinVRs offers different box shapes offers different box shapes



• Adding a SkyboxAdding a Skybox– The path is retrieved from the configuration and a skybox is set up with 6 The path is retrieved from the configuration and a skybox is set up with 6

image filesimage files

– Dimensions and far clipping plane have to be set as well Dimensions and far clipping plane have to be set as well

– The Skybox is internally generated and a node pointer containing the Skybox The Skybox is internally generated and a node pointer containing the Skybox scene graph is requestedscene graph is requested

– This node is attached to the top node of the scene This node is attached to the top node of the scene

– The box position is set to the camera positionThe box position is set to the camera position

– Compile and runCompile and run







Where the navigation results are altered that the terrain Where the navigation results are altered that the terrain can be followed and collisions with the buildings can be can be followed and collisions with the buildings can be detected and resolved.detected and resolved.

Chapter 3Chapter 3Transformation ManagementTransformation Management


Transformation ManagementTransformation Management

• Height Maps and Collision MapsHeight Maps and Collision Maps– Height mapsHeight maps

• 2D Grid structure defining the height value underneath a 3D geometry2D Grid structure defining the height value underneath a 3D geometry

• Additional normal vectors are provided which describe the orientation of Additional normal vectors are provided which describe the orientation of the triangles at given grid locationthe triangles at given grid location

– Collision MapsCollision Maps

• Line sets defining non-passable areas in a VELine sets defining non-passable areas in a VE

• Mapping from 3D objects on a planeMapping from 3D objects on a plane

• Plane is placed in the scene Plane is placed in the scene

• Lines are drawn where geometries at a defined height are cutLines are drawn where geometries at a defined height are cut

– Both are implemented as modifiers and can alter the generated transformation Both are implemented as modifiers and can alter the generated transformation matrixmatrix



• Height Maps and Collision MapsHeight Maps and Collision Maps



• Generating Height MapsGenerating Height Maps– Either offline or onlineEither offline or online

– Take tiles as inputTake tiles as input

– If height maps have to be generated during runtime this can take a significant If height maps have to be generated during runtime this can take a significant amount of timeamount of time

– In case no pre-defined height map is available for a tile and the method In case no pre-defined height map is available for a tile and the method generate is called a height map will be automatically createdgenerate is called a height map will be automatically created

– The geometry of a tile sampled and the grid is generatedThe geometry of a tile sampled and the grid is generated

• Generating Collision MapsGenerating Collision Maps– Always have to be created offlineAlways have to be created offline

– Can be generated automatically by an external toolCan be generated automatically by an external tool

– Modeling tools (e.g. Blender, MAYA, 3D Max) are often used to manually draw Modeling tools (e.g. Blender, MAYA, 3D Max) are often used to manually draw collision linescollision lines




• Generating Collision MapsGenerating Collision Maps– Typically the final scene is dumped to disk from the applicationTypically the final scene is dumped to disk from the application

– It is loaded into the modeling toolIt is loaded into the modeling tool

– The lines are drawn from top viewThe lines are drawn from top view

– The line sets are again written to disc in a VRML file formatThe line sets are again written to disc in a VRML file format



• Transformation Manager ArchitectureTransformation Manager Architecture– Consists of Pipes and ModifiersConsists of Pipes and Modifiers

– TransformationData is sent from a source component to a destination TransformationData is sent from a source component to a destination component via the TransformationManagercomponent via the TransformationManager

– At the destination component the transformation is to be applied on a targetAt the destination component the transformation is to be applied on a target

• PipesPipes– Transformations are routed through pipes inside the transformation managerTransformations are routed through pipes inside the transformation manager

– Have a key consisting of source and destination component, target, received Have a key consisting of source and destination component, target, received from network, etc.from network, etc.

– Have several stages where the transformation can be modifiedHave several stages where the transformation can be modified

• ModifiersModifiers– Pipe stagePipe stage

– Different types e.g. for reading and writing data from and to external Different types e.g. for reading and writing data from and to external components existcomponents exist



• Setting up the Transformation ManagerSetting up the Transformation Manager– Pipe is identified by a keyPipe is identified by a key

– Contains list of modifiersContains list of modifiers

modifiers.xmlmodifiers.xml



• Integrating the Height Maps and Collision Maps Integrating the Height Maps and Collision Maps – Height map modifier has to be integrated after the navigated transformation is Height map modifier has to be integrated after the navigated transformation is

put in the pipeput in the pipe

– CheckCollisionModifier is applied afterwardsCheckCollisionModifier is applied afterwards

– Radius for collision detection is to be setRadius for collision detection is to be set

– Filename of the collision map has to be providedFilename of the collision map has to be provided

– The height of the camera has to be modifiedThe height of the camera has to be modified






• Adding the Transformation Managers’ SetupAdding the Transformation Managers’ Setup– The factories for generating the used modifiers have to be registered since the The factories for generating the used modifiers have to be registered since the

modifiers are not provided as core featuresmodifiers are not provided as core features

– All additional modifiers which are not provided by the SystemCore have to All additional modifiers which are not provided by the SystemCore have to register their factories at the initialization callbackregister their factories at the initialization callback

– The TransformationManager has to be registered for a callbackThe TransformationManager has to be registered for a callback

– Compile and runCompile and run






Where the user is able to pick up and drop boxes and Where the user is able to pick up and drop boxes and benches in the town.benches in the town.

Chapter 4Chapter 4InteractionInteraction


InteractionInteraction

• Implemented as a deterministic finite automaton (DFA)Implemented as a deterministic finite automaton (DFA)– Input alphabet Input alphabet Σ Σ defined through components of the abstract input device defined through components of the abstract input device

and system statesand system states

– q = {qq = {q00 (Idle), q (Idle), q11, (Selection) q, (Selection) q22, (Manipulation)}, (Manipulation)}

– Transition function Transition function δ δ defined through interaction techniquesdefined through interaction techniques

– Start- and end state = qStart- and end state = q00



• Configuring the State MachineConfiguring the State Machine

interaction.xmlinteraction.xml



• Adding the Interaction Module to our ApplicationAdding the Interaction Module to our Application– Set the path for the interaction configuration firstSet the path for the interaction configuration first

– Provide a configuration file for the Interaction moduleProvide a configuration file for the Interaction module

– Retrieve the module in callback functionRetrieve the module in callback function






• Setting up the Transformation ManagementSetting up the Transformation Management– For interaction the transformation pipe has to be altered againFor interaction the transformation pipe has to be altered again

– In the navigation pipe the updated position has to write out the cursor position, In the navigation pipe the updated position has to write out the cursor position, which is always relative to the userwhich is always relative to the user

– An additional pipe has to be configured, which takes as a source the An additional pipe has to be configured, which takes as a source the Interaction module and as destination the WorldDatabaseInteraction module and as destination the WorldDatabase

– The pipe is opened by the modules when neededThe pipe is opened by the modules when needed

– This pipe is the interaction pipe using modifiers for This pipe is the interaction pipe using modifiers for

• Adding manipulation offsetAdding manipulation offset

• Writing out the transformationWriting out the transformation





• Adding a Cursor RepresentationAdding a Cursor Representation– Helpful to have a visual representation of the cursor for selection and Helpful to have a visual representation of the cursor for selection and

manipulationmanipulation

– Paths for model and representation have to be set as wellPaths for model and representation have to be set as well

– Additionally the configuration files have to be set in the UserDatabaseAdditionally the configuration files have to be set in the UserDatabase

• Invoking Interaction and Changing the Cursor AppearanceInvoking Interaction and Changing the Cursor Appearance– In the display loop the interaction has to be invoked for checking the transition In the display loop the interaction has to be invoked for checking the transition

functions, changing the state, writing transformations and event processingfunctions, changing the state, writing transformations and event processing

– The cursor is updated based on information of the state machineThe cursor is updated based on information of the state machine

– Compile and executeCompile and execute



userDatabase.xmluserDatabase.xml




Where the virtual world is shared with other participants Where the virtual world is shared with other participants and remote interaction and navigation can be perceived.and remote interaction and navigation can be perceived.

Chapter 5Chapter 5Using Network CommunicationUsing Network Communication


Using Network CommunicationUsing Network Communication

• Network ConceptsNetwork Concepts– Module designed for exchangeabilityModule designed for exchangeability

• Many implementations exist alreadyMany implementations exist already

– Standard module Standard module

• Communication topology represents a complete graphCommunication topology represents a complete graph

• Databases fully replicatedDatabases fully replicated

– Communication between components and network uses a high level interface Communication between components and network uses a high level interface

• Sending and receiving of TransformationData and EventsSending and receiving of TransformationData and Events

• Sending and receiving of user defined messagesSending and receiving of user defined messages

• Connection establishment and disconnectingConnection establishment and disconnecting



• Adding the Network Module to our ApplicationAdding the Network Module to our Application– As usual set the path for the network configuration firstAs usual set the path for the network configuration first

– Provide a configuration file for the Network moduleProvide a configuration file for the Network module

– Retrieve the module in callback functionRetrieve the module in callback function

– Connection establishment using the first command line argumentConnection establishment using the first command line argument

– Synchronization between the different instances (e.g. updates on the Synchronization between the different instances (e.g. updates on the WorldDatabase)WorldDatabase)







• Using the Network ModuleUsing the Network Module– An update on the SystemCore has to be triggered at the beginning of the An update on the SystemCore has to be triggered at the beginning of the

display loopdisplay loop

– Internal events like updating the UserDatabase and synchronizing the VEs can Internal events like updating the UserDatabase and synchronizing the VEs can be subsequently trigged in in the corebe subsequently trigged in in the core

– The ports which are used for communication are defined in network.xmlThe ports which are used for communication are defined in network.xml

• TCP is typically used for EventsTCP is typically used for Events

• UDP is typically used for TransformationDataUDP is typically used for TransformationData

• Altering the Transformation ManagementAltering the Transformation Management– In the interaction and navigation pipe a distributor has to be includedIn the interaction and navigation pipe a distributor has to be included

– The current value at this stage is distributed to remote users and passed inside The current value at this stage is distributed to remote users and passed inside a similar pipe a similar pipe


network.xmlnetwork.xml



– An additional pipe for remote interaction input has to be set upAn additional pipe for remote interaction input has to be set up

• The attribute fromNetwork is in that case set to trueThe attribute fromNetwork is in that case set to true

– An additional pipe for remote navigation input has to be set upAn additional pipe for remote navigation input has to be set up

• The attribute fromNetwork is in that case set to trueThe attribute fromNetwork is in that case set to true







Where new code is introduced into the application to Where new code is introduced into the application to make the sails of a windmill turn.make the sails of a windmill turn.

Chapter 6Chapter 6Developing own Application LogicDeveloping own Application Logic


Developing own Application LogicDeveloping own Application Logic

• Own Application LogicOwn Application Logic– Goal: to manipulate a scene graph of an entity based on user inputGoal: to manipulate a scene graph of an entity based on user input

– Gather exposed user input in display loopGather exposed user input in display loop

– Variable containing a rotational speed is usedVariable containing a rotational speed is used

– In case the defined button is pressed speed is increased up to a thresholdIn case the defined button is pressed speed is increased up to a threshold

– If the button is not pressed the speed will be decreased to zeroIf the button is not pressed the speed will be decreased to zero

– In next step the calculated speed has to be applied on the sails of the windmill In next step the calculated speed has to be applied on the sails of the windmill modelmodel

Snippet-6-1Snippet-6-1



• Own Application LogicOwn Application Logic– First get the entity from the WorldDatabaseFirst get the entity from the WorldDatabase

– Get the scene graph of the EntityGet the scene graph of the Entity

– Get the sub scene graph of the previously retrieved scene graph with the name Get the sub scene graph of the previously retrieved scene graph with the name “Sails” ( this name is stored in the loaded model)“Sails” ( this name is stored in the loaded model)

– Make sure it is a transformation nodeMake sure it is a transformation node

– Cast the Cast the inVRsinVRs scene graph node into an scene graph node into an inVRsinVRs transformation node transformation node

– Request the transformation from the nodeRequest the transformation from the node

– Apply the rotational change to the transformationApply the rotational change to the transformation

– Apply the final transformation on the transformation nodeApply the final transformation on the transformation node



• Own application logicOwn application logic

• Recompile and executeRecompile and execute

Snippet-6-1Snippet-6-1




OutlookOutlook


OutlookOutlook

• Variety of additional tools are availableVariety of additional tools are available– Modules Modules

• Physics Support (2D and 3D Physics)Physics Support (2D and 3D Physics)

• Animation and Camera pathAnimation and Camera path

– External Tools External Tools

• Collaborative EditorCollaborative Editor

– Scene Graph Specific Enhancements (OpenSG) Scene Graph Specific Enhancements (OpenSG)

• Avatars (with export from 3D Max, MAYA and Blender)Avatars (with export from 3D Max, MAYA and Blender)

• CAVESceneManagerCAVESceneManager

• Particle WrapperParticle Wrapper

• SkyboxSkybox

• 3D Menu System3D Menu System


OutlookOutlook

• Novel conceptsNovel concepts– Clear distinction in the area of communication patternsClear distinction in the area of communication patterns

– Events and transformations are handled independentlyEvents and transformations are handled independently

– Transformation management allows for concurrent object manipulationTransformation management allows for concurrent object manipulation

– Composeable and clearly defined interaction and navigationComposeable and clearly defined interaction and navigation

– Automatic data distribution mechanism Automatic data distribution mechanism

– Full abstraction from graphics, input, network, etc.; the developer should be Full abstraction from graphics, input, network, etc.; the developer should be able to focus on the application logicable to focus on the application logic

– Development and integration of networked physics module (Roland Development and integration of networked physics module (Roland Landertshamer)Landertshamer)

• Does not provideDoes not provide– Scripting supportScripting support

– Logic supportLogic support


AcknowledgementsAcknowledgements

• ContributorsContributors– Architecture and Main DevelopmentArchitecture and Main Development

Christoph Anthes, Helmut Bressler, Roland Landertshamer, Marina LengerChristoph Anthes, Helmut Bressler, Roland Landertshamer, Marina Lenger

– ToolsTools

Helmut Garstenauer, Martin Garstenauer, Adrian Haffegee, Marlene Helmut Garstenauer, Martin Garstenauer, Adrian Haffegee, Marlene Hochrieser, Roland Hopferwieser, Robert Owen, Stephan Reiter, Thomas Hochrieser, Roland Hopferwieser, Robert Owen, Stephan Reiter, Thomas Weberndorfer, Christian Wressnegger, Johannes ZarlWeberndorfer, Christian Wressnegger, Johannes Zarl

Questions ?Questions ?


BibliographyBibliography

• Christoph Anthes; Paul Heinzlreiter; Gerhard Kurka & Jens Volkert, “Navigation Models for Christoph Anthes; Paul Heinzlreiter; Gerhard Kurka & Jens Volkert, “Navigation Models for a Flexible, Multi-Mode VR Navigation Framework“, a Flexible, Multi-Mode VR Navigation Framework“, ACM SIGGRAPH on Virtual Reality ACM SIGGRAPH on Virtual Reality Continuum and Its Applications in Industry (VRCAI '04), ACM Press, Continuum and Its Applications in Industry (VRCAI '04), ACM Press, 2004, pages 476-479 2004, pages 476-479

• Christoph Anthes; Roland Landertshamer; Helmut Bressler & Jens Volkert, “Managing Christoph Anthes; Roland Landertshamer; Helmut Bressler & Jens Volkert, “Managing Transformations and Events in Networked Virtual Environments“Transformations and Events in Networked Virtual Environments“ACM International MultiMedia Modeling Conference (MMM '07), Springer, ACM International MultiMedia Modeling Conference (MMM '07), Springer, 20072007, 4352, 4352, , pages 722-729pages 722-729

• Christoph Anthes; Roland Landertshamer & Jens Volkert, “Physically-Based Interaction for Christoph Anthes; Roland Landertshamer & Jens Volkert, “Physically-Based Interaction for Networked Virtual Environments.“, Networked Virtual Environments.“, International Conference on Computational Science International Conference on Computational Science (ICCS '07), Springer, (ICCS '07), Springer, 20072007, 4488, 4488, pages 776-783 , pages 776-783

• Christoph Anthes & Jens Volkert, “inVRs - A Framework for Building Interactive Networked Christoph Anthes & Jens Volkert, “inVRs - A Framework for Building Interactive Networked Virtual Reality Systems“, Virtual Reality Systems“, International Conference on High Performance Computing and International Conference on High Performance Computing and Communications (HPCC '06), Springer, Communications (HPCC '06), Springer, 20062006, 4208, 4208, pages 894-904 , pages 894-904


BibliographyBibliography

• Christoph Anthes; Alexander Wilhelm; Roland Landertshamer; Helmut Bressler & Jens Christoph Anthes; Alexander Wilhelm; Roland Landertshamer; Helmut Bressler & Jens Volkert, “Net'’O'’Drom -- An Example for the Development of Networked Immersive VR Volkert, “Net'’O'’Drom -- An Example for the Development of Networked Immersive VR Applications“, Applications“, International Conference on Computational Science (ICCS '07), Springer, International Conference on Computational Science (ICCS '07), Springer, 20072007, 4488, 4488, pages 752-759 , pages 752-759

• Helmut Bressler; Roland Landertshamer; Christoph Anthes & Jens Volkert, “An Efficient Helmut Bressler; Roland Landertshamer; Christoph Anthes & Jens Volkert, “An Efficient Physics Engine for Virtual Worlds“, Physics Engine for Virtual Worlds“, medi@terra '06, medi@terra '06, 2006, pages 152-158 2006, pages 152-158

• Adrian Haffegee; Ronan Jamieson; Christoph Anthes & Vassil N. Alexandrov, “Tools For Adrian Haffegee; Ronan Jamieson; Christoph Anthes & Vassil N. Alexandrov, “Tools For Collaborative VR Application Development“, Collaborative VR Application Development“, International Conference on Computational International Conference on Computational Science (ICCS '05), Springer, Science (ICCS '05), Springer, 20052005, 3516, 3516, pages 350-358 , pages 350-358

Documents

Christoph AnthesRoland LandertshamerMarina Lenger Tutorial I - Medieval Town