How easy is it to use the Untold Engine?

I'm the type of person that needs to know how things work at a deeper level. When dissecting a program, code, etc., my normal behavior is to start removing unnecessary code until only the minimum amount of code remains. Most of the time, when this is not possible, I try to build the piece of software from the bottom up. It is my nature as an engineer. I am not only interested in what IT can do, but I also need to know how it works.

This behavior carries over when I have to use tools that hide the API from the developer and forces me to use a Graphical Editor. It irritates me because I want to have full control. I want to control and know what is happening at any point in time. I am not against at Graphical Editors. I do find them very useful, but when I'm learning something, I want "Under-the-hood" access.

Therefore, when I started developing the Untold Engine, I opted for creating an API that is small, simple-to-use, and more importantly gives you the opportunity to know what is happening under-the-hood.

Let me show you the simplicity of the Untold Engine Framework.

Creating a 3D Character

Let's say you want to render the following character:


The first thing you need to do is to create a Game Object like this:

//Line 1. Create an instance of U4DGameObject type
U4DGameObject *myAstronaut=new U4DGameObject();

Once created, then you need to provide the object with its attributes and textures like this:

//Line 2. Load attribute (rendering information) into the game entity
// name of character: "astronaut"
// name of attributes file: "charactersAttributes.u4d"
if (myAstronaut->loadModel("astronaut","charactersAttributes.u4d")) {

    //Line 3. Load rendering information into the GPU


And finally you add it to the scenegraph:

//Line 4. Add astronaut to the scenegraph

And that is it.

Translating & Rotating a character

Translating a character

To move a character around, all you need to do is call either the translateTo() or translateBy() methods.

The translateTo() method will translate the character to a particular location. While the translateBy() method moves the character by a particular amount.

For example, the snippet below shows how to translate the character to location (-2.0,1.0,2.0).

//Line 5. Translate the game object to location (-2.0, 1.0, 2.0)
myAstronaut->translateTo(-2.0, 1.0, 2.0);

Rotating a character

Rotating a character is equally as simple. The Untold Engine provides two methods: rotateTo() and rotateBy().

The rotateTo() method rotates a character to a fixed orientation. Whereas, the rotateBy() method rotates the character by a certain angle.

For example, to rotate an entity to an orientation of 45 degrees about the y-axis, you use the method: rotateTo(), as shown below:

//Line 5. Rotate the character 45 degress about the y-axis
myAstronaut->rotateTo(0.0, 45.0, 0.0);

Animating a 3D character

The Untold Engine makes animating a character equally as simple. Let's say you want to render the following walking animation:


First, you would create an Animation Object, as shown below:

//Line 3. Create an Animation object and link it to the 3D model
walkAnimation=new U4DAnimation(myAstronaut);

Then, you need to load the animation data into the animation object, as shown below:

//Line 4. Load animation data into the animation object
if(myAstronaut->loadAnimationToModel(walkAnimation, "walking", "walkinganimation.u4d")){

    //If animation data was successfully loaded, you can set other parameters here. For now, we won't do this.


Finally, you simply play the animation object.

//Line 7. Check if the animation object exist and play the animation
if (walkAnimation!=nullptr) {



That is how easy it is to use the Untold Engine.

Of course, aside from the simple API, I also provide in-depth articles that explain what is happening under-the-hood.

Check out the engine at Untold Engine. It's free.

Thanks for reading.

Harold Serrano

Computer Graphics Enthusiast. Currently developing a 3D Game Engine.