- always renders into the backbuffer and blits it to window (no single buffered rendering)

			- no native Windows or Mac OS X pixmap support

			- no power management events

			- no support for swap interval

#include "riMath.h"

//==============================================================================================

void* OSGetCurrentThreadID(void);

void OSAcquireMutex(void);

void OSReleaseMutex(void);

void OSDeinitMutex(void);

EGLDisplay OSGetDisplay(EGLNativeDisplayType display_id);

void* OSCreateWindowContext(EGLNativeWindowType window);

void OSDestroyWindowContext(void* context);

bool OSIsWindow(const void* context);

void OSGetWindowSize(const void* context, int& width, int& height);

void OSBlitToWindow(void* context, const Drawable* drawable);

EGLBoolean OSGetNativePixmapInfo(NativePixmapType pixmap, int* width, int* height, int* stride, VGImageFormat* format, int** data);

/*-------------------------------------------------------------------*//*!

* \brief	

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

class RIEGLContext

{

public:

	RIEGLContext(OpenVGRI::VGContext* vgctx, const EGLConfig config);

	~RIEGLContext();

	void	addReference()				{ m_referenceCount++; }

	int		removeReference()			{ m_referenceCount--; RI_ASSERT(m_referenceCount >= 0); return m_referenceCount; }

    VGContext*      getVGContext() const      { return m_vgContext; }

    EGLConfig getConfig() const         { return m_config; }

private:

	RIEGLContext(const RIEGLContext&);

	RIEGLContext& operator=(const RIEGLContext&);

	VGContext*		m_vgContext;

	const EGLConfig	m_config;

	int				m_referenceCount;

};

RIEGLContext* CastToRIEGLContext(EGLContext aCtxId);

EGLContext CastFromRIEGLContext(RIEGLContext* aCtx);

	m_vgContext(vgctx),

	m_config(config),

	m_referenceCount(0)

{

}

{

}

* \brief	

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

class RIEGLSurface

{

public:

    RIEGLSurface(void* OSWindowContext, const EGLConfig config, Drawable* drawable, bool largestPbuffer, int renderBuffer);

	~RIEGLSurface();

	void	addReference()				{ m_referenceCount++; }

	int		removeReference()			{ m_referenceCount--; RI_ASSERT(m_referenceCount >= 0); return m_referenceCount; }

    void*           getOSWindowContext() const { return m_OSWindowContext; }

    EGLConfig       getConfig() const          { return m_config; }

    Drawable*       getDrawable() const        { return m_drawable; }

    bool            isLargestPbuffer() const   { return m_largestPbuffer; }

    int             getRenderBuffer() const    { return m_renderBuffer; }

private:

	RIEGLSurface(const RIEGLSurface&);

	RIEGLSurface& operator=(const RIEGLSurface&);

    void*            m_OSWindowContext;

	const EGLConfig	 m_config;

	Drawable*        m_drawable;

	bool			 m_largestPbuffer;

	int				 m_renderBuffer;		//EGL_BACK_BUFFER or EGL_SINGLE_BUFFER

	int				 m_referenceCount;

};

RIEGLSurface* CastToRIEGLSurface(EGLSurface aSurfaceId);

EGLSurface CastFromRIEGLSurface(RIEGLSurface* aSurface);

RIEGLSurface::RIEGLSurface(void* OSWindowContext, const EGLConfig config, Drawable* drawable, bool largestPbuffer, int renderBuffer) :

    m_OSWindowContext(OSWindowContext),

	m_config(config),

	m_drawable(drawable),

	m_largestPbuffer(largestPbuffer),

	m_renderBuffer(renderBuffer),

	m_referenceCount(0)

{

    RI_ASSERT(m_renderBuffer == EGL_BACK_BUFFER);   //only back buffer rendering is supported

    m_drawable->addReference();

}

{

    OSDestroyWindowContext(m_OSWindowContext);

	if(m_drawable)

	{

		if(!m_drawable->removeReference())

}

	m_id(id),

	m_contexts(),

	m_surfaces()

{

	m_configs[0].set(8, 8, 8, 8, 0, 32, 1, 8, 1);	//EGL_RGB_BUFFER, buffer size = 32

	m_configs[1].set(8, 8, 8, 0, 0, 32, 1, 8, 2);	//EGL_RGB_BUFFER, buffer size = 24

	m_configs[2].set(5, 5, 5, 1, 0, 16, 1, 4, 3);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[3].set(5, 6, 5, 0, 0, 16, 1, 4, 4);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[4].set(4, 4, 4, 4, 0, 16, 1, 4, 5);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[5].set(0, 0, 0, 8, 0, 8,  1, 8, 6);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[6].set(0, 0, 0, 4, 0, 4,  1, 4, 7);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[7].set(0, 0, 0, 1, 0, 1,  1, 1, 8);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[8].set(0, 0, 0, 0, 8, 8,  1, 8, 9);	//EGL_LUMINANCE_BUFFER, buffer size = 8

	m_configs[9].set(0, 0, 0, 0, 1, 1,  1, 1, 10);	//EGL_LUMINANCE_BUFFER, buffer size = 1

	m_configs[10].set(8, 8, 8, 8, 0, 32, 4, 1, 11);	//EGL_RGB_BUFFER, buffer size = 32

	m_configs[11].set(8, 8, 8, 0, 0, 32, 4, 1, 12);	//EGL_RGB_BUFFER, buffer size = 24

	m_configs[12].set(5, 5, 5, 1, 0, 16, 4, 1, 13);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[13].set(5, 6, 5, 0, 0, 16, 4, 1, 14);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[14].set(4, 4, 4, 4, 0, 16, 4, 1, 15);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[15].set(0, 0, 0, 8, 0, 8,  4, 1, 16);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[16].set(0, 0, 0, 4, 0, 4,  4, 1, 17);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[17].set(0, 0, 0, 1, 0, 1,  4, 1, 18);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[18].set(0, 0, 0, 0, 8, 8,  4, 1, 19);	//EGL_LUMINANCE_BUFFER, buffer size = 8

	m_configs[19].set(0, 0, 0, 0, 1, 1,  4, 1, 20);	//EGL_LUMINANCE_BUFFER, buffer size = 1

	m_configs[20].set(8, 8, 8, 8, 0, 32, 32, 1, 21);	//EGL_RGB_BUFFER, buffer size = 32

	m_configs[21].set(8, 8, 8, 0, 0, 32, 32, 1, 22);	//EGL_RGB_BUFFER, buffer size = 24

	m_configs[22].set(5, 5, 5, 1, 0, 16, 32, 1, 23);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[23].set(5, 6, 5, 0, 0, 16, 32, 1, 24);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[24].set(4, 4, 4, 4, 0, 16, 32, 1, 25);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[25].set(0, 0, 0, 8, 0, 8,  32, 1, 26);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[26].set(0, 0, 0, 4, 0, 4,  32, 1, 27);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[27].set(0, 0, 0, 1, 0, 1,  32, 1, 28);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[28].set(0, 0, 0, 0, 8, 8,  32, 1, 29);	//EGL_LUMINANCE_BUFFER, buffer size = 8

	m_configs[29].set(0, 0, 0, 0, 1, 1,  32, 1, 30);	//EGL_LUMINANCE_BUFFER, buffer size = 1

    //configs without mask

	m_configs[30].set(8, 8, 8, 8, 0, 32, 1, 0, 31);	//EGL_RGB_BUFFER, buffer size = 32

	m_configs[31].set(8, 8, 8, 0, 0, 32, 1, 0, 32);	//EGL_RGB_BUFFER, buffer size = 24

	m_configs[32].set(5, 5, 5, 1, 0, 16, 1, 0, 33);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[33].set(5, 6, 5, 0, 0, 16, 1, 0, 34);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[34].set(4, 4, 4, 4, 0, 16, 1, 0, 35);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[35].set(0, 0, 0, 8, 0, 8,  1, 0, 36);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[36].set(0, 0, 0, 4, 0, 4,  1, 0, 37);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[37].set(0, 0, 0, 1, 0, 1,  1, 0, 38);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[38].set(0, 0, 0, 0, 8, 8,  1, 0, 39);	//EGL_LUMINANCE_BUFFER, buffer size = 8

	m_configs[39].set(0, 0, 0, 0, 1, 1,  1, 0, 40);	//EGL_LUMINANCE_BUFFER, buffer size = 1

	m_configs[40].set(8, 8, 8, 8, 0, 32, 4, 0, 41);	//EGL_RGB_BUFFER, buffer size = 32

	m_configs[41].set(8, 8, 8, 0, 0, 32, 4, 0, 42);	//EGL_RGB_BUFFER, buffer size = 24

	m_configs[42].set(5, 5, 5, 1, 0, 16, 4, 0, 43);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[43].set(5, 6, 5, 0, 0, 16, 4, 0, 44);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[44].set(4, 4, 4, 4, 0, 16, 4, 0, 45);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[45].set(0, 0, 0, 8, 0, 8,  4, 0, 46);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[46].set(0, 0, 0, 4, 0, 4,  4, 0, 47);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[47].set(0, 0, 0, 1, 0, 1,  4, 0, 48);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[48].set(0, 0, 0, 0, 8, 8,  4, 0, 49);	//EGL_LUMINANCE_BUFFER, buffer size = 8

	m_configs[49].set(0, 0, 0, 0, 1, 1,  4, 0, 50);	//EGL_LUMINANCE_BUFFER, buffer size = 1

	m_configs[50].set(8, 8, 8, 8, 0, 32, 32, 0, 51);	//EGL_RGB_BUFFER, buffer size = 32

	m_configs[51].set(8, 8, 8, 0, 0, 32, 32, 0, 52);	//EGL_RGB_BUFFER, buffer size = 24

	m_configs[52].set(5, 5, 5, 1, 0, 16, 32, 0, 53);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[53].set(5, 6, 5, 0, 0, 16, 32, 0, 54);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[54].set(4, 4, 4, 4, 0, 16, 32, 0, 55);	//EGL_RGB_BUFFER, buffer size = 16

	m_configs[55].set(0, 0, 0, 8, 0, 8,  32, 0, 56);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[56].set(0, 0, 0, 4, 0, 4,  32, 0, 57);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[57].set(0, 0, 0, 1, 0, 1,  32, 0, 58);	//EGL_RGB_BUFFER, buffer size = 8

	m_configs[58].set(0, 0, 0, 0, 8, 8,  32, 0, 59);	//EGL_LUMINANCE_BUFFER, buffer size = 8

	m_configs[59].set(0, 0, 0, 0, 1, 1,  32, 0, 60);	//EGL_LUMINANCE_BUFFER, buffer size = 1

/*

attrib                default        criteria order   priority

--------------------------------------------------------------

EGL_COLOR_BUFFER_TYPE EGL_RGB_BUFFER Exact    None    2 

EGL_RED_SIZE          0              AtLeast  Special 3 

EGL_GREEN_SIZE        0              AtLeast  Special 3 

EGL_BLUE_SIZE         0              AtLeast  Special 3 

EGL_LUMINANCE_SIZE    0              AtLeast  Special 3 

EGL_ALPHA_SIZE        0              AtLeast  Special 3 

EGL_BUFFER_SIZE       0              AtLeast  Smaller 4 

EGL_CONFIG_ID         EGL_DONT_CARE  Exact    Smaller 11

*/

}

{

	for(int i=0;i<m_contexts.size();i++)

	{

		if(!m_contexts[i]->removeReference())

	}

	m_contexts.clear();	//remove all contexts from the list (makes further references to the current contexts invalid)

	for(int i=0;i<m_surfaces.size();i++)

	{

		if(!m_surfaces[i]->removeReference())

	m_surfaces.clear();	//remove all surfaces from the list (makes further references to the current surfaces invalid)

}

{

	for(int i=0;i<m_contexts.size();i++)

		if(m_contexts[i] == CastToRIEGLContext(ctx))

	}

}

{

	for(int i=0;i<m_surfaces.size();i++)

		if(m_surfaces[i] == CastToRIEGLSurface(surf))

	}

}

{

    for(int i=0;i<EGL_NUMCONFIGS;i++)

    {

        if(m_configs[i].m_config == config)

		return EGL_TRUE;

    }

}

/*-------------------------------------------------------------------*//*!

* \brief	

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

class RIEGLThread

{

public:

	RIEGLThread(void* currentThreadID);

	~RIEGLThread();

    void*           getThreadID() const       { return m_threadID; }

    void            makeCurrent(RIEGLContext* c, RIEGLSurface* s)       { m_context = c; m_surface = s; }

	RIEGLContext*	getCurrentContext() const   { return m_context; }

	RIEGLSurface*	getCurrentSurface() const   { return m_surface; }

    void            setError(EGLint error)      { m_error = error; }

    EGLint          getError() const            { return m_error; }

    void            bindAPI(EGLint api)         { m_boundAPI = api; }

    EGLint          getBoundAPI() const         { return m_boundAPI; }

private:

	RIEGLThread(const RIEGLThread&);

	RIEGLThread operator=(const RIEGLThread&);

	RIEGLContext*		m_context;

	RIEGLSurface*		m_surface;

	EGLint              m_error;

	void*               m_threadID;

	EGLint              m_boundAPI;

};

	m_context(NULL),

	m_surface(NULL),

	m_error(EGL_SUCCESS),

	m_threadID(currentThreadID),

	m_boundAPI(EGL_NONE)

{

}

{

}

Image* CastToImage(EGLClientBuffer aBufferId);

EGLClientBuffer CastFromImage(Image* aBUffer);

	m_threads(),

	m_currentThreads(),

	m_displays(),

	m_referenceCount(0)

{

}

{

	for(int i=0;i<m_displays.size();i++)

	}

	for(int i=0;i<m_threads.size();i++)

	{

	}

}

* \brief	

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

{

	{

		try

		{

			g_egl = RI_NEW(EGL, ());				//throws bad_alloc

			g_egl->addReference();

		}

		catch(std::bad_alloc)

		{

			g_egl = NULL;

		}

	}

	return g_egl;

	*/

		return es->getEgl();

}

{

/*

	if(g_egl)

		if(!g_egl->removeReference())

		{

			RI_DELETE(g_egl);

			g_egl = NULL;

		}

	}

	*/

	EGL* pEgl = static_cast<EGL*>(Dll::Tls());

		delete pEgl; 

}

* \brief	Given a display ID, return the corresponding object, or NULL

*			if the ID hasn't been initialized.

* \param	

* \return	

* \note		if egl has been initialized for this display, the display ID can

*			be found from egl->m_displays

*//*-------------------------------------------------------------------*/

{

	for(int i=0;i<m_displays.size();i++)

		if(displayID == m_displays[i]->getID())

	return NULL;		//error: the display hasn't been eglInitialized

}

* \brief	return EGLDisplay for the current context

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

{

	for(int i=0;i<m_displays.size();i++)

        if(m_displays[i]->contextExists(ctx))

            return m_displays[i]->getID();

    return EGL_NO_DISPLAY;

}

* \brief	return an EGL thread struct for the thread made current, or

*            NULL if there's no current context.

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/