A game engine-Based Visual Framework and Application

A game engine-Based Visual Framework and Application
Wang deyong
(Pingdingshan Institute of industry and technology, Pingdingshan 467001, Henan Province)
Abstract: The game engine is a core component of video games. It is mainly used to process tasks such as rendering, AI in the game, and collision detection between game objects. Thanks to the popularity of computer games, people have invested a lot of research work in game engine development. This article analyzes the applicability of the game engine to visual research. A software architecture and a visual framework to facilitate this task are provided to evaluate the applicability of many engines. Finally, the results are confirmed from several case studies and the conclusion is obtained.
Keywords: Game Engine, visualization, human-machine interface, collaboration Interface
A framework for game engine based visualizations and Applications
Abstract:
Game engines are the core software component of video games and typically handle tasks such as rendering, game AI and collision detection between game objects. due to the popularity of computer games, a huge amount of research has been converted Ted towards the development of game engines. in this paper we analyzed the suitability of game engines for visualization research. we present a software architecture and a visualization framework which facilitates this task and we evaluate the suitability of a number of popular engines. we conclude with a summary of our experiences from several case studies.
Keywords: game engines visualization human-computer interfaces collaborative interfaces
 
1. Introduction
Modern computer games use technologies in many fields of computer science, such as computer graphics, artificial intelligence, network programming, operating systems, programming languages and algorithms. A modern computer game engine, such as Doom 3 or Unreal Tournament 2004, contains a large number of powerful rendering and interaction techniques, effective and fully tested implementation methods, these are usually concentrated on displaying the real 3D world and supporting navigation and interaction between elements in the visualization system. Assuming that these game engines have powerful flexibility and maturity, this provides a very meaningful way for other visualization tasks to reuse these engines, thus potentially saving a lot of development time.
This article will focus on the use of computer game implementation methods to achieve more general visualization tasks, such as information visualization, science, and biological visualization. We provide a visual game engine development framework and give examples to illustrate the relationship between the necessary software architecture and its data ing and processing, then we will analyze the game engine through the experiment summary obtained from several case studies.
2. Related Research Status
Computer Game implementation methods have been successfully applied to visualization-related work, such as reference for architecture design, industrial simulation, military simulation, and land planning. The game engine has been used by more abstract visualization tasks. One of the innovative examples is psdoom, which is used to process visualization and management, the implementation method is to modify the doom of computer games. The program provides the Unix ps command function through a 3D user interface, and the running process is represented as a monster (enemy ), monsters can be shot and killed, and the related processes are also terminated. Monsters can also be attacked, and more important processes are expressed by larger monsters (it is more difficult to kill them), thus reducing the chances of termination. Interestingly, when many processes are running, the 3D space of monsters will become very crowded, and these monsters start to attack each other (a normal doom behavior ), this provides a natural control mechanism for processes in the high-load system. A secondary important process will be killed first, because an important process is expressed as a stronger monster.
3. Visualized Game Engine
Visualization refers to the representation of complex data through graphical images, which facilitates understanding and transmitting information. Visual Research is often divided into several research fields, such as information, science, biology, software and algorithms.
3.1 visualization process
The visualization process can be expressed through pipelines. The process of data encoding and decoding is shown in step 2. The first stage of the data encoding step is the data conversion stage, turn information into a new and visualized form. This may include the creation of new quantities and subsets, the new conversion of data classes, and the creation of model operations (for example, building a directory structure into a tree structure ). The subsequent visual ing converts the converted data into graphical representations for display. Some authors prefer to refine the ing phase to the visual conversion (Data Modeling) and visual ing stages. However, in many applications, these two phases are mixed: the ready available model and model parameters (shape, size, color, texture material) are represented as encoded information. The data decoding stage describes how to understand and process visual information and how visual information is made up of visual perception and recognition.
 
Figure 1 visualization process
In this process, the encoding and decoding steps are connected through visual attributes, including shape, position, color, and text attributes (such as text and symbols, they are also represented by simple visual attributes ). This visualization program is valid if the encoding can be effectively and correctly executed. "Correct" means that the relationship between the volume of data represented by the visualization program and the data directly reflects the actual data, "effective" means that the visualization program shows the maximum amount of information at least time. It is a challenge to achieve a correct and effective goal by taking advantage of the capabilities provided by the game engine without modifying the engine source code.
3.2 game engine-Based Visual Framework
There are two ways to use the FPS game engine for visualization: one is to modify the existing game implemented on the engine, but to add some necessary features of visualization, the basic types of 3D world interaction are retained. Another method is to write brand new code for the game logic, but to use the graphics, sound, and network functions in the game engine. Although this method is flexible, it requires a greater workload for developers. In fact, this approach is similar to the use of visualization tools or game engines, such as code reuse, interface references, and the use of widely used, growing, and free software environments.
(1) Software Architecture
The game engine does not support data conversion and ing. These tasks must be completed by a module on the engine. Many datasets are complex and must be extended to the customer/service architecture (C/S) shown in 2 to complete the interaction visualization process ).
 
Figure 2 Software Architecture Based on visualized tool Game Engine
If the dataset is very large, it should be processed on the server and mapped to a graphical object, which will be displayed on the Game Engine client. The opposite is true. If the original dataset is quite compact and the graphic representation is very complex, it is more effective in the conversion and ing stages on the client. Note that the game world is usually stored on the game server. Therefore, it is very useful to divide the visualization program into static and dynamic parts. The static part is represented by the game world on the server side, while the dynamic part is stored on the client, it should be noted that the appropriate interaction mechanism must be used to allow the user to return the corresponding data from the visualization program.
(2) Data ing
There are two basic element types in FPS games: static or almost static maps (3D layout of space) and dynamic interaction physical entities occupying positions in this map. When you use the game engine for visualization, the main challenge is that the available visual attributes, text attributes, and interaction methods are limited. Therefore, when converting and ing natural data into graphical representation methods is an innovative method, you need to select a special ing method for special visualization. For example, in a file-level visualization, the directory layout can be expressed by the Space Layout (that is, the map), and the physical entity occupying the position in the space during file operations.
When designing mappings, you must consider the limitations of using game engines. For example, in the most modern FPS games (especially quake 3), maps cannot be changed in a game session. When a player is in another map, he can change the map to be partially processed to create a dynamic world. The disadvantage is that the game will be suspended when the map is switched. In addition, there are limits on the size of quake 3 maps. One solution is to split a large map into several small maps, but the game is suspended when the map changes.
Another limit for FPS games is that they are designed to have a small number of related objects. Quake 3 allows a maximum of 1024 objects in a map. Therefore, in some cases, a part of the visualization is represented as a dynamically generated texture (for example, a table in a graphic structure) rather than a separated entity. An optional solution is to use multiple maps with the disadvantages discussed above.
Another limitation of gaming engines is that they are designed to only support a style of interaction defined by the game logic. For example, in quake 3, each object usually has a fixed appearance and a fixed action throughout the game session. (In fact, you can change this in a game session by programming if you want) The problem is that the engine does not support any multiple visual views. Therefore, if a visualization program has multiple view types, you must write a framework code on the engine to show which view is currently in use, it also shows the representation and behavior of the entity corresponding to the game logic.
3.3 game engine Analysis
To use the game engine to build a user-friendly and collaborative visualization tool, the game engine must be flexible and available, with multi-user capabilities, stability, fully tested, and rich in features. In addition, we need to avoid modifying the source code. Therefore, the game engine needs a powerful and flexible scripting language and must have a fully tested, open-source implementation of a game available for it.
We have evaluated Multiple game engines and found that the quake 3 engine with scenario implementation can best meet these needs. The source code of the quake 3 scenario is available with a limited license. It declares that the source code can be modified and the virtual machine bytecode of the game to be modified can be released. For several open-source game engines, such as ogre, crystal space, and irrlicht, research has found that most of them lack key features (such as network support), or that the games they implement are not fully tested. Quake 3 uses the standard FPS game control system, namely, the keyboard and mouse. Moving the mouse can change the player's angle of view. The mouse buttons are also typically used for forward or shooting, different keys on the keyboard are also used to indicate squatting, jumping, retreating, scanning, and exchanging weapons. These keys can be redefined into different functions in the game through the so-called key bonding process. Quake 3 is designed as a network-oriented (LAN or Internet) game. It uses the customer/server communication mode. Each computing machine running quake 3 runs an instance of quake3.exe (game engine, this execution can run bytecode: Game, cgame, and UI on three virtual machines. These are called qvms, which is the quake virtual machine. The qvm of the game is the game server part, it is responsible for maintaining the state of the game world, such as the location of all objects and sending messages to clients. It also has a final conclusion about some issues, such as whether a bullet hits a player. The game does not show any performance. It only communicates with the client. Cgame is a client Virtual Machine (qvm), that is, a computer running on each server connected to a specific game. The client is responsible for rendering maps and Objects Based on the data sent by the server. The UI qvm is responsible for displaying the menus in the game. In the main program that the worker executes. These are the execution processes of tasks, which display information on the screen, file or network access. Internally, the main message transmission mechanism (or one that is the easiest to access and modify) is based on the length of the transferred variable, rather than the ending character.
4. Results
We found that quake 3 is a good choice for implementing game engine-based visualization applications, and we have successfully implemented one visualization tool software and one mine production visualization tool, as shown in result 3.
 

Figure 3 A mine production visualization tool using the quake 3 engine
5. Conclusion
It is possible for a visualization tool to use a game engine as the basis, which saves a lot of implementation time by reusing the functions already implemented in the game engine, the biggest benefit of doing so is that you can create a modified product (MOD) without rewriting the source code. The modern game engine provides a fast and realistic quality and interactivity as well as multi-user support, which is difficult to obtain through existing visualization tools.
To simplify the implementation process, it is very important to find a proper visualization tool and an appropriate performer. An appropriate performer often requires considerable creativity. Due to the limitation of most engines, a visual system may be divided into a static 3D world and a dynamic object, allowing users to interact with dynamic objects (for example, obtain feedback from them ). These objects should usually be less than 500, but this restriction depends on the choice of the game engine. You need to modify the quantity, performance, and hardware requirements of the product. There are also limits on the size of the largest map (3d world) and the size of the surface mesh, although it can work with several smaller maps or mesh stitching.
Using the game engine to develop visual applications requires a lot of work compared to using visual libraries (such as VTK, we hope this research will allow readers to design visualization tools on the game engine and combine the advantages of the Game Engine with separate visualization applications.
References:
[1] "id software." url: www.idsoftware.com.
[2] "epic games." url: www.epicgames.com.
[3] J. moloney, R. amor, J. furness, and B. moores, "Design critique inside a multiplayer game engine," in Proceedings of the CIB w78 Conference on it in construction, pp. 255-262,200 3. waiheke Island, New Zealand, 23-25 w.l.
[4] J. manojlovich, P. prasithsangaree, S. hughes, J. chen, and M. lewis, "utsaf: A Multi-agent-based framework for supporting military-based distributed interactive simulations in 3D virtual environments," in Proceedings of the winter simulation conference, pp. 960-968,200 3. new Orleans, 7-10 December.
[5] a. herwig and P. Paar, trends in GIS and virtualization alization in environmental planning and design, Ch. game engines: Tools for Landscape visualization and planning ?, Pp. 161-172. Wichmann Verlag, Heidelberg, 2002.
[6] D. chao, "Doom as an interface for process management," in Proceedings of sigchi '01, pp. 152-157,200 1. seattle, WA, 31 March-1 limit L.

(Author profile: Wang deyong (1969.6 -?), Male, Han nationality, Associate Professor, Senior Programmer, master of Xi'an University of electronic science and technology, computer department teacher of Pingdingshan Institute of Industrial Technology, major research direction computer simulation .)