文章目錄
- Logic System
- Platform
- Other Features
Description
NeoAxis Engine is a game engine and toolkit designed for the creation of game titles for all genres, as well as 3D Visualization and Virtual Reality projects.
Features
- The engine is designed for maximum convenience and expandability.
- Due to its unique entity and logic systems, both construction and integration of game logic is simple and transparent.
- Our versatile and feature-rich toolkit simplifies the writing of game logic and the creation of game content with modules like the expandable Resource and Map Editors.
- Utilizes the power and convenience of C# and the .Net platform and is compatible with any .Net supported programming language.
Our goal is to make NeoAxis Engine as convenient and intuitive as possible!
EngineSupported platforms
Entity System
The Entity System is the heart of NeoAxis Engine.
Through this uniform system all game logic is created.
For any game or application there is a specialized object system and within this, a set of objects and rules for their interaction. Users can describe objects, algorithms for their functioning, and methods of interrelation with other objects in the game world. Base objects can also be organized to facilitate the creation of new objects with minimal effort. Because of this structure the game's object system should symbolically represent the real world well, making it possible to easily conceptually identify the game world and objects within it.
Usually in the game there is a world. The game simulates through levels. Each level behaves through the rules of the world along with properties specific to that level.
Each entity has a class and a type.
The entity class is a base algorithm of entity behavior. Entity classes are written in programming language and are easily integrated into the system. Such integration allows one to expand upon the editors (resource and the map editors) without directly modifying them.
The type of an entity is defined through adjustments of properties of the entity class. Entity types are created and adjusted in the resource editor (.type files). The adjustment of entities entails the configuration of various object properties (appearance of characters, maximum quantity of lives, etc.).
Logic System
It often becomes necessary to stratify logic into specific levels of code. For the convenient definition of such logic, our logic system allows you to expand base game elements with additional functionality.
Programmers write the basic game logic in the programming language and level designers can expand this functionality within the level, visually or through scripts.
Supported methods for defining level logic:
- Visually
Gives level designs the opportunity to design level logic without the need of scripts. Algorithms are represented in the form of trees.
- Scripting
More typical way of defining logic by use of a scripting language.
Map System
The map system is at core, an expansion of the entity system which allows you to positions entities in space, attach them to an appearance, work with physical models, and more. It is a set of algorithms which as a whole constitute the realization of your 3D world.
There are fundamental classes, such as the map (Map) and objects of a map (MapObject), which are expanded entities that lay down a top the map and provide functionality.
Attached Objects System
The attached objects system allows to attach various objects to entities:
- Entities
You can attach any entity to other entities which makes it easy to create complex dynamic constructions. For example: you could easily attach a animated rotating machine gun mesh to a helicopter, and turn them into functioning machine guns. Such a system would also allow the attachment of weapons or armor to characters.
- Meshes
- Particle systems
- Billboards
- Ribbon trails
- Lights
- In-game GUI
- Sounds
Objects can be attached to bodies of physical model of object. Also can be attached to bones of 3D models.
Render
The OGRE rendering engine is used.
Platform
- Direct3D and OpenGL support
Materials and shaders
- Powerful material declaration language (.material files)
- Supports vertex and fragment programs (shaders), both low-level programs written in assembler, and high-level programs written in Cg, DirectX9 HLSL, or GLSL and provides automatic support for many commonly bound constant parameters like worldview matrices, light state information, object space eye position etc
- Support for multiple material techniques means you can design in alternative effects for a wide range of cards and engine automatically uses the best one supported
- Material LOD support; your materials can reduce in cost as the objects using them get further away
- Load textures from PNG, JPEG, TGA, HDR, BMP, PSD or DDS files, including formats like 1D textures, volumetric textures, cubemaps and compressed textures (DXT/S3TC)
- Per-pixel lighting
- Normal mapping
- Parallax mapping
- Cubemap reflections
64-bit High Dynamic Range rendering
- Bloom
- Adaptive exposure
- Tone mapping
Shadows
- Shadow maps
- Soft shadows
- Self-shadowing
- Correct shadows from alpha test objects
- Stencil shadows
Meshes
- Progressive meshes (LOD), manual or automatically generated
- Static geometry batcher
Animation
- Blending of multiple animations with variable weights
- Manual bone control
- Software and hardware-accelerated skinning pipelines with intelligent buffer sharing
- Configurable interpolation modes, accuracy vs speed tradeoffs
Scene Features
- Indoor/outdoor portal system. Work in mixed indoor and outdoor scenes.
- Occluders
- Octtree scene split
- Multiple shadow rendering techniques, both modulative and additive techniques, stencil and texture based, each highly configurable and taking full advantage of any hardware acceleration available.
- Scene querying features
Special Effects
- Custom file format for the declaration of particle systems (.particle files)
- Particle Systems, including easily extensible emitters, affectors and renderers
- Automatic use of particle pooling for maximum performance
- Support for skyboxes, skyplanes and skydomes
- Compositor system, allowing for full-screen post-processing effects, defined easily via scripts if desired
- Custom file format for posteffects (.compositor files)
- Ribbon trails
- Transparent objects automatically managed (rendering order & depth buffer settings all set up for you)
Other Features
- Opportunity to limit the version of shaders
- Full screen antialiasing
- Filtration control: bilinear, trilinear, anisotropic 2-16x
Physics
- Abstract wrapper for physics. Easy to implement another third-party physics library.
- Ageia PhysX implemented (requires license for PhysX)
- ODE implemented. Expanded by continuous collision detection.
- File format for the declaration of physical models (.physics files)
- Primitives: boxes, spheres, capsules, user-defined triangular mesh collision detection
- Joints: hinge, universal, ball, hinge2, slider, fixed
- Motors: attractor, geared, servo
- Linear and angular motion damping
- Breakable joints
- Per shape collision events
- Per shape ray casts
- Volume casts
- Events: Collision event handler, Joint break event handler
- Contact groups (define which objects can interact physically)
- Physics materials
- Per-shape material settings
- Ragdolls
User Interface System
The user interface system is a unified system for the creation of end-user controls, menus, dialogues, windows and HUD screens.
The workflow for this system is surprisingly simple. In the resource editor, the designer creates controls and game screens visually, and then places on them UI elements. Consequentially, the programmer (or level designer) uses the elements created by the designer. By writing new code or utilizing the logic system, the programmer can implement data and set event controls.
The UI class is a programming class which creates a basic element of UI management. Buttons, check boxes, and lists are examples of the UI class.
UI model is an object of one of the aforementioned base UI classes, which can in turn contain other UI objects. Specific instances of buttons, menus (containing a set of buttons), a window with options, and indivisible HUD screens are all examples of the UI model. In our resource files, UI models are presented with the .gui file extension.
- Specific file format for UI model definition (.gui files)
- Any UI model can be enclosed within another.
Example 1. - You can create a game menu which is a UI model. Next, you can create a framework, insert a heading and then place buttons (each separate UI models)
Example 2. - You can create a list (ListBox) and within its elements, place checkboxes, pictures and any other controls.
- UI models inherit from UI classes or from other UI models. For example, you can create the design of basic button (built from the base class Button) and then modify and reuse the design for application elsewhere.
- Base UI classes
- Control - the parent class of all UI classes. Allows you to define a name and to adjust the color and set a background texture.
- Button
- TextBox - control for a text output
- CheckBox
- ComboBox
- ScrollBar - horizontal or vertical
- ListBox
- TabControl - bookmarks of pages
- EditBox
- VideoBox (based on the Ogg Theora Video)
- By inheriting from these base classes you can create and extend your own UI classes.
- In-game GUI
Sound
- Abstract wrapper for a sound. Easy to implement another third-party sound library.
- FMOD implementation (requires license for FMOD)
- DirectSound implementation
- Virtual channels management. Virtual channels allow thousands of channels to play on limited hardware/software. Sounds are swapped in and out according to 3d distance and priority.
- Binding sounds to entities (through the attached objects system)
- Management of reproduction channels groups. You can share sounds with groups. For example: sounds with differing volume levels can be organized into separate groups so that the volume level for all objects of a group can be adjusted at once.
- 3D sound
- Streaming
- Microphone input
Virtual File System
- The general control system for resources
- File archives support. An interface for file archive type creation has been added.
- Zip archives support
Additional Features
- Framework for creation of new game types and other projects
- Curves
Bezier, uniform cubic splines. Adjustment in the Map Editor.
- Cameras management
Simple cameras and cameras which can move on curves.
- Cut Scene Manager
Adjustment of cut scenes in the Map Editor.
- Dynamic objects
An object with a lifespan, sounds and damage for the collision of physical bodies, and management of influences.
- Units
A unit differs from a dynamic object by the presence of and is controlled by an intelligence.
- Physical characters
- Turrets
A turret can be rotated. Guns are attached on the tower and player can control the aiming and shooting of the turret.
- Factions
Concept of the command. Opponents with an artificial intelligences attack units of another's fraction.
- Influences
Influences are effects on objects. For example, the ability to burn a monster, is implemented through the use of influences.
- Bullets
- Explosions
An invisible blast wave which damages and increases the impulse of physical models within a radius.
- Items
Items which can be picked up by units. Med-kits, weapons, ammunition.
- Doors
Automatically opening doors
- Switches
Boolean and quantitative.
- Weapons
Guns, melee weapons. Both hand-held by characters or guns established on turret are weapons.
- Fans
- Start and respawn points
- Physical streams
You can create steam, fiery streams, etc.
Artificial Intelligence
- Unit-intellect framework
This takes the form of either AI (Artificial Intelligence) or player control over a unit . There is inherit AI base base for an computer-controlled intellect. For example, there is the GameCharacterAI class which is designed for the management of a game character. Control by a live player is achieved through the commands of pressed keys or the mouse for control of the unit or turret.
- Expandable grid-based path finding system.
Tools
Currently, the developer toolkit includes the following utilities: the Resource Editor, Map Editor, and exporter plug-ins for the popular modeling and animation packages.
- Exporter plug-ins from the popular modeling and animation packages, with support for multiple materials, import, and skeletal animation data:
- Autodesk 3D Studio Max
- Autodesk Maya
- SoftImage XSI
- Milkshape
- Lightwave
- Blender
- AC3D
- Wings3D
- We provide the full source code for these editors and the right to distribute them with your game title. This is very convenient for mod-makers, and enthusiasts and can provide a more substantial longevity for your game title.
Resource Editor
All files within the engine are resources, and are further divided by type.
The resource editor is intended for the centralized management, editing and creation of resources of various types.
- The entity type editor (.type files)
Allows developers to fully configure all types of game entities, and to adjust attached objects visually through the created type.
The entity type editor is extendable due to its exterior dynamic linking assemblies.
- Gui Editor
- Particle system editor
- Physics model editor
- Model viewer that can change materials, LOD adjustment and view animations (.mesh and .skeleton file formats)
- View textures
- Listen to sound files
- View video files
Map Editor
The Map Editor is intended for map editing as well as the placement and adjustment of game entities. This is achieved through the adjustment of properties and further functionality can be extended through the logic system.
- The editor is extendable due to its exterior dynamic linking assemblies.
- Visual arrangement and editing of any game entities, such as: static objects, items, characters, light sources, etc. All objects can be edited by a level designer through properties, which programmers can provide.
- The game logic editor allows developers to specify game logic within the limits of a map. Any entity can be expanded on through the logic editor. Visual and scripted development is supported.
- The heightmap based landscape editor
- The Map Editor is a full realization of the "What You See Is What You Get" toolkit design philosophy.
- No compile times! Simply press "Run simulation" to instantly interact with your map!
- Undo/redo support
- Layers
- Gizmo
