[ODFAEG] (Open Source Development Framework Adapted for Every Game)

[eXpl0it3r]

I disagree a little bit on the "There is no clear definition of 3D game".. At least in my opinion, a game which uses 3D assets to represent most of its world its a 3D game, but more importantly, a game who projects its geometry into perspective is even more a 3D game. That's the crucial part I guess.

Well then you didn't fully get my argument. Relying only on "3D assets" doesn't work, because of games like Myth, that use pre-rendered scenes and thus no 3D assets in the end. Or if you mean 3D assets in development, then most of the modern 2D games are 3D games as well, because many sprites you see, will be rendered from 3D models.
If you'd want to go with "projects its geometry into perspective" you'd still have problems with games that give you the illusion of 3D, while not having much to do with 3D (e.g. most isometric games, including Age of Empires II).

On the other hand I should've made it clear, that games using 3D assets are of course 3D games.

Then again 2D is a subset of 3D, so all 2D games are essentially also 3D games, just without making use of one dimension, j/k.

[Grimshaw]

I see what you mean, but I meant displaying 3D geometry on runtime in particular, as pre rendered graphics are still sprites for all means.

And when I talked about projection, I was referring directly to projection matrices and their use in the ingame cameras. A 2.5D game as they call it, that looks 3D but really isn't, is usually a orthogonal projection with sprites for geometry, while other games actually "fake" that same look but use actual 3D projection matrices with 3D geometry.

In sum, what I am trying to say is that it doesn't matter what it looks to the consumer. What matters is what math is being performed internally and how the geometry is represented

PS: http://imgur.com/7eacZ3T,vIwX44M,V4gsvky,rVe3kg9 as you can see, I rendered LoL models and map, and they were full 3D, the only difference to the actual LoL client is the fixed camera angle in it.

[eXpl0it3r]

True, one has to differentiate between "technical perspective" and "experienced perspective".
The "experience" is personal thus one can argue forever, while the "technical" can be determined rather easily, even though one might find some 3D math tricks within 2D math calculations.

Anyways I'll leave it at that, it has polluted the topic enough already (if only I were I mod, I could move the stuff...).

On Topic
It's "Development" not "Developement" - there's an 'e' too much.

[Lolilolight]

New update :

-Action and signal improvements :

-We can know create combined actions in a easier way with the logical operators.
-I reduced the template arguments. (To create signals)

It should cloturate the first version, the next updates'll be most of all bug corrections/optimisations.
I've to clean the code also and generate documentation and exemples.

[Lolilolight]

I've created a devblog, then, I'll avoid to post in this forum for small updates. (But you can visit my devblog if you want to have more news about this project.)

I'll post only to annonce the launch of the releases or answer to the questions.

The first release'll be released soon I've just to generate documentation with doxygen, configuring the library to provide a shared verson of the library, and, finishing the tutorials. (In french and next in English)

PS : see the first post to find the link of my devblog. (I've updated it)

[G.]

Welcome to my devblog! I’m Laurent Duroisin,  one of the most experienced c++ developper in the world

Awesome.

[Lolilolight]

The version RC has just been released. (it's the version without the tutorials and documentations)
See on my git-hub repository for the source code.
I've still to configure the library for the shared build, and make the documentation before the launch of the first release!

The library contains now :

-An entity system. (Scene nodes, animations, a grid for entity storage, updaters and the world who conains everything.)
-A lighting system.
-A listener system. (For the events  and actions, you can even make and connect your own triggers!)
-Some classes to manage collision detection with 2D bounding areas.
And a states system to store and restaure states without reload everything.
-A lightweight resource management system.

The next version'll come  very soon, it'll implement these new functionnalities :

-Safe Networking.
-Movement prediction.
-A particule system.

I've already test the 2 first points, I've just to re-order the code and put it into the framework.
Thus, just the last point (the particule system) remains but to do it faster, I'll take a look at the particule system of the thor library.

I've implemented my own tuple system but I don't recommend to use it, it was just for learning purpose. (Maybe I'll improve it later when I'll have better knoledges about the D language)

PS : Creating some guis looks like buttons shoud be nice if someone is interessed.

[eXpl0it3r]

In case anyone else is wondering: https://github.com/Lolilolight/ODFAEG

Manually managed C arrays of pointer of manually managed states. I mean if it was a C library we could talk about it again, but this... nope - but as we all know, you don't like RAII.

[Lolilolight]

In case anyone else is wondering: https://github.com/Lolilolight/ODFAEG

Manually managed C arrays of pointer of manually managed states. I mean if it was a C library we could talk about it again, but this... nope - but as we all know, you don't like RAII.

It isn't the fact that I don't like RAII, but smart_pointers are not pointers, so you can't pass them to a pointer to a function... (And they are not copiable too, they only encapsulate a pointer who's destroyed when the object is destroyed, this is RAII)

References are also causing a lot of problems when we want to store them into a container to pass them to a function pointer. (So I can't pass smart pointers)
But anyway I use std::vectors of pointers and std::array, and, they use RAII it seems. (No ?)

So, I've no problems with the memory management.

Thus it joins what I've said on another topic, every classes should have a class with a destructor. (And essentially containers like std::vectors who can store anything)
And should use the move semantic to pass adresses to function pointers. (Instead of the RAII mecanism)

Here, I use the std::vectors because I don't have to pass them to a function pointer but..., in other case..., it's very paintfull with RAII.
I tried to use a std::reference_wrapper to pass smart pointers to function pointers but it didn't worked, and if I pass a pointer I've to delete them manually...

PS : It would be nice if the std::vectors can also have a forward_as_vector function like std::tuples who are very helpfull.
So I prefer to use the move semantic who's less paintfull. (To move the pointers from my first list, to the pointers to my second list)

[Grimshaw]

Why can't you pass a reference to a smart pointer to a function, so it doesn't get copied?

[Lolilolight]

Because it's too paintfull to store reference into a container :

I'll show you a source code exemple later.

But I had to use something like this :

std::map<std::string, ResourceManager<void*>&>

I don't know if it's very well but I want to avoid copy. (I've objects who are non copiable)

[Lolilolight]

I know how I'll do that, I'll create a class like boost any and delete the pointer in the destructor.

It should do the trick.

I've just to know how to pass reference arguments in a function template, to store them in a tuple.

I've to do some tests and check information about that for the next realease...., but if someone knows it'll really help me.
I've to do some test with the tuple too, to try to use a typed bind class with a placeholder system. (With type erasure)
I've found the insterter to insert elements into a tuple but I don't know really how it works.
 

[zsbzsb]

I know how I'll do that, I'll create a class like boost any and delete the pointer in the destructor.

And you just described those hated smart pointers which are already there for you to use.............................

[Lolilolight]

Yeah smart pointers are made for that, but, I prefer the move semantic, you don't even need an object to encapsulate the pointer.

With the forward_as_tuple method, I even don't need to use smart pointers, and I can pass references and const references without any problem. (With tempaltes)

Anyway I prefer use my proper class to manage that, than the smart pointers.
Because smart pointers don't offers us the type erasement.
So I'll use a base class for my resource manager class I think, rather than a smart pointer with a pointer to void.

The same technique that I've used to store triggers,signals and actions into the listener.

I think it's really better.

And I'll use the move semantic for the template.

[Lolilolight]

Hi!

I've found a solution for the storage of multiple resources types with multiple identifiers, it'll be updated in the next realease.

I simply use the type erasure.

I've also added a wait method in the listener, because I had assynchroneous problems.

And I've fixed a deadline for the launch of the first release, so the first realease should goes out on the first March! (Just the time for me to finish the documentations and tutorials)