--- /dev/null
+/*
+ * Elementary EGL/OpenGL-ES helper macros and functions
+ *
+ * Author: Jean-Philippe ANDRE <jpeg@videolan.org>
+ */
+
+#ifndef _ELEMENTARY_GL_HELPERS_H
+#define _ELEMENTARY_GL_HELPERS_H
+
+#include <Elementary.h>
+#include <Evas_GL_GLES1_Helpers.h>
+#include <Evas_GL_GLES2_Helpers.h>
+#include <Evas_GL_GLES3_Helpers.h>
+
+/**
+ * @defgroup Elementary_GL_Helpers Elementary GL Helper functions
+ * @ingroup Elm_GLView
+ *
+ * @{
+ */
+
+/**
+ * @file Elementary_GL_Helpers.h
+ * @brief Convenience functions and definitions to use OpenGL with EFL.
+ *
+ * Applications can combine OpenGL and Elementary using the @ref Elm_GLView widget.
+ * Because of the design and specific features of EFL's OpenGL support, porting
+ * an application from OpenGL-ES+EGL to EFL can be a bit tedious. In order to
+ * ease the transition, this file provides a set of convenience functions and
+ * macros.
+ *
+ * Please also refer to @ref elm_opengl_page and the various guides about
+ * @ref Evas_GL "Evas GL".
+ *
+ * Users can include this file instead of any other GL or EGL header file.
+ * This will redefine all the standard GL functions into macros using the
+ * #Evas_GL_API structure.
+ */
+
+/**
+ * @brief Convenience macro to insert at the beginning of every function calling OpenGL with @ref Elm_GLView.
+ * @param[in] glview Elementary GLView object in use
+ *
+ * Here's a very simple code example:
+ * @code
+static void _draw_gl(Evas_Object *obj)
+{
+ ELEMENTARY_GLVIEW_USE(obj);
+
+ glClearColor(0.2, 0.2, 0.2, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+}
+ * @endcode
+ *
+ * This is the equivalent of:
+ * @code
+static void _draw_gl(Evas_Object *obj)
+{
+ Evas_GL_API *api = elm_glview_gl_api_get(obj);
+
+ api->glClearColor(0.2, 0.2, 0.2, 1.0);
+ api->glClear(GL_COLOR_BUFFER_BIT);
+}
+ * @endcode
+ *
+ * @note This macro should be used in every function that calls OpenGL from the
+ * Elementary. This indeed means that each function must have access to
+ * the @ref Elm_GLView widget. Although this might require some changes in
+ * existing GL codebases, this is the recommended way to use the GL API.
+ *
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ */
+#define ELEMENTARY_GLVIEW_USE(glview) \
+ Evas_GL_API *__evas_gl_glapi = elm_glview_gl_api_get(glview);
+
+/**
+ * @brief Convenience macro to insert at the beginning of every function calling OpenGL with @ref Elm_GLView.
+ *
+ * @param[in] glview Elementary @ref Elm_GLView object in use
+ * @param[in] retval A value to return in case of failure (GL API was not found), can be empty
+ *
+ * This is similar to @ref ELEMENTARY_GLVIEW_USE except that it will return from
+ * the function if the GL API can not be used.
+ *
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ */
+#define ELEMENTARY_GLVIEW_USE_OR_RETURN(glview, retval) \
+ Evas_GL_API *__evas_gl_glapi = elm_glview_gl_api_get(glview); \
+ if (!__evas_gl_glapi) return retval;
+
+// End of the convenience functions
+
+
+// Global convenience functions and big warnings on their limited usage
+
+/**
+ *
+ * This second set of helper macros can be used in simple applications
+ * that use OpenGL with a single target surface.
+ *
+ * @warning Be very careful when using these macros! The only recommended solution
+ * is to use @ref ELEMENTARY_GLVIEW_USE in every client function. Here
+ * are some situations where you should <b>not</b> use the global helpers:
+ * @li If you are using more than one Evas canvas at a time (eg. multiple windows).
+ * The GL API will be different if you are using different rendering engines
+ * (software and GL for instance), and this can happen as soon as you have
+ * multiple canvases.
+ * @li If you are using multiple GLES APIs i.e OpenGL-ES 1.1, OpenGL-ES 2.0 and
+ * OpenGL-ES 3.0 APIs.
+ * @li If you are writing or porting a library that may be used by other
+ * applications.
+ *
+ * This set of macros should be used only in the following situation:
+ * @li Only one surface is used for GL rendering,
+ * @li Only one API set (GLES 1.1 or GLES 2.0 or GLES 3.0) is used
+ */
+
+/**
+ * @brief Convenience macro to use the GL helpers in simple applications: declare
+ *
+ * @c ELEMENTARY_GLVIEW_GLOBAL_DECLARE should be used in a global header for the
+ * application. For example, in a platform-specific compatibility header file.
+ *
+ * Example of a global header file @c main.h:
+ * @code
+#include <Elementary_GL_Helpers.h>
+// other includes...
+
+ELEMENTARY_GLVIEW_GLOBAL_DECLARE()
+
+// ...
+ * @endcode
+ *
+ * @see @ref ELEMENTARY_GLVIEW_GLOBAL_DEFINE
+ * @see @ref ELEMENTARY_GLVIEW_GLOBAL_USE
+ *
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ */
+#define ELEMENTARY_GLVIEW_GLOBAL_DECLARE() \
+ extern Evas_GL_API *__evas_gl_glapi;
+
+/**
+ * @brief Convenience macro to use the GL helpers in simple applications: define
+ *
+ * @c ELEMENTARY_GLVIEW_GLOBAL_DEFINE should be used at the top of a file
+ * creating the @ref Elm_GLView widget.
+ *
+ * Example of a file @c glview.c:
+ *
+ * @code
+#include "main.h"
+ELEMENTARY_GLVIEW_GLOBAL_DEFINE()
+
+// ...
+
+static Evas_Object *
+glview_create(Evas_Object *parent)
+{
+ Evas_Object *glview;
+
+ glview = elm_glview_version_add(parent, EVAS_GL_GLES_2_X);
+ ELEMENTARY_GLVIEW_GLOBAL_USE(glview);
+
+ elm_glview_mode_set(glview, ELM_GLVIEW_ALPHA | ELM_GLVIEW_DEPTH | ELM_GLVIEW_STENCIL);
+ elm_glview_resize_policy_set(glview, ELM_GLVIEW_RESIZE_POLICY_RECREATE);
+ elm_glview_render_policy_set(glview, ELM_GLVIEW_RENDER_POLICY_ON_DEMAND);
+
+ elm_glview_init_func_set(glview, _init_gl);
+ elm_glview_del_func_set(glview, _del_gl);
+ elm_glview_resize_func_set(glview, _resize_gl);
+ elm_glview_render_func_set(glview, _draw_gl);
+
+ return glview;
+}
+
+// ...
+ * @endcode
+ *
+ * @see @ref ELEMENTARY_GLVIEW_GLOBAL_DECLARE
+ * @see @ref ELEMENTARY_GLVIEW_GLOBAL_USE
+ *
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ */
+#define ELEMENTARY_GLVIEW_GLOBAL_DEFINE() \
+ Evas_GL_API *__evas_gl_glapi = NULL;
+
+/**
+ * @brief Convenience macro to use the GL helpers in simple applications: use
+ *
+ * This macro will set the global variable holding the GL API so that it's
+ * available to the application.
+ *
+ * It should be used right after setting up the @ref Elm_GLView object.
+ *
+ * @see @ref ELEMENTARY_GLVIEW_GLOBAL_DECLARE
+ * @see @ref ELEMENTARY_GLVIEW_GLOBAL_DEFINE
+ *
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ */
+#define ELEMENTARY_GLVIEW_GLOBAL_USE(glview) \
+ do { __evas_gl_glapi = elm_glview_gl_api_get(glview); } while (0)
+
+/**
+ * @brief Macro to check that the GL APIs are properly set (GLES 1.1)
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ */
+#define ELEMENTARY_GLVIEW_GLES1_API_CHECK() EVAS_GL_GLES1_API_CHECK()
+
+/**
+ * @brief Macro to check that the GL APIs are properly set (GLES 2.0)
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ */
+#define ELEMENTARY_GLVIEW_GLES2_API_CHECK() EVAS_GL_GLES2_API_CHECK()
+
+/**
+ * @brief Macro to check that the GL APIs are properly set (GLES 3.0)
+ * @since_tizen 2.4
+ */
+#define ELEMENTARY_GLVIEW_GLES3_API_CHECK() EVAS_GL_GLES3_API_CHECK()
+
+
+// End of the convenience functions
+
+/**
+ * @ingroup Elm_GLView
+ * @{
+ */
+/**
+ * @page elm_opengl_page OpenGL with Elementary
+ *
+ *
+ * @section elm_opengl_egl2evasgl Porting a native EGL+OpenGL-ES2 application to EFL
+ *
+ * Contents of this section:
+ * @li @ref elm_opengl_foreword
+ * @li @ref elm_opengl_why
+ * @li @ref elm_opengl_evasglexample
+ * @li @ref elm_opengl_direct_rendering
+ * @li @ref elm_opengl_gles1
+ * @li @ref elm_opengl_otheregl
+ *
+ *
+ * @subsection elm_opengl_foreword Foreword
+ *
+ * While Evas and Ecore provide all the required functions to build a whole
+ * application based on EFL and using OpenGL, it is recommended to use
+ * @ref Elm_GLView instead. Elementary @ref Elm_GLView will create a drawable GL
+ * surface for the application, and set up all the required callbacks so that
+ * the complexity of Evas GL is hidden.
+ *
+ *
+ * @subsection elm_opengl_helpers Convenience functions for OpenGL with EFL
+ *
+ * The file @ref Elementary_GL_Helpers "Elementary_GL_Helpers.h" provides some convenience functions
+ * that ease the use of OpenGL within an Elementary application.
+ *
+ *
+ * @subsection elm_opengl_why Why all the trouble?
+ *
+ * Evas GL is an abstraction layer on top of EGL, GLX or WGL that should provide
+ * the necessary features for most applications, in a platform-independent way.
+ * Since the goal of Evas GL is to abstract the underlying platform, only a
+ * subset of the features can be used by applications.
+ *
+ * On top of this, an Evas GL surface can be stacked within a GUI layout just
+ * like any other widget, and will support transparency, direct rendering, and
+ * various other features. For these reasons, it is not possible to directly
+ * expose lower level APIs like OpenGL or EGL and interact with Evas as the
+ * same time.
+ *
+ * The following sections should provide developers guides on how to use
+ * OpenGL-ES in an EFL application.
+ *
+ *
+ * @subsection elm_opengl_evasglexample Evas GL initialiation with GLView
+ *
+ * When using @ref Elm_GLView, EFL will take care of the tedious creation of all
+ * the surfaces and contexts. Also, EFL hides the underlying display system
+ * so there is no way to get a direct handle to
+ *
+ * Here is a demo using EFL with OpenGL:
+ *
+ * @code
+// gcc `pkg-config --cflags --libs elementary` glview.c -o glview
+#include <Elementary_GL_Helpers.h>
+
+static void _draw_gl(Evas_Object *obj)
+{
+ ELEMENTARY_GLVIEW_USE(obj);
+
+ glClearColor(0.2, 0.2, 0.2, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+}
+
+static void _resize_gl(Evas_Object *obj)
+{
+ ELEMENTARY_GLVIEW_USE(obj);
+ int w, h;
+
+ elm_glview_size_get(obj, &w, &h);
+ glViewport(0, 0, w, h);
+}
+
+// This is the GL initialization function
+Evas_Object* glview_create(Evas_Object *win)
+{
+ Evas_Object *glview;
+
+ glview = elm_glview_add(win);
+ elm_win_resize_object_add(win, glview);
+ elm_glview_mode_set(glview, ELM_GLVIEW_ALPHA | ELM_GLVIEW_DEPTH | ELM_GLVIEW_STENCIL);
+ elm_glview_resize_policy_set(glview, ELM_GLVIEW_RESIZE_POLICY_RECREATE);
+ elm_glview_render_policy_set(glview, ELM_GLVIEW_RENDER_POLICY_ON_DEMAND);
+ //elm_glview_init_func_set(glview, _init_gl);
+ //elm_glview_del_func_set(glview, _del_gl);
+ elm_glview_render_func_set(glview, _draw_gl);
+ elm_glview_resize_func_set(glview, _resize_gl);
+ evas_object_size_hint_min_set(glview, 250, 250);
+ evas_object_show(glview);
+
+ return glview;
+}
+
+EAPI int elm_main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
+{
+ Evas_Object *win;
+
+ // Set the acceleration preference to 3d
+ elm_config_accel_preference_set("3d");
+
+ // Create a window
+ win = elm_win_util_standard_add("glview", "GLView");
+ evas_object_show(win);
+
+ // Setup our GLView
+ glview_create(win);
+
+ elm_run();
+ elm_shutdown();
+ return 0;
+}
+ELM_MAIN()
+ * @endcode
+ *
+ *
+ *
+ * @subsection elm_opengl_direct_rendering Direct rendering with Evas GL
+ *
+ * Evas GL can be used to render directly to the back buffer of the Evas
+ * window. It is important to note that this is an optimization path and this
+ * will present a few limitations. Normally, Evas GL will create an FBO and use
+ * it as target surface for all the GL draw operations, and finally blend this
+ * FBO's contents to the Evas canvas.
+ *
+ * Evas GL will automatically fallback to indirect rendering unless the
+ * conditions are right. The flag @ref EVAS_GL_OPTIONS_DIRECT must be set on
+ * the target surface in order to enable direct rendering. When using the
+ * Elementary GLView widget, the flag @c ELM_GLVIEW_DIRECT should be set.
+ *
+ * Some limitations of direct rendering include the following:
+ * @li If @c glClear() is called after @c glClearColor(0,0,0,0), then clear will be
+ * skipped for the color buffer. Otherwise this would erase the back buffer
+ * in evas, instead of preparing a transparent surface for GL rendering.
+ * Opaque colors will be cleared as expected (eg. @c (0,0,0,1)).
+ * @li Evas GL will fallback to indirect rendering if an Evas Map is applied,
+ * or if other conditions force Evas to fallback.
+ * @li The user application is responsible for handling screen rotation when
+ * using direct rendering, which is why applications should set the
+ * flag @ref EVAS_GL_OPTIONS_CLIENT_SIDE_ROTATION on the GL surface (or
+ * @ref ELM_GLVIEW_CLIENT_SIDE_ROTATION for @ref Elm_GLView). Please also see
+ * @ref evas_gl_rotation_get.
+ *
+ * @note Direct rendering is an option that can drastically improve the
+ * performance of OpenGL applications, but it can exhibit some side effects.
+ *
+ *
+ *
+ * @subsection elm_opengl_gles1 OpenGL-ES 1.1 support in EFL
+ *
+ * Since Tizen 2.3, Evas GL supports the OpenGL-ES 1.1 set of rendering APIs on
+ * top of the normal OpenGL-ES 2.0 APIs, if the drivers supports it.
+ *
+ * With @ref Elm_GLView, it is easy to create a 1.1 capable surface:
+ * @code
+Evas_Object *glview;
+glview = elm_glview_version_add(win, EVAS_GL_GLES_1_X);
+ * @endcode
+ *
+ * @subsection elm_opengl_gles3 OpenGL-ES 3.0 support in EFL
+ *
+ * Since Tizen 2.4, Evas GL supports the OpenGL-ES 3.0 set of rendering APIs on
+ * top of the normal OpenGL-ES 2.0 APIs, if the drivers supports it.
+ *
+ * With @ref Elm_GLView, it is easy to create a 3.0 capable surface:
+ * @code
+Evas_Object *glview;
+glview = elm_glview_version_add(win, EVAS_GL_GLES_3_X);
+ * @endcode
+ *
+ * As usual, the GL API is available using @ref elm_glview_gl_api_get, which
+ * can be abstracted with @ref ELEMENTARY_GLVIEW_USE.
+ *
+ * When using Evas GL directly, developers must be careful to use
+ * @ref evas_gl_context_api_get with the current context in order to get
+ * the proper API (1.1 or 2.0 or 3.0). Indeed, @ref evas_gl_api_get will always return
+ * a GLES 2.0 API, and the 1.1 and 2.0 APIs are not compatible. Also, the application
+ * will then be responsible for calling @c evas_gl_make_current.
+ *
+ * @remarks Always use @ref Elm_GLView unless there is a very good reason not to.
+ *
+ * @subsection elm_opengl_otheregl Other uses of EGL and their Evas GL equivalents
+ *
+ * Of course, Evas GL is not limited to creating fullscreen OpenGL target surfaces,
+ * and some developers might want to exploit some of the more advanced features
+ * of Evas GL.
+ *
+ * @li @ref elm_opengl_evasglvsegl "Evas GL vs. EGL"
+ * @li @ref elm_opengl_surfquery "Query surfaces for their properties"
+ * @li @ref elm_opengl_pbuffer "PBuffer surfaces for multithread rendering"
+ *
+ * These features usually require to use @ref Evas_GL directly rather than just
+ * @ref Elm_GLView.
+ *
+ *
+ * @anchor elm_opengl_evasglvsegl
+ * <h2> Evas GL vs. EGL </h2>
+ *
+ * As explained above, Evas GL is an abstraction layer on top of EGL, but not
+ * limited to EGL. While trying to look similar to EGL, Evas GL should also
+ * support GLX and other backends (WGL, ...).
+ *
+ * As a consequence, only a subset of the EGL features are supported by Evas GL.
+ *
+ * Manual work is required in order to transform all calls to EGL into Evas GL
+ * calls, but the final code should be much lighter when using EFL. Here is
+ * a simple table comparison between EGL and Evas GL calls:
+ *
+ * <table border="1">
+ * <tr> <th> EGL </th> <th> Evas GL </th> <th> Comment </th> </tr>
+ * <tr> <td> @c eglGetDisplay </td> <td> N/A </td> <td> Not required </td> </tr>
+ * <tr> <td> @c eglInitialize </td> <td> @ref evas_gl_new </td> <td> - </td> </tr>
+ * <tr> <td> @c eglTerminate </td> <td> @ref evas_gl_free </td> <td> - </td> </tr>
+ * <tr> <td> @c eglQueryString </td> <td> @ref evas_gl_string_query </td> <td> For extensions: if (glapi->evasglExtFunc) { ... } </td> </tr>
+ * <tr> <td> @c eglReleaseThread </td> <td> N/A </td> <td> - </td> </tr>
+ * <tr> <td> @c eglGetConfigs </td> <td> N/A </td> <td> Not required </td> </tr>
+ * <tr> <td> @c eglGetConfigAttrib </td> <td> N/A </td> <td> - </td> </tr>
+ * <tr> <td> @c eglChooseConfig </td> <td> @ref evas_gl_config_new and @ref Evas_GL_Config </td> <td> - </td> </tr>
+ * <tr> <td> @c eglCreateWindowSurface </td> <td> @ref Elm_GLView or @ref evas_gl_surface_create </td> <td> @ref Elm_GLView provides @ref elm_glview_add </td> </tr>
+ * <tr> <td> @c eglCreatePixmapSurface </td> <td> N/A </td> <td> Not available because it is platform dependent </td> </tr>
+ * <tr> <td> @c eglCreatePbufferSurface </td> <td> @ref evas_gl_pbuffer_surface_create </td> <td> - </td> </tr>
+ * <tr> <td> @c eglCreatePbufferFromClientBuffer </td> <td> N/A </td> <td> - </td> </tr>
+ * <tr> <td> @c eglDestroySurface </td> <td> @ref evas_gl_surface_destroy </td> <td> - </td> </tr>
+ * <tr> <td> @c eglSurfaceAttrib </td> <td> N/A </td> <td> Surfaces can't be changed </td> </tr>
+ * <tr> <td> @c eglQuerySurface </td> <td> @ref evas_gl_surface_query </td> <td> Subset of features only </td> </tr>
+ * <tr> <td> @c eglCreateContext </td> <td> @ref evas_gl_context_create and @ref evas_gl_context_version_create </td> <td> @ref Elm_GLView provides @ref elm_glview_add </td> </tr>
+ * <tr> <td> @c eglDestroyContext </td> <td> @ref evas_gl_context_destroy </td> <td> - </td> </tr>
+ * <tr> <td> @c eglMakeCurrent </td> <td> @ref evas_gl_make_current </td> <td> - </td> </tr>
+ * <tr> <td> @c eglWaitGL </td> <td> N/A </td> <td> Use a fence sync if available </td> </tr>
+ * <tr> <td> @c eglWaitNative </td> <td> N/A </td> <td> Use a fence sync if available </td> </tr>
+ * <tr> <td> @c eglWaitClient </td> <td> N/A </td> <td> Use a fence sync if available </td> </tr>
+ * <tr> <td> @c eglSwapBuffers </td> <td> N/A </td> <td> Transparently done by Evas </td> </tr>
+ * <tr> <td> @c eglCopyBuffers </td> <td> N/A </td> <td> Not available because it is platform dependent </td> </tr>
+ * <tr> <td> @c eglSwapInterval </td> <td> N/A </td> <td> Transparently done by Ecore and Evas </td> </tr>
+ * <tr> <td> @c eglBindTexImage </td> <td> N/A </td> <td> Not available, use FBOs </td> </tr>
+ * <tr> <td> @c eglReleaseTexImage </td> <td> N/A </td> <td> Not available, use FBOs </td> </tr>
+ * <tr> <td> @c eglGetProcAddress </td> <td> #Evas_GL_API: #evas_gl_proc_address_get </td> <td> Provides extra Evas GL extensions (not EGL) </td> </tr>
+ * <tr> <td> @c eglCreateImageKHR </td> <td> #Evas_GL_API: @ref evasglCreateImageForContext </td> <td> Extension </td> </tr>
+ * <tr> <td> @c eglDestroyImageKHR </td> <td> #Evas_GL_API:@ref evasglDestroyImage </td> <td> Extension </td> </tr>
+ * <tr> <td> @c eglCreateSyncKHR </td> <td> #Evas_GL_API: @ref evasglCreateSync </td> <td> Extension </td> </tr>
+ * <tr> <td> @c eglDestroySyncKHR </td> <td> #Evas_GL_API: @ref evasglDestroySync </td> <td> Extension </td> </tr>
+ * <tr> <td> @c eglClientWaitSyncKHR </td> <td> #Evas_GL_API: @ref evasglClientWaitSync </td> <td> Extension </td> </tr>
+ * <tr> <td> @c eglSignalSyncKHR </td> <td> #Evas_GL_API: @ref evasglSignalSync </td> <td> Extension </td> </tr>
+ * <tr> <td> @c eglGetSyncAttribKHR </td> <td> #Evas_GL_API: @ref evasglGetSyncAttrib </td> <td> Extension </td> </tr>
+ * <tr> <td> @c eglWaitSyncKHR </td> <td> #Evas_GL_API: @ref evasglWaitSync </td> <td> Extension </td> </tr>
+ * </table>
+ *
+ * The extensions above may or may not be available depending on the OpenGL
+ * driver and the backend used.
+ *
+ * Some EGL definitions have also been imported and transformed for Evas GL. In
+ * particular, the EVAS_GL error codes returned by @ref evas_gl_error_get don't
+ * start from @c 0x3000 like EGL but from 0. Also, attribute lists can be
+ * terminated by 0 instead of @c EGL_NONE.
+ *
+ *
+ * @anchor elm_opengl_surfquery
+ * <h2> Query surfaces for their properties </h2>
+ *
+ * When using EGL, it is common to query a surface for its properties. Evas GL
+ * supports only a subset of the surface properties:
+ * @li @ref EVAS_GL_WIDTH,
+ * @li @ref EVAS_GL_HEIGHT,
+ * @li @ref EVAS_GL_TEXTURE_FORMAT,
+ * @li @ref EVAS_GL_TEXTURE_TARGET
+ *
+ * Refer to @ref evas_gl_surface_query for more information.
+ *
+ *
+ * @anchor elm_opengl_pbuffer
+ * <h2> PBuffer surfaces for multithread rendering </h2>
+ *
+ * If an application wants to render offscreen using OpenGL, it can use FBOs.
+ * But if the application wants to render in a separate render thread, a surface
+ * must be created for that thread in order to call @ref evas_gl_make_current.
+ *
+ * In the EGL world, it is common to create a PBuffer surface with
+ * @c eglCreatePBufferSurface() and set its size to 1x1. With @ref Evas_GL this
+ * is possible using @ref evas_gl_pbuffer_surface_create.
+ *
+ * Here is how an application could setup a render context in a separate thread:
+ *
+ * @code
+// In the init function:
+Evas_GL_Surface *sfc;
+Evas_GL_Config *cfg;
+Evas_GL_Context *ctx;
+Evas_GL *evasgl;
+
+evasgl = elm_glview_evas_gl_get(glview);
+
+cfg = evas_gl_config_new();
+cfg->color_format = EVAS_GL_RGBA_8888;
+cfg->depth_bits = EVAS_GL_DEPTH_NONE;
+cfg->stencil_bits = EVAS_GL_STENCIL_NONE;
+cfg->options_bits = EVAS_GL_OPTIONS_NONE;
+
+sfc = evas_gl_pbuffer_surface_create(evasgl, cfg, WIDTH, HEIGHT, NULL);
+ctx = evas_gl_context_create(elm_glview_evas_gl_get(glview), NULL);
+evas_gl_config_free(cfg);
+// ...
+
+// In the render function:
+evas_gl_make_current(evasgl, sfc, ctx);
+
+// Render to a FBO, bind it to a native image and pass it to the main thread
+// using an EvasGLImage.
+ * @endcode
+ *
+ * Multithread OpenGL rendering with Evas GL is the topic of another guide.
+ *
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+#endif // _ELEMENTARY_GL_HELPERS_H
projects / platform / upstream / efl.git / commitdiff