Due to recent family issues, I couldn’t update the website with new info, but the project is still ongoing.
The code is now hosted on github: https://github.com/IonutCava/Divide-Framework

More info to come when I get a chance.

I originally posted this on jukeforums.co.uk on the 27th of August 2015, but due to some forum changes, the post got messed up so this is my attempt at keeping the info alive.

Hi everyone!

After deciding to go on a holiday back to my hometown of Tulcea, Romania, me and my GF (Geo as in geopopa on the forum), decided to drive there. Since it was going to be a long journey, we decided to visit a few cities on our way, to decide which ones are good candidates for city breaks (e.g. Bratislava) and which are not (sorry Budapest).

Since we were passing through some nice places, I had the “brilliant” idea of taking pictures with the car in every place of interest. Sadly, most of the cities have a very aggressive “no parking near the main attractions”  policy, so we did our best. We thought it might be nice to share our experiences here on the forum.

Anyway, here’s the first part of the journey: Bristol (U.K.) -> Tulcea (RO)

First on our list was Antwerp, Belgium. Beautiful city, but I wasn’t as impressed by the old part of town (after visiting Brussels, Bruges, Ghent, etc) so decided to go in the Old Harbour and see if we can find a nice spot. We didn’t. The best we got were a couple of shots by the Museum aan de Stroom :

Next up, we drove to Munich. As lovely as the city is, the main locations I had in mind for taking pictures were either BMW World and Allianz Arena. BMW World is in a park, so Allianz Arena seemed like a better idea. It wasn’t. Parking anywhere near it was impossible, so this is the best shot I got:

Feeling a bit discouraged and doubting my plan’s chances of success, we got a message from Wilson (Lawrence – very active on the Facebook Group) asking us to visit him in the beautiful Ramsau bei Berchtesgaden. Vienna was our next destination, so we couldn’t refuse a slight detour and loose the chance of driving up the mountains in the Juke. This is what happened next:

Sadly, we had to move on and head over to Vienna. As you can imagine, it’s very crowded, and the best we managed was to snatch a quick picture in the Schwarzenbergplatz:

Moving on to Budapest, we wanted to take a picture in front of the parliament building, but parking was limited. It’s still visible in the back:

We made another overnight stop in Cluj-Napoca, but on the outskirts of town so it didn’t exactly qualify for the album. However, The greatest driving road in the world! did, and the outcome was amazing. As a side-note, this was one of the main reasons we decided to drive back home.First of all, the view is incredible:

(I blurred Geo’s  face so I wouldn’t get in trouble :)) ). She was taking this:

Way up in the clouds (2000m) :

And the road is just silly fun:

The next stop on the list was Bucharest. Although it’s an AMAZING city (just Google “Bucharest” and click on Images), I decided to take a shot with something that the British folk might expect, so I went in front of the biggest P.O.S. in the country, and tried to capture it’s awfulness. Ladies and gentlemen, the “People’s Palace” (heaviest building in the world, second largest, etc):

The damn thing is so large, Geo had to take 3 pictures and stitch them via software. We tried to use the tripod. We failed. We then moved on to Constanta. Geo’s hometown. We stopped in the Old City and stood in front of the former City Hall for the photo. Taking said photo in a parking lot proved a bit difficult, but this is the best we got:

Afterwards, we moved to my hometown, Tulcea, right at the entrance to the Danube Delta:

And that concluded the fist part of the journey. The second bit wasn’t as successful photo-wise, but we did our best. So here’s Tulcea -> Bristol:

First (new) stop, Bratislava. Incredible city, definitely visiting it again:

Prague was also OK, but DON’T PAY IN EUROS OR YOU WILL GET SCAMMED. We payed ~70 euros for a tank of fuel. It was also a city where parking in the centre was difficult, so we stopped near the castle:

The last city on the list (asides from Brussels where we stopped just to buy beer), was Frankfurt am Main. The bad news is that we arrived on a Sunday, so parking anywhere near the centre was next to impossible, so Frankfurt Cathedral will have to do:

We also blew a tyre in the world’s tightest underground parking lot. Since Germany shuts down on Sundays, we spent the night in the small town of Maintal, outside of the city and it is gorgeous and probably has the best ice-cream in the world. We didn’t regret a single second of our 1 day extension to the holiday.

We did kinda regret the 240 euro tyre+labour charge for a single Conti, but on the other hand, I expected  unexpected costs :)).

And that’s about it. A few things to get out of the way:

• The Autobahn is amazing and the Nismo feels right at home:
• Fuel consumption is stuck at 30 mpg on the dashboard, but the classic pen and paper method (well, Fuelly, but still) gave a 31.5 – 32 mpg. With A/C on >50% of the journey. The Autobahn dropped that right down to ~18. I REGRET NOTHING 😀 .
• The seats are really really good. Multiple 8-9 hour driving sessions and nothing ached.
• No mechanical failures, rattling, or unbearable cabin noise.
• Once you go past Belgium, it’s a real head-turner. The number of Jukes on the road drops dramatically. I think I only saw 2 other Nismos in total.
• All of the pictures are available in high-res on my public imgur album.

And that’s about it.

Thank you for your patience! 😀

Ionut and Geo.

Since I started my new job at Gameloft, I had little to no time for posting on the blog/site and doing other social stuff, but development did not stop in any way.
As of this post, AI PathFinding is fully functional and I’ll post a short video and some development logs and description as soon as I get some breathing time (possibly over the weekend).

In the mean time, Facebook is a great place for day-to-day updates.
Twitter is almost as good, but lacks the screenshot and video updates.

[important]TL;DR: Rendering refactored for OGL3.x clean context. Lots of bugs. Takes time. New Revision soon.[/important]

The new revision is getting harder and harder to commit the more I try to clean the code. What cleaning am I talking about? The first part of getting a clean OpenGL 3.x context to work, that cleaning.

So, where to start?

First of all, no more matrix-related stuff. I included glm.hpp, made 3 std::stack<glm::mat4> for model, view and projection, added a caching system for MV,MVP,VP and normal matrices and a matrix upload system for shaders that will be ported to UBOs in the following commits (the code is in place, but isn’t tested enough, so I’m using regular uniforms for now)

[code lang=”cpp”]
///Getting the normal matrix for the current model
void _queryMatrix(const EXTENDED_MATRIX& mode, glm::mat3& mat){
assert(mode == NORMAL_MATRIX /*|| mode == … */);
_clean();
// Normal Matrix
mat = _isUniformScaled ? glm::mat3(_MVCachedMatrix) :
glm::inverseTranspose(glm::mat3(_MVCachedMatrix));
}
[/code]

Next, I needed a clean way of representing geometry and the relationship it has with a certain program,
thus, every batch is contained within a VAO and generated only if a valid shader program was specified. If the specified shader program is not bound or for some other reason, is not valid, the draw command will silently return (well, not in debug).

The new shader + vao + new matrix system led to the implementation of a RenderInstance class that holds an Object3D, it’s transform, a flag for calling the onDraw() method and a flag for 2D rendering. The Object3D contains the geometry and material, the transform holds the model to world matrix that will become active on shader use, the preDraw is for geometry refreshing (changing vertex data or using custom shaders as opposed to the the material ones) and so on and the 2D flag will set an ortho projection for the current instance only. More features will be added as needed for this.

Rendering is thus simplified to this:

[code lang=”cpp”]

void WaterPlane::render(SceneGraphNode* const sgn){
GFX_DEVICE.renderInstance(_plane->renderInstance());
}

…

void Object3D::render(SceneGraphNode* const sgn){
if(!GFX_DEVICE.excludeFromStateChange(SceneNode::getType())){
_renderInstance->transform(sgn->getTransform());
}
GFX_DEVICE.renderInstance(_renderInstance);
}

[/code]

No more manual binding of VBOs or specifying ARRAY_BUFFER bindings by hand or rendering with a different shader than the one the VAO was created with (unless needed and attributes match – e.g. depthPass*.glsl and lighting*.glsl are interchangeable as far as the object is concerned). This also led to avoiding the rebind of the same VAO and shader programs.

Another cool feature was the usage of GLEW_MX and GLFW3 to allow the creation of a separate GL context in a background thread used for both texture loading and uploading to GPU and shader compiling (shaders are still read from file in the main thread to make use of GLSW’s nice caching features for already opened files). Reading small files isn’t a problem for shaders, but linking will no longer cause small lockups in rendering. All loading requests are serialized in a FIFO queue in the loader thread and glFlush is called after each load command is executed (load commands are the entire loading methods, not line by line commands.) The ResourceDecriptor was modified to allow bypassing this mechanism and loading elements in the main thread if needed:

[code lang=”cpp”]

///The threadedLoad() method generates the texture, reads data from file, creates mipmaps, sets params etc
bool glTexture::generateHWResource(const std::string& name) {
GFX_DEVICE.loadInContext(_threadedLoading ? GFX_LOADING_CONTEXT : GFX_RENDERING_CONTEXT,
DELEGATE_BIND(&glTexture::threadedLoad, this, name));
return true;
}
…
///_loadQueue is a boost::lockfree::spsc_queue
void GL_API::loadInContextInternal(){
glfwMakeContextCurrent(Divide::GL::_loaderWindow);
#ifdef GLEW_MX
Divide::GL::initGlew();
#endif
while(!_closeLoadingThread){
if(_loadQueue.empty()){
boost::this_thread::sleep(boost::posix_time::milliseconds(5));//<Avoid burning the CPU – Ionut
continue;
}
boost::function0<GLvoid> callback;
while(_loadQueue.pop(callback)){
callback();
glFlush();
}
}
glfwMakeContextCurrent(NULL);
}
[/code]

CEGUI was updated to 0.8.2 and FTGL was modified to allow a clean OGL3.x context.
CEGUI,FTGL and GLIM were modified to allow the usage of GLEW_MX, and FTGL was modified to allow configurable vertex position attribute location.

Another big change is the drop of Visual Studio 2008 support to improve productivity. Along with this, Divide-Sever and Divide-Networking projects were deleted from SVN and moved inside Divide Framework. Also, all of the ReCast files are moved to a separate project. The new layout is as follows:

New solution layout

After pushing a few revisions to the trunk since I got to the UK, I really started working on my dissertation project. But one thing led to another and now, updating the SVN will be postponed for a few more days. Revision 149 also presented a small bug that causes performance to slow down to a crawl after a while. The fix is simple. Cut the double bind check as it was horrid and I was exhausted when I wrote it. I’ll add a better version later.

Change some things in FrameBufferObject.cpp (Hardware/Video/Buffers/FrameBufferObject)

[code lang=”cpp”]

void FrameBufferObject::Bind(U8 unit, U8 texture){

……

}

[/code]

to

[code lang=”cpp”]
void FrameBufferObject::Bind(U8 unit, U8 texture){
return;
}

[/code]

and

[code lang=”cpp”]
void FrameBufferObject::Unbind(U8 unit) {
……
_fixedPipeline = false;
}
[/code]

to

[code lang=”cpp”]
void FrameBufferObject::Unbind(U8 unit) {
_fixedPipeline = false;
}
[/code]

Another issue is with terrain rendering. To get 10x better performance, just change the “chunkSize” in TerrainLoader.cpp (Environment/Terrain) when building the Quadtree. 256 will give 40+FPS in Debug if the baseline was 4-5 (like my laptop).

[code lang=”cpp”]
U32 chunkSize = 256;//&lt;Was 16. 128 is also ok. This will be edited in XML descriptors
_terrainQuadtree->setParentShaderProgram(…);
_terrainQuadtree->Build(….);
[/code]

Also, experimental code that would allow VAO’s to send less data to the GPU during depth rendering (shadows, ssao, dof, etc) is added but will probably be disabled in the next revision.

The dissertation part includes the complete integration of the ReCast library and PhysX for each scene. Both are complete, but data passing between SceneGraph <-> ReCast and SceneGraph <-> PhysX isn’t yet complete.

Another big point in the next update will be the proper usage of a ThreadPool and the change made to the Event class (now called Task) that allows better and safer multithreading.

TL;DR: Big updates, testing takes time.