Nimbus Graphics API

About

Nimbus is a graphics API, with an emphasis on ease of use and high performance 3D rendering. While working on my Aqua game engine I realized that many things did not fit right. After a while every new feature seemed more like a hack. It was clear that the core architecture needed a serious overhaul. I had two choices: one was to redesign the Aqua engine and the other was to let it give birth to a new engine. Setting aside the imagery of an “engine” giving birth, I chose to start over. It seemed like the right way to go since I wanted to change so much of it. Thus, the Nimbus was born.

Objectives

I began working on Nimbus about 2 months ago. Since then Nimbus has grown considerably and I am very happy with the progress so far. Initially I wanted to create a new engine but I realized that the things I had in mind apply to more than just an engine. I wanted to create a better framework for handling graphics than what XNA offered so I decided to work with DirectX 9 instead. This is a very different goal from the Aqua engine which was more of a learning experience for how the graphics pipeline fits together.

Data Visualization

An average game runs at about 30 to 60 frames per second. This means that game objects are updated at least 30 to 60 times every second. Sometimes it is very difficult to spot why something goes wrong when there are so many updates and changes to the object data. Often these data values can be visualized with a graph, making glitches and bugs more visible.

At the time I was also playing around with a graphics API called Xen. Xen is an excellent graphics API and is surprisingly mature considering it was written by one developer. I really liked the graph component that it has to offer, so I based my graph component off it. To use it I simply need to give it a pointer to a function which updates its current value. The graphs can be customized in several ways such as sample size, physical size, update speed, and colored “good” value ranges.

View Frustum Culling

Game scenes often contain large amounts of objects. Rendering and updating all of these objects can be a major problem. One way to reduce the amount of work required to render the scene is to partially ignore objects when they are not visible. This process of ignoring objects is called view frustum culling. Unfortunately, I added frustum culling late in the development process while working on Aqua. It was enforced only very weakly. For the new Nimbus engine, I felt that frustum culling was a really important feature and it had to be implemented right into the very core of the engine. Thus, any drawable object, using the Nimbus API, must implement a culling method. This ensures that objects are automatically culled.

Object Interaction

Editors are a vital part to game development. Being able to scale and rotate objects in the game world on the fly is a very useful and time saving feature. Therefore, I have begun to add object selection/picking features which will allow me to edit game objects in an intuitive way during run-time.