| |
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!
Engine
Supported 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
|
|
