Groogy's Game Engine

[Groogy]

By the way, why don't you use a proper smart pointer instead of that ugly SAFE_DELETE?

Because I don't want a smart pointer
I use reference counting where reference counting is needed. For example I reference count resources, not singletons. I reference count... well that is about it

Everything else is RAII based.

NOTE: Even my resources is half loosed on reference counting. They are not removed if they hit 0 references. They are removed only if the memory is needed.

[Nexus]

I use reference counting where reference counting is needed. For example I reference count resources, not singletons. I reference count... well that is about it

I didn't mean you should use a reference counted smart pointer. But something like std::auto_ptr, boost::scoped_ptr or std::unique_ptr. Everything is better than such an unsafe and ugly macro, even plain delete.

Everything else is RAII based.

Well, I see no reason why you can't use RAII here. Manually initializing and destroying something before/after it is used is quite annoying and reminds me of C libraries

[Groogy]

I use reference counting where reference counting is needed. For example I reference count resources, not singletons. I reference count... well that is about it

I didn't mean you should use a reference counted smart pointer. But something like std::auto_ptr, boost::scoped_ptr or std::unique_ptr. Everything is better than such an unsafe and ugly macro, even plain delete.

How would you do it then? The pointer exists in a global scope because of it being static. So no matter what smart pointer class I use, that object will never be destroyed. If I manually destroy the smart pointer then I'm back to square one but with an even uglier indirection.

I want there to be a Create and Release functionality as it's defined in the actual pattern. Though you are not forced to call Create as it will be called trough the Instance() function(just saw I forgot to add that).

[Nexus]

Can't you use the Meyers singleton? Then you don't even need dynamic memory.

Code: [Select]

template <typename T>
class Singleton
{
public:
static Singleton& Instance()
{
static Singleton instance;
return instance;
}

private:
...
};
If you absolutely do need a Release() function, you can do it like this, but of course the code becomes slightly more complicated:

Code: [Select]

#include <memory>

template <typename T>
class Singleton
{
public:
static Singleton& Instance()
{
if (!instance.get())
instance.reset(new Singleton);
return *instance;
}

static void Release()
{
instance.reset();
}

private:
// auto_ptr needs access to our destructor
template <typename T>
friend class std::auto_ptr;

static std::auto_ptr<Singleton> instance;

...
};

[Groogy]

Hmm I could provide both Meyers and a normal one. These are just design patterns that are provided together with the library.

NOTE: There must be a Create function on the normal so that you can control the allocation in a nice way. Calling Instance() just to allocate the singleton is not very informative.

And of course I do not necessarily NEED the functions but I am just implementing the design pattern for use by others. So someone might expect a Create-Release function pair but if it then don't exist he will get grumpy on me, and then we have someone else that complains on that there is a Create-Release function pair and he get's grumpy. The difference is that the one that don't want the pair I can just tell him to ignore them as they are not needed to actually use the class.

For the actual application in GGE I would only use the normal singleton for one class and the rest would work perfectly(maybe even optimal) with Meyers Singleton.

[danman]

I've used a singleton derived pattern for me (that support polymorphism i think, not tried), because i need a perfect control on what i singlelise :

Code: [Select]



Obj singleton;
SharedInstance(singleton);

SharedInstance<Obj>()->DoThat();

Obj singletwo;
SharedInstance(singletwo);
...



I agree with Groogy. although it's a C-like behavior, you need external memory management, because devs could need it and could be stopped by this leak.

But i don't manage it itself, I prefer let the user destroy it, or use a GTK-like Garbage, but with more semantics :

Code: [Select]


template<typename T>
class Garbage
{
public:
    virtual ~Garbage();
    T& Manage(T*); // I use reference, because the other code use reference, not a Qt like system
private:
    std::vector<T*> m_Objects;
};

class GuiHandle : public Garbage<Widget> // GuiHandle can manage memory destruction for widgets object
{

};


I hope you understand me  :oops:

[Groogy]

Understood you perfectly danman. Unfortunately this is a subject there is a grey zone of right.

Anyway as I am reaching my own set deadline I am about to write some documentation and tutorials for use of the engine. Since the engine will eventually contain tools for like skeletal animations, shader/model previewers and so on it would be nice to have video tutorials too.

So am just asking if anyone got a screen capture application to recommend?

[Cuban-Pete]

camstudio works decent.

[Groogy]

Thanks Pete, now I need a video editing tool to put the different clips together.

[Groogy]

Introduction tutorial is up on youtube now ^^


Sorry though for my English.

[Ceylo]

I love your soft and sexy voice *gets out*.

Actually your English is quite better than mine.. and really easy to understand thus you shouldn't worry.

[Groogy]

The thing that worries me are all the "Örhm" because I hesitate to think about what I am about to say... and that's even with me practising several times before XD

I actually like doing this. Was quite fun to "vlog" or whatever it's called ^^

Anyway the next tutorial will be up tonight with me showing how to implement the "hello world" application.

Anyway thanks Ceylo for the remark on my voice  :wink: *kisses*

[MorleyDev]

If you have trouble coming up with names for a project, my tactic is to just keep clicking random on wikipedia until something catches my eye ^^ My latest project is called "Zander" xD

I've found rather easy to create a singleton pattern which decides at compile-time whether it is gamma or meyers, or something the user defines.

Anyway looks interesting ^^

[Groogy]

The new tutorial is out where we actually do something with the engine:



It became pretty long so had to divide it into two parts.

[Ceylo]

Aaah aaah aaaaaah got a kiss from the guy-with-a-sexy-voice *faints*.

Apart from that, I think you should increase the sound's volume because we can't hear you without setting the volume close to maximum.

As for the "erm" thing, maybe you should write down what you want to say so that you do no more hesitate?