- Lukas Kalinowski
Games fascinated me even as a child. I was keen on understanding how a game does work behind the scenes. So I started to study media and computing to lay the foundations.
During my study, I started to develop an application in C++ to ease the creation of graphical simulation.
At that time I was inspired by Advanced Ogre Framework. Henceforward, all my projects where developed using the OgreBaseArchitecture, which is an DLL and can be linked to applications.
This had also the effect, that the OgreBaseArchitecture had been extended bit by bit. Now a few years have passed since 2010 and the engine is still growing. I re-branded the name to NOWA-Engine (NativeObjectWorldArchitecture-Engine). NOWA is a word play for the same polish word, which means ‘new’. Put It in another words: from something old, something new emerges like a star that explodes in a nova creating something new.
The idea of the NOWA-Engine is to ease the development of games as far as possible, so the engine is as generic as possible.
Thus a lot of design patterns are used in the engine like Observer-, Eventing system with delegate functions, generic factory-, Composite-, State-, Strategy-, Singleton-, Null-Object-pattern, Curiously recurring template pattern etc.
The NOWA-Engine is intended for C++ developer and Designer with basic knowledge of the scripting language Lua.
The developer can concentrate on a higher level building a game without the need of taking care of lower level issues.
The NOWA-Engine became a hobby project and will be extended in future.
Contained components of the NOWA-Engines:
- Graphics-Engine: Ogre-Engine
- Physics-Engine: OgreNewt (Port of Physics-Engine: “Newton Game Dynamics”)
- Audio: OgreAL (Port of 3D-Audio library OpenAL)
- Network: RakNet
- Particle-Effects: Particle Universe
- Ogre Realtime Shader: RT Shader System
- Ogre Terrain: Ogre Terrain System
- Sky/Weather simulation: Caelum
- Water simulation: Hydrax
- Scripting: Lua
- Pathfinding Recast navigation: OgreRecast
- Paged Geometry Instancing: PagedGeometry
- Wii-Controller input system: WiiUse
- Split meshes: MeshSplitter
- GUI: MyGui
The NOWA-Engine is now used in an runtime virtual environment editor called NOWA-Design.
Feature videos of NOWA-Engine:
A stress test with the NOWA-Engine and the NOWA-Design editor.
Scenario: Spawning lots of barels which are also physically simulated.
Ogre3D Threads 4, Newton Physics Threads 1: ~250 Barels FPS went down
Ogre3D Threads 4, Newton Physics Threads 4: ~650 Barels FPS went down
Note: In the video the FPS went down earlier because of the additional resources consumption of the screen capturing tool.
So what are the features of the NOWA-Engine:
- Nearly full OgreNewt physics integration:
- Static physics objects with complex collision, which can also be automatically serialized and deserialized, when something changed on the collision map for loading speedup. Also collision map for Ogre Terrain.
- Dynamic physics objects: For motion and physics handling for severial kinds of collision types: Quader, Ellipsoid, Pyramid, Capsule, Cylinder, Convexhull, Cone, CompoundCollisionHull, etc.
- Compositions: Compositions of dynamic physics objects to create more complex physics objects like connecting together a Convexhull with a Quader etc.
- Convex compound collisions: Creating most complex active physical components composed of convex hulls, that are forming together a complex collision hull. E.g. creating gears and rings.
- Constraints: (breakable) Hinge-, Slider-, Ball-And-Socket-, Motorized-, Screwcork-, CustomDryFriction-, Kinematic-, Pulley-, WormGear-, Spring-damping, Pin-Joints to constrain some motion behavior, e.g. creating breakable swing doors.
- Ragdolls: Integration of ragdolls for game objects with bones.
- Vehicle: Integration of vehicles to controll cars etc. (Unfinished)
- Category system to group kinds of physics objects together to perform collision behavior of game objects of different categories, ray casts.
- Physics material pairs to combine two different categories to specify physics behavior on collision, like creating a trampolin, on which a game object may jump higher.
- Buoyancy integration for motion behavior of game objects in liquid.
- Motion constraints: Its possible to constraint axes for a object. E.g. eliminating the z-axis could be useful for 2D Jump’ n’ Run games, in which the physics just works for x- and y-axis.
- The NOWA-Engine uses a state system to create own levels, menues etc.
- Generic GameObject factory, to create GameObjects, which are composed of several components, like physics component, shader component etc.
- It uses Ogre2.x version and “Physically Based Shading” (PBS) to keep pace with newest rendering techniques.
- Event-Delegate system to ease the communcation between different modules.
- Process system to create chained events like explosion of bombs etc.
- Different kinds of game loops (VSync restricted, unrestricted and adaptive).
- MyGui layout.
- Artificial Intelligence to integrate to game object, to move autonome, like seek, flee, move-path, flocking, arrive etc.
- Ability to create navigation maps and obstacles for A* path finding.
- GameObjectController: Database for gameobjects. Its possible to perform a lot of different queries, to receive the desired game objects.
- Realtime camera manager, to specify camera behavior like base-, first-person, third-person camera and switch between the modes at runtime.
- Game object name display above the head.
- Skeleton visualizer to debug bones of game objects etc.
- Animation fader, to interpolate between to animation to create a more realistic game object motion.
- Camcorder to record and playback camera motions
- Screenshot manager
- Lua scripting:
- Lua script integration, to write lua code and control game objects at runtime. Furthermore with the introduction of the LuaScriptComponent, possibility to code everything in Lua.
- Build in console for scripting and logging.
- Physically based shading (PBS) for realistic scene rendering and complex shadows.
- Several predefinded workspaces: PBS, PBS and Skybox, PBS, Skybox and reflections.
- Directional-, Spot- and Point-lights, which can be mixed.
- Compositor effects for the screen like motion blur etc.
- Water simulation, which can be connected with buoyancy for phyical water motion behavior of game objects.
- 3D Audio system to connect to game objects and states for sounds and music.
- Editor manager: Class container with a lot of functionalities like game objects manipulation via Gizmo, Undo/Redo, MyGUI integration etc. to create a runtime editor.
- Picker: In order to grab and play with dynamic physics objects.
- A lot of free resources like meshes, animations, sounds, particle effects etc.
- Integration of server/client topology.
- Replicating game objects like players statically by cloning GameObjects at realtime.
- Efficient automatic dispatch of movements of game objects using the procedure “playout delays”.
- Area of interest: Information about a game object will only be sent to other remote game objects, if there are in range.
- A lot of things! Since my timewindow is small.
- Instancing for collision objects.
- Other constraints like magnets, pulley joint etc.
- Planet systems
- AiComponents: AiMoveComponent, AiMoveRandomlyComponent, AiPathFollowComponent, AiWanderComponent, AiFlockingComponent, AiRecastPathNavigationComponent, AiObstacleAvoidanceComponent, AiHideComponent
- AiLuaComponent: Possibilty in Lua to describe ai states and behaviors.
- AnimationComponent: GameObject can be animated (if skeleton does exist).
- AttributesComponent: Custom attributes may be set for the game like energy, strength etc.
- BuoyancyComponent: Physical fluid behavior
- DistributedComponent: Movable component, that is transmitted via network for synchronization amongst players.
- GameObjectTitleComponent: A game object title is shown with custom text.
- ExitComponent: Level exit component. When reached, a new level will be loaded.
- NavMeshComponent: A*-navigation component, which is used as obstacle, so that the path is computed around the obstacle.
- ParticleUniverseComponent: Used for particle effects
- PhysicsActiveComponent: Physics component that is dynamic and uses law of forces.
- PhysicsActiveCompoundComponent: Active physics component, that is build of several collision pieces, forming a more complex collision hull, like a ring.
- PhysicsCompoundConnectionComponent: Active physics component, that is build of several components, forming a more complex collision hull.
- PhysicsMaterialComponent: Used to connect to physics groups together and adding specifig physics materials like elasticity, friction, conveyor and even Lua callbacks when a physics collision occured, to react in Lua.
- PlayerControllerComponents: PlayerController3DComponent, PlayerControllerClickToPointComponent (unfinished)
- PhysicsArtifactComponent: Physics component, that will never be moved. Collision hull may be complex like buildings etc.
- PhysicsRagdollComponent: Physics component, that is described in a XML file forming a physics ragdoll of a game object, that has a skeleton.
- SimpleSoundComponent: Sound component, that 5.1 dolby surround.
- SpawnComponent: This component is able, to produce other game objects with all its components.
- NodeTrackComponent: Node animation track component, which does work with NodeComponents for animation pathes.
- NodeComponent: This component can be used as placeholder for positions and orientations for other components, like the path follow component or node track component.
- TimeTriggerComponent: Component which activates other components at a specifig time.
- PlaneComponent: With this component a floor or walls can be created.
- CameraComponent: This component is used, to control the camera or switch to a different camera.
- LightDirectionalComponent: Directional light
- LightSpotComponent: Spot light
- LightPointComponent: Point light
- CompositorEffectComponent: Compositor effects for post screen space effect like motion blur etc.
- AreaOfInterestComponent: Component to react when a specifig game object category is in the range of this component. Reaction is also possible in a Lua script.
- BillboardComponent: Component to place sprites, that are always orientated at the camera for visual effects.
- RibbonTrailComponent: Component for special effects like trails
- CameraBehaviorComponents: BaseCameraComponent, FirstPersonCameraComponent, ThirdPersonCameraComponent, FollowPlayer2DCameraComponent
- LookAfterComponent: A bone can be choosen like the neck, so that the game object will look at a specifig target.
- DatablockComponent: With this component the visualization of a game object can be manipulated. The underlying technology is physically based shading.
- TagPointComponent: Component, with which other game objects can be attached to a bone, e.g. holding a weapon.
- TagChildNodeComponent: Component, with which a game object’s node is attached as a child. E.g. attaching a light to another game object, to follow the object.
- MaterialContactBehaviour (ConveyorPlayer, ConveyorObject)
- LuaScriptModule (Singleton)
- OgreALModule (Singleton)
- OgreNewtModule (Singleton)
- OgreRecastModule (no Singleton)
- ParticleUniverseModule (Singleton)
- RakNetModule (Singleton)
- WorkspaceModule (no Singleton)
- GameProgressModule (Singleton)
Whats still left:
The most import piece is the GameObject. A GameObject represents a model in the scene. It contains mainly a position, orientation, scale and a mesh. A GameObject may be composed of so called Components. This is a really powerful design pattern. Because each Component comes with a specific behaviour. By adding Components to a GameObject, the GameObject will be armed with the functionality of the Components. Thus a GameObject knows its Components and each Component knows its GameObject (owner). Therefore a Component can also communicate via its owner with another Component. This design architecture prevents derivation explosion, as there is just the game object and a list of components.
GameObjects are gathered by the GameObjectController. It keeps track of the lifecycle of GameObjects and has a lot of manipulation functionality. Like cloning GameObjects, query GameObjects, add categories of GameObjects to group them together for ray scene queries and physics materials. Its also possible to activate (heavy) game objects when player is in a certain range and deactivate when the player leaves the range.
The next important piece is the DotSceneImportModule. The DotSceneImportModule is responsible for loading and parsing virtual environments described in XML. In order to save a virtual environment to XML, the DotSceneExportModule is used. In the past the Ogitor was used but it has been abandoned, as the Ogitor has being stopped developed.
Hence yeah! Why not creating an own virtual environment editor??? Thus the NOWA-Design editor has been created for this task.
At that time a GameObject can be combined with following components:
Physics Components can also be connected together with joints (constraints). This joints are managed by so called JointComponents. The following JointComponents types are available:
A joint can also be released, e.g. to simulate breakable joints (see PhysicsActiveDestructableComponent).
Physics Components can also have physics materials. With this material component the physical behaviour between groups of physics components is specifed. E.g. whether a GameObject of the category ‘vehicle’ will have a high friction with the GameObject of the category ‘ground’ etc. The following material attributes are available:
The NOWA-Engine comes with a lot of helper modules, which support GameObject, Components etc. by its tasks. A module can be a Singleton when it does make sense, but not every module is one. The following modules can be listed: