#pragma once

#ifndef TGLDISPLAYLISTSMANAGER_H

#define TGLDISPLAYLISTSMANAGER_H

// TnzCore includes

#include "tgl.h"

// tcg includes

#include "tcg/tcg_observer_notifier.h"

// Qt includes

#include <qmutex></qmutex>

#undef DVAPI

#undef DVVAR

#ifdef TGL_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

//**************************************************************************************************

//    TGLDisplayListsProxy  declaration

//**************************************************************************************************

//! TGLDisplayListsProxy is a wrapper to a dummy OpenGL context attached to a

//! specific display lists space.

/*!

  TGLDisplayListsProxy implements the basic functionalities necessary to address

a display lists

  space without having to access any actual associated OpenGL context. This is

equivalent to

  making a hidden OpenGL context (the display lists proxy) the \a current one.

\note Implementations of the TGLDisplayListsProxy must take ownership of the

proxy.

*/

class TGLDisplayListsProxy {

  QMutex m_mutex;

public:

  virtual ~TGLDisplayListsProxy() {}

  virtual void makeCurrent() = 0;

  virtual void doneCurrent() = 0;

  QMutex *mutex() { return &m_mutex; }

};

//**************************************************************************************************

//    TGLDisplayListsProxy  template specializations

//**************************************************************************************************

template <typename context=""></typename>

class TGLDisplayListsProxyT : public TGLDisplayListsProxy {

  Context *m_proxy;

public:

  TGLDisplayListsProxyT(Context *proxy) : m_proxy(proxy) {}

  ~TGLDisplayListsProxyT() { delete m_proxy; }

  void makeCurrent() { m_proxy->makeCurrent(); }

  void doneCurrent() { m_proxy->doneCurrent(); }

};

//**************************************************************************************************

//    TGLDisplayListsManager  declaration

//**************************************************************************************************

//! TGLDisplayListsManager is a singleton class used to track OpenGL shared

//! display lists spaces.

/*!

  OpenGL contexts can share their display lists space (in particular, this

includes texture

  objects) with other contexts. Typically, sharing specification happens when a

new context

  is created - at that point, the new context is allowed to share the lists

space of another

  known context, pretty much the same way a shared smart pointer does.

\n\n

  However, OpenGL provides access to the display lists space \a only through

their attached

  OpenGL contexts; meaning that an external object has to know at least one

associated context

  to operate on a display lists space.

\n\n

  We'll call such an associated context  a \a proxy of the display lists space.

It is a dummy

  OpenGL context that shares the display lists spaces with those that are

attached to it.

\n\n

  Observe that the use of one such dummy context, rather than one of the

originally

  attached ones, is strictly necessary in a multithreaded environment, since 

an OpenGL

  context can be active in exactly one thread at a given time <\I> - and any of

the attached

  contexts could always be current in another thread.

\n\n

  However, the use of a single proxy per display lists space means that multiple

threads

  could try to access it at the same time. Synchronization in this case must be

handled by

  the user by accessing the proxy's built-in mutex.

  \warning TGLDisplayListsManager relies on the user to attach a context to the

\b correct

           display lists id.

*/

class DVAPI TGLDisplayListsManager : public tcg::notifier<> {

public:

  struct Observer : public tcg::observer<tgldisplaylistsmanager> {</tgldisplaylistsmanager>

    virtual void onDisplayListDestroyed(int dlSpaceId) = 0;

  };

public:

  static TGLDisplayListsManager *instance();

  int storeProxy(TGLDisplayListsProxy *proxy);  //!< Stores the specified proxy,

                                                //!returning its associated

                                                //!display

  //!< lists id. Context attaches should follow.

  void attachContext(int dlSpaceId, TGlContext context);  //!< Attaches the

                                                          //!specified context

                                                          //!to a display lists

                                                          //!space

  void releaseContext(TGlContext context);  //!< Releases a context reference to

                                            //!its display lists space

  int displayListsSpaceId(TGlContext context);  //!< Returns the display lists

                                                //!space id of a known context,

                                                //!or

  //!< -1 if it did not attach to any known space.

  TGLDisplayListsProxy *dlProxy(int dlSpaceId);  //!< Returns the display lists

                                                 //!space proxy associated to

                                                 //!the

                                                 //!< specified id.

};

#endif  // TGLDISPLAYLISTSMANAGER_H