Software Engines

I have noticed, after the new features that I have added to the project, that the framerate has become very slow.

There are a number of possible explanations for this. The first one that springs to mind is the fact that I am using, for some of my rendering, the older GlBegin() and GlEnd() pairs. This is known as “Direct Mode” and is significantly slower than the modern approach of using VBO’s, or “Vertex Buffer Objects”. Switching to indirect mode at this stage would be a lot of work, however, and I have a feeling that the performance bottleneck is elsewhere in the code.

I could also implement Frustum culling to improve performance. Frustum culling is where only the objects within the view frustum are rendered. At the moment, I have not implemented any optimisations at all, so every poly is being drawn, regardless of whether or not it is in view. This is very inefficient, and frustum culling could improve performance a lot.

There are also, no doubt, other areas in the code that could be optimised to improve performance.

I have successfully implemented click detection and object selection in the game engine.

Originally, I used the “official” method of  first creating a mouse callback, and then using code to select the objects close to the position that the player clicked. I used glLoadName() to identify the world objects. This didn’t work well at all, I would guess because the code was not able to precisely determine a vector from the 2D screen coordinates into the 3D world. It used glPerspective() to create a narrow view frustum around the players click coordinates, and returned the glLoadName() ids of all of the objects inside. However, that view frustum would often return the wrong object, or a large number of objects in the region of the mouse click.

I then implemented what sounded like a much less effective method, but which ended up working out much better. This method relies on assigning every object in the scene a unique colour value, getting the colour value of the pixel that the player has clicked on, and then looking up that colour value to get the id of the object that has been selected. The player never sees the colour values changing, since you don’t call swapbuffers(), sit it is invisible. It is supposed to be quite a slow technique, but it seems to be working well. THIS link provides information on this technique.

I can now easily select unique objects in the scene.

I have now implemented the ability for the player to cycle the text onscreen. Finalising the text rendering took a little more work than I thought, since I had to integrate it into my existing rendering code.

I realised that the main reason for my issues was a slight confusion over the way OpenGL works. Unlike a high-level games engine, OpenGL doesn’t use objects. It is a state machine, which means, instead of doing, for example:

myobject.setrendermode(“wireframe”);

you must first do something like this;

SetModeWireframe

Render Myobject

SetModeNormal

The reason why my text was not appearing properly was simply because I was setting the render mode to wireframe to create an “edged faces” effect  around my shapes, like this:
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );

and I was not turning off wireframe, causing the text to render as an outline. Adding this line after rendering my wireframe fixed this issue:

glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );

I also learned about saving and loading the OpenGL state, which solved a lot of problems I was having with vertex attribute objects not rendering correctly. In OpenGL, is extremely important to reset the state after rendering, by doing something like this:

glBindVertexArray(0);
glDeleteVertexArrays(1, &vao);

I think I have really turned a corner with my knowledge of OpenGL, I have much more of a command of it now. The next step in this project is to enable click-detection, so that the user can select objects in the world.

I have finally finished implementing freetype fonts in this project. This was a long process, and much more complex than I thought.

I found that a lot of the tutorials available online were written for older versions of OpenGL, and would not work correctly with the code that I was using.

One of the problems that I noticed was that the output from the FreeType font is in grayscale format. Loading this into a glTexImage2D(), for texturing onto a quad, resulted in a corrupted image for me. This turned out to be because I had used GL_RGB as the “format” parameter in glTexImage2D. I needed to change this to “GL_LUMINANCE”, so that it now looks like this:

glTexImage2D( GL_TEXTURE_2D,
0,
GL_RGB,
face->glyph->bitmap.width,
face->glyph->bitmap.rows,
0,
GL_LUMINANCE,
GL_UNSIGNED_BYTE,
face->glyph->bitmap.buffer
);

The next goal is to get the text properly integrated into my main rendering loop, and include the ability to change to the previous and next pages using Page up and Page Down.

I have decided to use the FreeType library to render text in the P-155 engine.This seems to be one of the most popular and well supported libraries out there for this purpose.

To get freetype working, I had to download the windows binaries, which were slightly harder to find than the linux source. They are HERE.

Freetype supports truetype (.ttf) fonts, which need to be installed on the machine or located in the programs director in order for freetype to be able to use them.

I am still working on getting text displaying in my project. I have run into a series of issues, most of which I have fixed, but I am still getting no text. I am fairly sure that I am close to a solution, however.

I have finished implementing Object Loading support (with .obj files) to the engine. I have not yet implemented texturing, or any kind of optimisations, but object loading is done.

I have also implemented camera movement. This was relatively simple, but what complicated it a little is that OpenGL is fundamentally different from a ready-made games engine, in the sense that OpenGL only renders to the screen, it does not store objects or information about objects.

What I was trying to do was implement code to move the camera in the world, the same way you would in a high-level games engine. However, I was thinking of the “Camera” as an object in the world, and OpenGL doesn’t have this kind of structure. So, in OpenGL, you actually don’t move the camera, you move the world.

In each render pass, you adjust the position of everything to be rendered with respect to the new transform of the viewer, so, if the player moves 10 units back, instead of moving a camera object 10 units back, you move all of the objects to be rendered 10 units forward. The same is true with rotation. This is essentially the same concept that I came across when solving the 32-bit precision problem with very long view distances.

The next step is to implement text rendering support, since this is obviously a vital feature for any game or project.

I intend to support the .obj file format, and I am currently working on an object loader for this. I have implemented some code that seems to be mostly working, although I haven’t got it completed yet.

I will need to add basic texturing and shading support, in addition to some support functions to translate and rotate the objects.

I will then need to think about animation, and collision detection.

I have successfully created an OpenGL context and installed and linked most of the libraries that I will need for the next part of this project.

As I said, I am using OpenGL for rendering, and GLFW and GLEW for the support libraries. I have also included the glm math library.

My intention is to make a seamless virtual universe, so I had to find some way of representing numerical (decimal) values greater than 64 bits. I thought that this would be easy, but it turns out there are very few libraries that were suitable for my purposes.
The most common seems to be GMP, although this is designed for linux. There are windows versions, MPIR, and MPFR, but these are either GPL or commercial.

Boost also has support for arbitrary precision mathematics, but it is a huge library. It’s something I have always wanted to play around with, and many of it’s other features, such as multithreading and networking, would have also been useful, it it’s just too inefficient to include a library of that size just for a few features, especially in a games engine. In addition, Boost doesn’t seem to have a great reputation for use in games engines, for a number of reasons.

I eventually found ttmath. This is a very small, very clean bignum library for c++. It is very easy to work with, and is free for commercial and non-commercial use (BSD Licence). This makes it perfect for my purposes.

The next step is to begin experimenting with creating objects in a scene with very large view distances.