Misplaced Pages

#77922

60-498: Gamebryo ( / ɡ eɪ m . b r iː oʊ / ; gaym- BREE -oh ; formerly NetImmerse until 2003) is a game engine developed by Gamebase Co., Ltd. and Gamebase USA, that incorporates a set of tools and plugins including run-time libraries , supporting video game developers for numerous cross-platform game titles in a variety of genres, and served as a basis for the Creation Engine . Numerical Design Limited (NDL)

120-460: A component-based architecture that allows specific systems in the engine to be replaced or extended with more specialized (and often more expensive) game-middleware components. Some game engines comprise a series of loosely connected game middleware components that can be selectively combined to create a custom engine, instead of the more common approach of extending or customizing a flexible integrated product. However achieved, extensibility remains

180-414: A graph or tree structure. A tree node may have many children but only a single parent, with the effect of a parent applied to all its child nodes; an operation performed on a group automatically propagates its effect to all of its members. In many programs, associating a geometrical transformation matrix (see also transformation and matrix ) at each group level and concatenating such matrices together

240-460: A scene graph —an object-oriented representation of the 3D game-world which often simplifies game design and can be used for more efficient rendering of vast virtual worlds. Most game engines or graphics engines use a Graphics API , which lets you easily communicate with the GPU . But older games did not have hardware acceleration or GPUs and had to build their own software renderer. As technology ages,

300-473: A 'horse' node with a 'knight' node attached to it. The scene graph may also describe the spatial, as well as the logical, relationship of the various entities: the knight moves through 3D space as the horse moves. In these large applications, memory requirements are major considerations when designing a scene graph. For this reason, many large scene graph systems use geometry instancing to reduce memory costs and increase speed. In our example above, each knight

360-469: A BVH – if each node has a volume associated or there is a purpose-built "bound node" added in at convenient location in the hierarchy. This may not be the typical view of a scene graph, but there are benefits to including a BVH in a scene graph. An effective way of combining spatial partitioning and scene graphs is by creating a scene leaf node that contains the spatial partitioning data. This can increase computational efficiency of rendering. Spatial data

420-401: A compiled binary library . Some middleware programs can be licensed either way, usually for a higher fee for full source code. Scene graph A scene graph is a general data structure commonly used by vector-based graphics editing applications and modern computer games, which arranges the logical and often spatial representation of a graphical scene. It is a collection of nodes in

480-446: A different order – this is where some systems implement scene graph rebuilding to reorder the scene graph into an easier-to-parse format or tree. For example, in 2D cases, scene graphs typically render themselves by starting at the tree's root node and then recursively draw the child nodes. The tree's leaves represent the most foreground objects. Since drawing proceeds from back to front with closer objects simply overwriting farther ones,

540-433: A feature of a layer, but not necessarily of a group. Scene graphs are useful for modern games using 3D graphics and increasingly large worlds or levels. In such applications, nodes in a scene graph (generally) represent entities or objects in the scene. For instance, a game might define a logical relationship between a knight and a horse so that the knight is considered an extension to the horse. The scene graph would have

600-412: A game developer may need to build a game. Most game-engine suites provide facilities that ease development, such as graphics, sound, physics and artificial-intelligence (AI) functions. These game engines are sometimes called " middleware " because, as with the business sense of the term, they provide a flexible and reusable software platform which provides all the core functionality needed, right out of

660-468: A game engine may include a rendering engine ("renderer") for 2D or 3D graphics , a physics engine or collision detection (and collision response), sound , scripting , animation , artificial intelligence , networking , streaming, memory management , threading , localization support, scene graph , and video support for cinematics . Game engine implementers often economize on the process of game development by reusing/adapting, in large part,

SECTION 10

#1732779847078

720-577: A game for the Atari 2600 , for example, had to be designed from the bottom up to make optimal use of the display hardware—this core display routine is today called the kernel by developers of games for older systems. Other platforms had more leeway, but even when the display was not a concern, memory constraints usually sabotaged attempts to create the data-heavy design that an engine needs. Even on more accommodating platforms, very little could be reused between games. The rapid advance of arcade hardware —which

780-455: A heightfield occupies a box volume itself, recursively subdividing this box into eight subboxes (hence the 'oct' in octree) until individual heightfield elements are reached is efficient and natural. A quadtree is simply a 2D octree. PHIGS was the first commercial scene graph specification, and became an ANSI standard in 1988. Disparate implementations were provided by Unix hardware vendors. The HOOPS 3D Graphics System appears to have been

840-462: A high priority for game engines due to the wide variety of uses for which they are applied. Despite the specificity of the name "game engine", end-users often re-purpose game engines for other kinds of interactive applications with real-time graphical requirements—such as marketing demos , architectural visualizations , training simulations , and modeling environments. Some game engines only provide real-time 3D rendering capabilities instead of

900-602: A leaf node sends the object off for rendering to the renderer. Some implementations might render the object directly, which invokes the underlying rendering API , such as DirectX or OpenGL . But since the underlying implementation of the rendering API usually lacks portability, one might separate the scene graph and rendering systems instead. In order to accomplish this type of dispatching, several different approaches can be taken. In object-oriented languages such as C++ , this can easily be achieved by virtual functions , where each represents an operation that can be performed on

960-457: A linear list, while others support layers within layers to any desired depth. Internally, there may be no real structural difference between layers and groups at all, since they are both just nodes of a scene graph. If differences are needed, a common type declaration in C++ would be to make a generic node class, and then derive layers and groups as subclasses. A visibility member, for example, would be

1020-524: A more automated fashion. A raytracer, for example, will take a scene description of a 3D model and build an internal representation that breaks up its individual parts into bounding boxes (also called bounding slabs). These boxes are grouped hierarchically so that ray intersection tests (as part of visibility determination) can be efficiently computed. A group box that does not intersect an eye ray, for example, can entirely skip testing any of its members. A similar efficiency holds in 2D applications as well. If

1080-582: A newly capitalized U.S. company, Gamebase USA. Gamebase USA is based in the Research Triangle Park region of North Carolina and is focused on continual development of the Gamebryo game engine. The newest version, Gamebryo 4.0, was introduced in March 2012. The Gamebryo system is a suite of modular C++ libraries. Game developers can combine and extend the libraries to modify the engine for

1140-402: A node. Virtual functions are simple to write, but it is usually impossible to add new operations to nodes without access to the source code. Alternatively, the visitor pattern can be used. This has a similar disadvantage in that it is similarly difficult to add new node types. Other techniques involve the use of RTTI ( Run-Time Type Information ). The operation can be realised as a class that

1200-412: A particular game. Gamebryo's design emphasises a rapid prototyping approach aimed at an iterative development process . The Gamebryo engine supports several deployment platforms including Microsoft Windows ( DirectX 6–11), Mac , iOS , Android , Linux ( OpenGL ), GameCube , Wii , PlayStation , PS2 , PSP , PS3 , PS4 , Xbox , Xbox 360 , and Xbox One . Gamebryo 4.0 is the latest version of

1260-713: A run, rather than move at a constant speed like in earlier platformers. While third-party game engines were not common up until the rise of 3D computer graphics in the 1990s, there were several 2D game creation systems produced in the 1980s for independent video game development . These include Pinball Construction Set (1983), ASCII 's War Game Construction Kit (1983), Thunder Force Construction (1984), Adventure Construction Set (1984), Garry Kitchen's GameMaker (1985), Wargame Construction Set (1986), Shoot-'Em-Up Construction Kit (1987), Arcade Game Construction Kit (1988), and most popularly ASCII's RPG Maker engines from 1998 onward. Klik & Play (1994)

SECTION 20

#1732779847078

1320-430: A strong separation between rendering, scripting, artwork, and level design . It is now common, for example, for a typical game development team to have several times as many artists as actual programmers. First-person shooter games remain the predominant users of third-party game engines, but they are now also being used in other genres . For example, the role-playing video game The Elder Scrolls III: Morrowind and

1380-429: A very long time to compute from design scene graphs, and must be recomputed if the design scene graph changes, so the levels tend to remain static, and dynamic characters aren't generally considered in the spatial partitioning scheme. Scene graphs for dense regular objects such as heightfields and polygon meshes tend to employ quadtrees and octrees , which are specialized variants of a 3D bounding box hierarchy. Since

1440-617: Is a low cost robust audio library and toolset. Havok provides a robust physics simulation system, along with a suite of animation and behavior applications. Scaleform provides GFx for high performance Flash UI and high-quality video playback, and an Input Method Editor (IME) add-on for in-game Asian chat support. Other middleware is used for performance optimisation—for example ' Simplygon ' helps to optimise and generate level of detail meshes, and ' Umbra ' adds occlusion culling optimisations to 3d graphics. Some middleware contains full source code , others just provide an API reference for

1500-520: Is a separate scene node, but the graphical representation of the knight (made up of a 3D mesh, textures, materials and shaders) is instanced. This means that only a single copy of the data is kept, which is then referenced by any 'knight' nodes in the scene graph. This allows a reduced memory budget and increased speed, since when a new knight node is created, the appearance data needs not be duplicated. The simplest form of scene graph uses an array or linked list data structure , and displaying its shapes

1560-424: Is a spatial structure, but doesn't have to partition the geometry (see spatial partitioning below). A BVH is a tree of bounding volumes (often spheres, axis-aligned bounding boxes or oriented bounding boxes). At the bottom of the hierarchy, the size of the volume is just large enough to encompass a single object tightly (or possibly even some smaller fraction of an object in high resolution BVHs). As one ascends

1620-472: Is a valuable advantage in the competitive video game industry . While there was a strong rivalry between Epic and id around 2000, since then Epic's Unreal Engine has been far more popular than id Tech 4 and its successor id Tech 5 . Modern game engines are some of the most complex applications written, often featuring dozens of finely tuned systems interacting to ensure a precisely controlled user experience. The continued evolution of game engines has created

1680-506: Is an efficient and natural way to process such operations. A common feature, for instance, is the ability to group related shapes and objects into a compound object that can then be manipulated as easily as a single object. In vector-based graphics editing, each leaf node in a scene graph represents some atomic unit of the document, usually a shape such as an ellipse or Bezier path . Although shapes themselves (particularly paths) can be decomposed further into nodes such as spline nodes , it

1740-436: Is another legacy offering that is still available. The term "game engine" arose in the mid-1990s, especially in connection with 3D games such as first-person shooters with a first-person shooter engine . Epic games, founded by developer Tim Sweeney, debuted Unreal Engine in the year 1998. Such was the popularity of Id Software 's Doom and Quake games that, rather than work from scratch, other developers licensed

1800-423: Is passed to the current node; it then queries the node's type using RTTI and looks up the correct operation in an array of callbacks or functors . This requires that the map of types to callbacks or functors be initialized at runtime, but offers more flexibility, speed and extensibility. Variations on these techniques exist, and new methods can offer added benefits. One alternative is scene graph rebuilding, where

1860-446: Is practical to think of the scene graph as composed of shapes rather than going to a lower level of representation. Another useful and user-driven node concept is the layer . A layer acts like a transparent sheet upon which any number of shapes and shape groups can be placed. The document then becomes a set of layers, any of which can be conveniently made invisible, dimmed, or locked (made read-only). Some applications place all layers in

Gamebryo - Misplaced Pages Continue

1920-540: Is simply a matter of linearly iterating the nodes one by one. Other common operations, such as checking to see which shape intersects the mouse pointer are also done via linear searches. For small scene graphs, this tends to suffice. Applying an operation on a scene graph requires some way of dispatching an operation based on a node's type. For example, in a render operation, a transformation group node would accumulate its transformation by matrix multiplication, vector displacement, quaternions or Euler angles . After which

1980-575: Is usually static and generally contains non-moving scene data in some partitioned form. Some systems may have the systems and their rendering separately. This is fine and there are no real advantages to either method. In particular, it is bad to have the scene graph contained within the spatial partitioning system, as the scene graph is better thought of as the grander system to the spatial partitioning. Very large drawings, or scene graphs that are generated solely at runtime (as happens in ray tracing rendering programs), require defining of group nodes in

2040-913: The MMORPG Dark Age of Camelot are based on the Gamebryo engine, and the MMORPG Lineage II is based on the Unreal Engine. Game engines are used for games originally developed for home consoles as well; for example, the RenderWare engine is used in the Grand Theft Auto and Burnout franchises. Threading is taking on more importance due to modern multi-core systems (e.g. Cell ) and increased demands in realism. Typical threads involve rendering, streaming, audio, and physics. Racing games have typically been at

2100-514: The 1980s that are also considered to be game engines, such as Sierra's Adventure Game Interpreter (AGI) and SCI systems, LucasArts' SCUMM system and Incentive Software 's Freescape engine (in 1986 ). Unlike most modern game engines, these game engines were never used in any third-party products (except for the SCUMM system which was licensed to and used by Humongous Entertainment ). As game engine technology matures and becomes more user-friendly,

2160-484: The Xbox Live Indie Games channel designed specifically for smaller developers who do not have the extensive resources necessary to box games for sale on retail shelves. It is becoming easier and cheaper than ever to develop game engines for platforms that support managed frameworks. Producers of game engines decide how they allow users to utilize their products. Just as gaming is an industry , so are

2220-834: The application of game engines has broadened in scope. They are now being used for serious games : visualization, training, medical, and military simulation applications, with the CryEngine being one example. To facilitate this accessibility, new hardware platforms are now being targeted by game engines, including mobile phones (e.g. Android phones, iPhone ) and web browsers (e.g. WebGL , Shockwave , Flash , Trinigy 's WebVision, Silverlight , Unity Web Player , O3D and pure DHTML ). Additionally, more game engines are being built upon higher level languages such as Java and C# / .NET (e.g. TorqueX , and Visual3D.NET ), Python ( Panda3D ), or Lua Script (Leadwerks). As most 3D rich games are now mostly GPU -limited (i.e. limited by

2280-458: The box , to develop a game application while reducing costs, complexities, and time-to-market—all critical factors in the highly competitive video-game industry . Like other types of middleware, game engines usually provide platform abstraction , allowing the same game to run on various platforms (including game consoles and personal computers) with few, if any, changes made to the game source-code . Often, programmers design game engines with

2340-438: The components of an engine may become outdated or insufficient for the requirements of a given project . Since the complexity of programming an entirely new engine may result in unwanted delays (or necessitate that a project restart from the beginning), an engine-development team may elect to update their existing engine with newer functionality or components. Before game engines, games were typically written as singular entities:

2400-428: The core portions of the software and designed their own graphics, characters, weapons and levels —the "game content" or "game assets". Separation of game-specific rules and data from basic concepts like collision detection and game entity meant that teams could grow and specialize. Later games, such as id Software 's Quake III Arena and Epic Games 's 1998 Unreal were designed with this approach in mind, with

2460-474: The development staff of Gamebryo was downsized, and by July 2010 the engineering office in Chapel Hill, North Carolina was closed. On November 11, 2010, assets of EGT were offered for acquisition, including its intellectual Property (IP), in whole or in part. In December 2010, Korea-based Gamebase Co., Ltd., a longtime partner of EGT, finalized the acquisition of EGT assets and technology, and established

Gamebryo - Misplaced Pages Continue

2520-516: The engine and content developed separately. The practice of licensing such technology has proved to be a useful auxiliary revenue stream for some game developers, as one license for a high-end commercial game engine can range from US$ 10,000 to millions of dollars, and the number of licensees can reach several dozen companies, as seen with the Unreal Engine . At the very least, reusable engines make developing game sequels faster and easier, which

2580-542: The engine, designed to merge the original Gamebryo system with its LightSpeed spin-off. Gamebryo is used by numerous companies within the gaming industry. Below is a sample of titles that have used the engine: Game engine Game engine can also refer to the development software supporting this framework, typically a suite of tools and features for developing games. Developers can use game engines to construct games for video game consoles and other types of computers . The core functionality typically provided by

2640-434: The engines they are built off. The major game engines come at varying prices, whether it be in the form of subscription fees or license payments. Unity and the Unreal Engine are currently the two most popular choices for game developers. Although the differences among the different game engines blur as they build their own tools on top of them, different game developers may be too used to a system to change, or attracted by

2700-417: The first commercial scene graph library provided by a single software vendor. It was designed to run on disparate lower-level 2D and 3D interfaces, with the first major production version (v3.0) completed in 1991. Silicon Graphics (SGI) released OpenGL Performer or more commonly called Performer in 1991 which was the primary scenegraph system for most SGI products into the future. IRIS Inventor 1.0 (1992)

2760-477: The forefront of threading with the physics engine running in a separate thread long before other core subsystems were moved, partly because rendering and related tasks need updating at only 30–60 Hz. For example, on PlayStation 3, physics ran in Need For Speed at 100 Hz versus Forza Motorsport 2 at 360 Hz. Although the term was first used in the 1990s, there are a few earlier systems in

2820-549: The hierarchy, each node has its own volume that tightly encompasses all the volumes beneath it. At the root of the tree is a volume that encompasses all the volumes in the tree (the whole scene). BVHs are useful for speeding up collision detection between objects. If an object's bounding volume does not intersect a volume higher in the tree, it cannot intersect any object below that node (so they are all rejected very quickly). There are some similarities between BVHs and scene graphs. A scene graph can easily be adapted to include/become

2880-704: The huge benefits of such engines regardless of pay-walls. In the broader sense of the term, game engines themselves can be described as middleware. In the context of video games, however, the term "middleware" is often used to refer to subsystems of functionality within a game engine. Some game middleware does only one thing but does it more convincingly or more efficiently than general purpose middleware. The four most widely used middleware packages that provide subsystems of functionality include RAD Game Tools ' Bink, Firelight FMOD , Havok , and Scaleform GFx. RAD Game Tools develops Bink for basic video rendering, along with Miles audio, and Granny 3D rendering. Firelight FMOD

2940-484: The mid-1980s was the smooth side-scrolling engine developed by Shigeru Miyamoto 's team at Nintendo for the Nintendo Entertainment System (NES). The engine they had developed for the side-scrolling racing game Excitebike (1984) was later employed for the scrolling platformer Super Mario Bros. (1985). This had the effect of allowing Mario to smoothly accelerate from a walk to

3000-511: The power of the graphics card), the potential slowdown due to translation overheads of higher level languages becomes negligible, while the productivity gains offered by these languages work to the game engine developers' benefit. These recent trends are being propelled by companies such as Microsoft to support indie game development. Microsoft developed XNA as the SDK of choice for all video games released on Xbox and related products. This includes

3060-508: The process is known as employing the Painter's algorithm . In 3D systems, which often employ depth buffers , it is more efficient to draw the closest objects first, since farther objects often need only be depth-tested instead of actually rendered, because they are occluded by nearer objects. Bounding Volume Hierarchies (BVHs) are useful for numerous tasks – including efficient culling and speeding up collision detection between objects. A BVH

SECTION 50

#1732779847078

3120-453: The root of the scene graph), applying the operation(s) (often the updating and rendering operations are applied one after the other), and recursively moving down the scene graph (tree) to the child nodes, until a leaf node is reached. At this point, many scene graph engines then traverse back up the tree, applying a similar operation. For example, consider a render operation that takes transformations into account: while recursively traversing down

3180-510: The same game engine to produce different games or to aid in porting games to multiple platforms. In many cases, game engines provide a suite of visual development tools in addition to reusable software components. These tools are generally provided in an integrated development environment to enable simplified, rapid development of games in a data-driven manner. Game-engine developers often attempt to preempt implementer needs by developing robust software suites which include many elements

3240-505: The scene graph hierarchy, a pre-render operation is called. If the node is a transformation node, it adds its own transformation to the current transformation matrix. Once the operation finishes traversing all the children of a node, it calls the node's post-render operation so that the transformation node can undo the transformation. This approach drastically reduces the necessary amount of matrix multiplication. Some scene graph operations are actually more efficient when nodes are traversed in

3300-406: The scene graph is rebuilt for each of the operations performed. This, however, can be very slow, but produces a highly optimised scene graph. It demonstrates that a good scene graph implementation depends heavily on the application in which it is used. Traversals are the key to the power of applying operations to scene graphs. A traversal generally consists of starting at some arbitrary node (often

3360-614: The user has magnified a document so that only part of it is visible on his computer screen, and then scrolls in it, it is useful to use a bounding box (or in this case, a bounding rectangle scheme) to quickly determine which scene graph elements are visible and thus actually need to be drawn. Depending on the particulars of the application's drawing performance, a large part of the scene graph's design can be impacted by rendering efficiency considerations. In 3D video games such as Quake , binary space partitioning (BSP) trees are heavily favored to minimize visibility tests. BSP trees, however, take

3420-660: The wide range of functionality needed by games. These engines rely upon the game developer to implement the rest of this functionality or to assemble it from other game-middleware components. These types of engines are generally referred to as a "graphics engine", "rendering engine", or "3D engine" instead of the more encompassing term "game engine". This terminology is inconsistently used, as many full-featured 3D game engines are referred to simply as "3D engines". Examples of graphics engines include: Crystal Space , Genesis3D , Irrlicht , OGRE , RealmForge, Truevision3D, and Vision Engine . Modern game- or graphics-engines generally provide

3480-565: Was founded in 1983, mostly doing contract work for government and CAD clients in the computer graphics sector, though also some game developers such as Interactive Magic . This work led to the production of the NetImmerse game engine in 1997, evolving into Gamebryo by 2003. NDL was merged into Emergent Game Technologies (EGT, founded 2000, Butterfly.net until May 2005) in August 2005. NetImmerse then evolved to Gamebryo LightSpeed. During 2009

3540-512: Was released by SGI, which was a high level scene graph built on top of Performer. It was followed up with Open Inventor in 1994, another iteration of the high level scene graph built on top of newer releases of Performer. More 3D scene graph libraries can be found in Category:3D scenegraph APIs . X3D is a royalty-free open standards file format and run-time architecture to represent and communicate 3D scenes and objects using XML . It

3600-596: Was the leading edge of the market at the time—meant that most of the code would have to be thrown out afterwards anyway, as later generations of games would use completely different game designs that took advantage of extra resources. Thus most game designs through the 1980s were designed through a hard-coded rule set with a small number of levels and graphics data. Since the golden age of arcade video games , it became common for video game companies to develop in-house game engines for use with first-party software. A notable example of an in-house game engine on home consoles in

#77922