diff --git a/legacy/evas/src/lib/Evas_GL.h b/legacy/evas/src/lib/Evas_GL.h index 687e9b15bd..c6810ab1da 100644 --- a/legacy/evas/src/lib/Evas_GL.h +++ b/legacy/evas/src/lib/Evas_GL.h @@ -2,6 +2,7 @@ #define _EVAS_GL_H #include +//#include #ifdef __cplusplus extern "C" { @@ -16,6 +17,7 @@ typedef struct _Evas_GL_Surface Evas_GL_Surface; typedef struct _Evas_GL_Context Evas_GL_Context; typedef struct _Evas_GL_Config Evas_GL_Config; typedef void* Evas_GL_Func; +typedef struct _Evas_GL_API Evas_GL_API; typedef enum _Evas_GL_Color_Format { @@ -136,7 +138,628 @@ EAPI Evas_GL_Func evas_gl_proc_address_get (Evas_GL *evas_gl, cons */ EAPI Eina_Bool evas_gl_native_surface_get (Evas_GL *evas_gl, Evas_GL_Surface *surf, Evas_Native_Surface *ns) EINA_ARG_NONNULL(1,2,3); -// EAPI Evas_GL *evas_gl_api_get (Evas *e, Evas_GL_API *glapi) EINA_ARG_NONNULL(1, 2); +EAPI Evas_GL_API *evas_gl_api_get (Evas_GL *evas_gl) EINA_ARG_NONNULL(1); + +#ifndef __gl_h_ +#define __gl_h_ +/* + * This document is licensed under the SGI Free Software B License Version + * 2.0. For details, see http://oss.sgi.com/projects/FreeB/ . + */ + +/*------------------------------------------------------------------------- + * Data type definitions + *-----------------------------------------------------------------------*/ + +typedef void GLvoid; +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef signed char GLbyte; // Changed khronos_int8_t +typedef short GLshort; +typedef int GLint; +typedef int GLsizei; +typedef unsigned char GLubyte; // Changed khronos_uint8_t +typedef unsigned short GLushort; +typedef unsigned int GLuint; +typedef float GLfloat; // Changed khronos_float_t +typedef float GLclampf; // Changed khronos_float_t +typedef signed int GLfixed; // Changed khronos_int32_t + +/* GL types for handling large vertex buffer objects */ +typedef signed long int GLintptr; // Changed khronos_intptr_t +typedef signed long int GLsizeiptr; // Changed khronos_ssize_t + +//#if (!defined(__gl2_h_) && !defined(__gl_h_)) + +/* OpenGL ES core versions */ +//#define GL_ES_VERSION_2_0 1 + +/* ClearBufferMask */ +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 + +/* Boolean */ +#define GL_FALSE 0 +#define GL_TRUE 1 + +/* BeginMode */ +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 + +/* AlphaFunction (not supported in ES20) */ +/* GL_NEVER */ +/* GL_LESS */ +/* GL_EQUAL */ +/* GL_LEQUAL */ +/* GL_GREATER */ +/* GL_NOTEQUAL */ +/* GL_GEQUAL */ +/* GL_ALWAYS */ + +/* BlendingFactorDest */ +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 + +/* BlendingFactorSrc */ +/* GL_ZERO */ +/* GL_ONE */ +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +/* GL_SRC_ALPHA */ +/* GL_ONE_MINUS_SRC_ALPHA */ +/* GL_DST_ALPHA */ +/* GL_ONE_MINUS_DST_ALPHA */ + +/* BlendEquationSeparate */ +#define GL_FUNC_ADD 0x8006 +#define GL_BLEND_EQUATION 0x8009 +#define GL_BLEND_EQUATION_RGB 0x8009 /* same as BLEND_EQUATION */ +#define GL_BLEND_EQUATION_ALPHA 0x883D + +/* BlendSubtract */ +#define GL_FUNC_SUBTRACT 0x800A +#define GL_FUNC_REVERSE_SUBTRACT 0x800B + +/* Separate Blend Functions */ +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_BLEND_COLOR 0x8005 + +/* Buffer Objects */ +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 + +#define GL_STREAM_DRAW 0x88E0 +#define GL_STATIC_DRAW 0x88E4 +#define GL_DYNAMIC_DRAW 0x88E8 + +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 + +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 + +/* CullFaceMode */ +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_FRONT_AND_BACK 0x0408 + +/* DepthFunction */ +/* GL_NEVER */ +/* GL_LESS */ +/* GL_EQUAL */ +/* GL_LEQUAL */ +/* GL_GREATER */ +/* GL_NOTEQUAL */ +/* GL_GEQUAL */ +/* GL_ALWAYS */ + +/* EnableCap */ +#define GL_TEXTURE_2D 0x0DE1 +#define GL_CULL_FACE 0x0B44 +#define GL_BLEND 0x0BE2 +#define GL_DITHER 0x0BD0 +#define GL_STENCIL_TEST 0x0B90 +#define GL_DEPTH_TEST 0x0B71 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_COVERAGE 0x80A0 + +/* ErrorCode */ +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 + +/* FrontFaceDirection */ +#define GL_CW 0x0900 +#define GL_CCW 0x0901 + +/* GetPName */ +#define GL_LINE_WIDTH 0x0B21 +#define GL_ALIASED_POINT_SIZE_RANGE 0x846D +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_VIEWPORT 0x0BA2 +#define GL_SCISSOR_BOX 0x0C10 +/* GL_SCISSOR_TEST */ +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_RED_BITS 0x0D52 +#define GL_GREEN_BITS 0x0D53 +#define GL_BLUE_BITS 0x0D54 +#define GL_ALPHA_BITS 0x0D55 +#define GL_DEPTH_BITS 0x0D56 +#define GL_STENCIL_BITS 0x0D57 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +/* GL_POLYGON_OFFSET_FILL */ +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB + +/* GetTextureParameter */ +/* GL_TEXTURE_MAG_FILTER */ +/* GL_TEXTURE_MIN_FILTER */ +/* GL_TEXTURE_WRAP_S */ +/* GL_TEXTURE_WRAP_T */ + +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 + +/* HintMode */ +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 + +/* HintTarget */ +#define GL_GENERATE_MIPMAP_HINT 0x8192 + +/* DataType */ +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_FIXED 0x140C + +/* PixelFormat */ +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_LUMINANCE 0x1909 +#define GL_LUMINANCE_ALPHA 0x190A + +/* PixelType */ +/* GL_UNSIGNED_BYTE */ +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 + +/* Shaders */ +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_MAX_VERTEX_UNIFORM_VECTORS 0x8DFB +#define GL_MAX_VARYING_VECTORS 0x8DFC +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_MAX_FRAGMENT_UNIFORM_VECTORS 0x8DFD +#define GL_SHADER_TYPE 0x8B4F +#define GL_DELETE_STATUS 0x8B80 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D + +/* StencilFunction */ +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 + +/* StencilOp */ +/* GL_ZERO */ +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_INVERT 0x150A +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 + +/* StringName */ +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 + +/* TextureMagFilter */ +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 + +/* TextureMinFilter */ +/* GL_NEAREST */ +/* GL_LINEAR */ +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 + +/* TextureParameterName */ +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 + +/* TextureTarget */ +/* GL_TEXTURE_2D */ +#define GL_TEXTURE 0x1702 + +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C + +/* TextureUnit */ +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 + +/* TextureWrapMode */ +#define GL_REPEAT 0x2901 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_MIRRORED_REPEAT 0x8370 + +/* Uniform Types */ +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_CUBE 0x8B60 + +/* Vertex Arrays */ +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F + +/* Read Format */ +#define GL_IMPLEMENTATION_COLOR_READ_TYPE 0x8B9A +#define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B + +/* Shader Source */ +#define GL_COMPILE_STATUS 0x8B81 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_SHADER_COMPILER 0x8DFA + +/* Shader Binary */ +#define GL_SHADER_BINARY_FORMATS 0x8DF8 +#define GL_NUM_SHADER_BINARY_FORMATS 0x8DF9 + +/* Shader Precision-Specified Types */ +#define GL_LOW_FLOAT 0x8DF0 +#define GL_MEDIUM_FLOAT 0x8DF1 +#define GL_HIGH_FLOAT 0x8DF2 +#define GL_LOW_INT 0x8DF3 +#define GL_MEDIUM_INT 0x8DF4 +#define GL_HIGH_INT 0x8DF5 + +/* Framebuffer Object. */ +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 + +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGB565 0x8D62 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_STENCIL_INDEX 0x1901 +#define GL_STENCIL_INDEX8 0x8D48 + +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 + +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 + +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 + +#define GL_NONE 0 + +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS 0x8CD9 +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD + +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 + +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 + +#else +# ifndef EVAS_GL_NO_GL_H_CHECK +# error "You may only include either Evas_GL.h OR use your native OpenGL's headers. If you use Evas to do GL, then you cannot use the native gl headers." +# endif +#endif + +#define EVAS_GL_API_VERSION 1 +struct _Evas_GL_API +{ + int version; + + /* version 1: */ + void (*glActiveTexture) (GLenum texture); + void (*glAttachShader) (GLuint program, GLuint shader); + void (*glBindAttribLocation) (GLuint program, GLuint index, const char* name); + void (*glBindBuffer) (GLenum target, GLuint buffer); + void (*glBindFramebuffer) (GLenum target, GLuint framebuffer); + void (*glBindRenderbuffer) (GLenum target, GLuint renderbuffer); + void (*glBindTexture) (GLenum target, GLuint texture); + void (*glBlendColor) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + void (*glBlendEquation) ( GLenum mode ); + void (*glBlendEquationSeparate) (GLenum modeRGB, GLenum modeAlpha); + void (*glBlendFunc) (GLenum sfactor, GLenum dfactor); + void (*glBlendFuncSeparate) (GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); + void (*glBufferData) (GLenum target, GLsizeiptr size, const void* data, GLenum usage); + void (*glBufferSubData) (GLenum target, GLintptr offset, GLsizeiptr size, const void* data); + GLenum (*glCheckFramebufferStatus) (GLenum target); + void (*glClear) (GLbitfield mask); + void (*glClearColor) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + void (*glClearDepthf) (GLclampf depth); + void (*glClearStencil) (GLint s); + void (*glColorMask) (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); + void (*glCompileShader) (GLuint shader); + void (*glCompressedTexImage2D) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data); + void (*glCompressedTexSubImage2D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data); + void (*glCopyTexImage2D) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); + void (*glCopyTexSubImage2D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); + GLuint (*glCreateProgram) (void); + GLuint (*glCreateShader) (GLenum type); + void (*glCullFace) (GLenum mode); + void (*glDeleteBuffers) (GLsizei n, const GLuint* buffers); + void (*glDeleteFramebuffers) (GLsizei n, const GLuint* framebuffers); + void (*glDeleteProgram) (GLuint program); + void (*glDeleteRenderbuffers) (GLsizei n, const GLuint* renderbuffers); + void (*glDeleteShader) (GLuint shader); + void (*glDeleteTextures) (GLsizei n, const GLuint* textures); + void (*glDepthFunc) (GLenum func); + void (*glDepthMask) (GLboolean flag); + void (*glDepthRangef) (GLclampf zNear, GLclampf zFar); + void (*glDetachShader) (GLuint program, GLuint shader); + void (*glDisable) (GLenum cap); + void (*glDisableVertexAttribArray) (GLuint index); + void (*glDrawArrays) (GLenum mode, GLint first, GLsizei count); + void (*glDrawElements) (GLenum mode, GLsizei count, GLenum type, const void* indices); + void (*glEnable) (GLenum cap); + void (*glEnableVertexAttribArray) (GLuint index); + void (*glFinish) (void); + void (*glFlush) (void); + void (*glFramebufferRenderbuffer) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); + void (*glFramebufferTexture2D) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); + void (*glFrontFace) (GLenum mode); + void (*glGenBuffers) (GLsizei n, GLuint* buffers); + void (*glGenerateMipmap) (GLenum target); + void (*glGenFramebuffers) (GLsizei n, GLuint* framebuffers); + void (*glGenRenderbuffers) (GLsizei n, GLuint* renderbuffers); + void (*glGenTextures) (GLsizei n, GLuint* textures); + void (*glGetActiveAttrib) (GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name); + void (*glGetActiveUniform) (GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name); + void (*glGetAttachedShaders) (GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders); + int (*glGetAttribLocation) (GLuint program, const char* name); + void (*glGetBooleanv) (GLenum pname, GLboolean* params); + void (*glGetBufferParameteriv) (GLenum target, GLenum pname, GLint* params); + GLenum (*glGetError) (void); + void (*glGetFloatv) (GLenum pname, GLfloat* params); + void (*glGetFramebufferAttachmentParameteriv) (GLenum target, GLenum attachment, GLenum pname, GLint* params); + void (*glGetIntegerv) (GLenum pname, GLint* params); + void (*glGetProgramiv) (GLuint program, GLenum pname, GLint* params); + void (*glGetProgramInfoLog) (GLuint program, GLsizei bufsize, GLsizei* length, char* infolog); + void (*glGetRenderbufferParameteriv) (GLenum target, GLenum pname, GLint* params); + void (*glGetShaderiv) (GLuint shader, GLenum pname, GLint* params); + void (*glGetShaderInfoLog) (GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog); + void (*glGetShaderPrecisionFormat) (GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision); + void (*glGetShaderSource) (GLuint shader, GLsizei bufsize, GLsizei* length, char* source); + const GLubyte* (*glGetString) (GLenum name); + void (*glGetTexParameterfv) (GLenum target, GLenum pname, GLfloat* params); + void (*glGetTexParameteriv) (GLenum target, GLenum pname, GLint* params); + void (*glGetUniformfv) (GLuint program, GLint location, GLfloat* params); + void (*glGetUniformiv) (GLuint program, GLint location, GLint* params); + int (*glGetUniformLocation) (GLuint program, const char* name); + void (*glGetVertexAttribfv) (GLuint index, GLenum pname, GLfloat* params); + void (*glGetVertexAttribiv) (GLuint index, GLenum pname, GLint* params); + void (*glGetVertexAttribPointerv) (GLuint index, GLenum pname, void** pointer); + void (*glHint) (GLenum target, GLenum mode); + GLboolean (*glIsBuffer) (GLuint buffer); + GLboolean (*glIsEnabled) (GLenum cap); + GLboolean (*glIsFramebuffer) (GLuint framebuffer); + GLboolean (*glIsProgram) (GLuint program); + GLboolean (*glIsRenderbuffer) (GLuint renderbuffer); + GLboolean (*glIsShader) (GLuint shader); + GLboolean (*glIsTexture) (GLuint texture); + void (*glLineWidth) (GLfloat width); + void (*glLinkProgram) (GLuint program); + void (*glPixelStorei) (GLenum pname, GLint param); + void (*glPolygonOffset) (GLfloat factor, GLfloat units); + void (*glReadPixels) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels); + void (*glReleaseShaderCompiler) (void); + void (*glRenderbufferStorage) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height); + void (*glSampleCoverage) (GLclampf value, GLboolean invert); + void (*glScissor) (GLint x, GLint y, GLsizei width, GLsizei height); + void (*glShaderBinary) (GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length); + void (*glShaderSource) (GLuint shader, GLsizei count, const char** string, const GLint* length); + void (*glStencilFunc) (GLenum func, GLint ref, GLuint mask); + void (*glStencilFuncSeparate) (GLenum face, GLenum func, GLint ref, GLuint mask); + void (*glStencilMask) (GLuint mask); + void (*glStencilMaskSeparate) (GLenum face, GLuint mask); + void (*glStencilOp) (GLenum fail, GLenum zfail, GLenum zpass); + void (*glStencilOpSeparate) (GLenum face, GLenum fail, GLenum zfail, GLenum zpass); + void (*glTexImage2D) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels); + void (*glTexParameterf) (GLenum target, GLenum pname, GLfloat param); + void (*glTexParameterfv) (GLenum target, GLenum pname, const GLfloat* params); + void (*glTexParameteri) (GLenum target, GLenum pname, GLint param); + void (*glTexParameteriv) (GLenum target, GLenum pname, const GLint* params); + void (*glTexSubImage2D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels); + void (*glUniform1f) (GLint location, GLfloat x); + void (*glUniform1fv) (GLint location, GLsizei count, const GLfloat* v); + void (*glUniform1i) (GLint location, GLint x); + void (*glUniform1iv) (GLint location, GLsizei count, const GLint* v); + void (*glUniform2f) (GLint location, GLfloat x, GLfloat y); + void (*glUniform2fv) (GLint location, GLsizei count, const GLfloat* v); + void (*glUniform2i) (GLint location, GLint x, GLint y); + void (*glUniform2iv) (GLint location, GLsizei count, const GLint* v); + void (*glUniform3f) (GLint location, GLfloat x, GLfloat y, GLfloat z); + void (*glUniform3fv) (GLint location, GLsizei count, const GLfloat* v); + void (*glUniform3i) (GLint location, GLint x, GLint y, GLint z); + void (*glUniform3iv) (GLint location, GLsizei count, const GLint* v); + void (*glUniform4f) (GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + void (*glUniform4fv) (GLint location, GLsizei count, const GLfloat* v); + void (*glUniform4i) (GLint location, GLint x, GLint y, GLint z, GLint w); + void (*glUniform4iv) (GLint location, GLsizei count, const GLint* v); + void (*glUniformMatrix2fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); + void (*glUniformMatrix3fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); + void (*glUniformMatrix4fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); + void (*glUseProgram) (GLuint program); + void (*glValidateProgram) (GLuint program); + void (*glVertexAttrib1f) (GLuint indx, GLfloat x); + void (*glVertexAttrib1fv) (GLuint indx, const GLfloat* values); + void (*glVertexAttrib2f) (GLuint indx, GLfloat x, GLfloat y); + void (*glVertexAttrib2fv) (GLuint indx, const GLfloat* values); + void (*glVertexAttrib3f) (GLuint indx, GLfloat x, GLfloat y, GLfloat z); + void (*glVertexAttrib3fv) (GLuint indx, const GLfloat* values); + void (*glVertexAttrib4f) (GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + void (*glVertexAttrib4fv) (GLuint indx, const GLfloat* values); + void (*glVertexAttribPointer) (GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr); + void (*glViewport) (GLint x, GLint y, GLsizei width, GLsizei height); + + /* future calls will be added down here for expansion */ + /* version 2: */ +}; + #ifdef __cplusplus } diff --git a/legacy/evas/src/lib/canvas/evas_gl.c b/legacy/evas/src/lib/canvas/evas_gl.c index f88b8c18e2..a43069e636 100644 --- a/legacy/evas/src/lib/canvas/evas_gl.c +++ b/legacy/evas/src/lib/canvas/evas_gl.c @@ -215,3 +215,15 @@ evas_gl_native_surface_get(Evas_GL *evas_gl, Evas_GL_Surface *surf, Evas_Native_ return (Eina_Bool)evas_gl->evas->engine.func->gl_native_surface_get(evas_gl->evas->engine.data.output, surf->data, ns); } + + +EAPI Evas_GL_API * +evas_gl_api_get(Evas_GL *evas_gl) +{ + MAGIC_CHECK(evas_gl, Evas_GL, MAGIC_EVAS_GL); + return NULL; + MAGIC_CHECK_END(); + + return (Evas_GL_API*)evas_gl->evas->engine.func->gl_api_get(evas_gl->evas->engine.data.output); + +} diff --git a/legacy/evas/src/lib/include/evas_common.h b/legacy/evas/src/lib/include/evas_common.h index dad5c51ca7..1e7b610deb 100644 --- a/legacy/evas/src/lib/include/evas_common.h +++ b/legacy/evas/src/lib/include/evas_common.h @@ -11,7 +11,7 @@ #include #include "Evas.h" -#include "Evas_GL.h" +//#include "Evas_GL.h" #ifdef HAVE_PIXMAN #include diff --git a/legacy/evas/src/lib/include/evas_private.h b/legacy/evas/src/lib/include/evas_private.h index 9d9b2d2ab5..db04d4e9b3 100644 --- a/legacy/evas/src/lib/include/evas_private.h +++ b/legacy/evas/src/lib/include/evas_private.h @@ -731,6 +731,7 @@ struct _Evas_Func int (*gl_make_current) (void *data, void *surface, void *context); void *(*gl_proc_address_get) (void *data, const char *name); int (*gl_native_surface_get) (void *data, void *surface, void *native_surface); + void *(*gl_api_get) (void *data); }; struct _Evas_Image_Load_Func diff --git a/legacy/evas/src/modules/engines/gl_common/evas_gl_context.c b/legacy/evas/src/modules/engines/gl_common/evas_gl_context.c index b38d7d750f..83ec9cf6ad 100644 --- a/legacy/evas/src/modules/engines/gl_common/evas_gl_context.c +++ b/legacy/evas/src/modules/engines/gl_common/evas_gl_context.c @@ -2688,8 +2688,12 @@ again: if ((tex->im) && (tex->im->native.data) && (!tex->im->native.yinvert)) { - // FIXME: handle yinvert - ERR("not handling inverted y case for map"); + for (i = 0; i < 4; i++) + { + ty[i] = 1.0 - ty[i]; + if (yuv) + t2y[i] = 1.0 - t2y[i]; + } } cmul = ARGB_JOIN(a, r, g, b); diff --git a/legacy/evas/src/modules/engines/gl_x11/evas_engine.c b/legacy/evas/src/modules/engines/gl_x11/evas_engine.c index 1ab49f4988..443d587542 100644 --- a/legacy/evas/src/modules/engines/gl_x11/evas_engine.c +++ b/legacy/evas/src/modules/engines/gl_x11/evas_engine.c @@ -2,6 +2,8 @@ #include "evas_engine.h" #include /* dlopen,dlclose,etc */ +#define EVAS_GL_NO_GL_H_CHECK 1 +#include "Evas_GL.h" #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX) // EGL / GLES @@ -91,6 +93,9 @@ typedef _eng_fn (*glsym_func_eng_fn) (); typedef void (*glsym_func_void) (); typedef int (*glsym_func_int) (); typedef XID (*glsym_func_xid) (); +typedef unsigned int (*glsym_func_uint) (); +typedef unsigned char (*glsym_func_uchar) (); +typedef unsigned char *(*glsym_func_uchar_ptr) (); _eng_fn (*glsym_glXGetProcAddress) (const char *a) = NULL; void (*glsym_glXBindTexImage) (Display *a, GLXDrawable b, int c, int *d) = NULL; @@ -186,6 +191,9 @@ int _evas_engine_GL_X11_log_dom = -1; /* function tables - filled in later (func and parent func) */ static Evas_Func func, pfunc; +/* Function table for GL APIs */ +static Evas_GL_API gl_funcs; + struct xrdb_user { time_t last_stat; @@ -2567,7 +2575,7 @@ eng_gl_make_current(void *data, void *surface, void *context) glBindFramebuffer(GL_FRAMEBUFFER, ctx->fbo); #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX) #else - glDrawBuffer(GL_COLOR_ATTACHMENT0); + //glDrawBuffer(GL_COLOR_ATTACHMENT0); #endif return 1; @@ -2609,6 +2617,256 @@ eng_gl_native_surface_get(void *data, void *surface, void *native_surface) return 1; } +#if 1 +static void +evgl_glBindFramebuffer(GLenum target, GLuint framebuffer) +{ + // Add logic to take care when framebuffer=0 + glBindFramebuffer(target, framebuffer); +} + +static void +evgl_glBindRenderbuffer(GLenum target, GLuint renderbuffer) +{ + // Add logic to take care when renderbuffer=0 + glBindRenderbuffer(target, renderbuffer); +} + +static void +evgl_glClearDepthf(GLclampf depth) +{ +#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX) + glClearDepthf(depth); +#else + glClearDepth(depth); +#endif +} + +static void +evgl_glDepthRangef(GLclampf zNear, GLclampf zFar) +{ +#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX) + glDepthRangef(zNear, zFar); +#else + glDepthRange(zNear, zFar); +#endif +} + +static void +evgl_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) +{ +#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX) + glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision); +#else + if (range) + { + range[0] = -126; // floor(log2(FLT_MIN)) + range[1] = 127; // floor(log2(FLT_MAX)) + } + if (precision) + { + precision[0] = 24; // floor(-log2((1.0/16777218.0))); + } + return; + shadertype = precisiontype = 0; +#endif +} + +static void +evgl_glReleaseShaderCompiler(void) +{ +#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX) + glReleaseShaderCompiler(); +#else +#endif +} + +static void +evgl_glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) +{ +#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX) + glShaderBinary(n, shaders, binaryformat, binary, length); +#else +// FIXME: need to dlsym/getprocaddress for this + return; + n = binaryformat = length = 0; + shaders = binary = 0; +#endif +} + +#endif + +static void * +eng_gl_api_get(void *data) +{ + Render_Engine *re; + + re = (Render_Engine *)data; + + gl_funcs.version = EVAS_GL_API_VERSION; +#if 1 +#define ORD(f) EVAS_API_OVERRIDE(f, &gl_funcs, ) + ORD(glActiveTexture); + ORD(glAttachShader); + ORD(glBindAttribLocation); + ORD(glBindBuffer); + ORD(glBindTexture); + ORD(glBlendColor); + ORD(glBlendEquation); + ORD(glBlendEquationSeparate); + ORD(glBlendFunc); + ORD(glBlendFuncSeparate); + ORD(glBufferData); + ORD(glBufferSubData); + ORD(glCheckFramebufferStatus); + ORD(glClear); + ORD(glClearColor); +// ORD(glClearDepthf); + ORD(glClearStencil); + ORD(glColorMask); + ORD(glCompileShader); + ORD(glCompressedTexImage2D); + ORD(glCompressedTexSubImage2D); + ORD(glCopyTexImage2D); + ORD(glCopyTexSubImage2D); + ORD(glCreateProgram); + ORD(glCreateShader); + ORD(glCullFace); + ORD(glDeleteBuffers); + ORD(glDeleteFramebuffers); + ORD(glDeleteProgram); + ORD(glDeleteRenderbuffers); + ORD(glDeleteShader); + ORD(glDeleteTextures); + ORD(glDepthFunc); + ORD(glDepthMask); +// ORD(glDepthRangef); + ORD(glDetachShader); + ORD(glDisable); + ORD(glDisableVertexAttribArray); + ORD(glDrawArrays); + ORD(glDrawElements); + ORD(glEnable); + ORD(glEnableVertexAttribArray); + ORD(glFinish); + ORD(glFlush); + ORD(glFramebufferRenderbuffer); + ORD(glFramebufferTexture2D); + ORD(glFrontFace); + ORD(glGenBuffers); + ORD(glGenerateMipmap); + ORD(glGenFramebuffers); + ORD(glGenRenderbuffers); + ORD(glGenTextures); + ORD(glGetActiveAttrib); + ORD(glGetActiveUniform); + ORD(glGetAttachedShaders); + ORD(glGetAttribLocation); + ORD(glGetBooleanv); + ORD(glGetBufferParameteriv); + ORD(glGetError); + ORD(glGetFloatv); + ORD(glGetFramebufferAttachmentParameteriv); + ORD(glGetIntegerv); + ORD(glGetProgramiv); + ORD(glGetProgramInfoLog); + ORD(glGetRenderbufferParameteriv); + ORD(glGetShaderiv); + ORD(glGetShaderInfoLog); +// ORD(glGetShaderPrecisionFormat); + ORD(glGetShaderSource); + ORD(glGetString); + ORD(glGetTexParameterfv); + ORD(glGetTexParameteriv); + ORD(glGetUniformfv); + ORD(glGetUniformiv); + ORD(glGetUniformLocation); + ORD(glGetVertexAttribfv); + ORD(glGetVertexAttribiv); + ORD(glGetVertexAttribPointerv); + ORD(glHint); + ORD(glIsBuffer); + ORD(glIsEnabled); + ORD(glIsFramebuffer); + ORD(glIsProgram); + ORD(glIsRenderbuffer); + ORD(glIsShader); + ORD(glIsTexture); + ORD(glLineWidth); + ORD(glLinkProgram); + ORD(glPixelStorei); + ORD(glPolygonOffset); + ORD(glReadPixels); +// ORD(glReleaseShaderCompiler); + ORD(glRenderbufferStorage); + ORD(glSampleCoverage); + ORD(glScissor); +// ORD(glShaderBinary); + ORD(glShaderSource); + ORD(glStencilFunc); + ORD(glStencilFuncSeparate); + ORD(glStencilMask); + ORD(glStencilMaskSeparate); + ORD(glStencilOp); + ORD(glStencilOpSeparate); + ORD(glTexImage2D); + ORD(glTexParameterf); + ORD(glTexParameterfv); + ORD(glTexParameteri); + ORD(glTexParameteriv); + ORD(glTexSubImage2D); + ORD(glUniform1f); + ORD(glUniform1fv); + ORD(glUniform1i); + ORD(glUniform1iv); + ORD(glUniform2f); + ORD(glUniform2fv); + ORD(glUniform2i); + ORD(glUniform2iv); + ORD(glUniform3f); + ORD(glUniform3fv); + ORD(glUniform3i); + ORD(glUniform3iv); + ORD(glUniform4f); + ORD(glUniform4fv); + ORD(glUniform4i); + ORD(glUniform4iv); + ORD(glUniformMatrix2fv); + ORD(glUniformMatrix3fv); + ORD(glUniformMatrix4fv); + ORD(glUseProgram); + ORD(glValidateProgram); + ORD(glVertexAttrib1f); + ORD(glVertexAttrib1fv); + ORD(glVertexAttrib2f); + ORD(glVertexAttrib2fv); + ORD(glVertexAttrib3f); + ORD(glVertexAttrib3fv); + ORD(glVertexAttrib4f); + ORD(glVertexAttrib4fv); + ORD(glVertexAttribPointer); + ORD(glViewport); +#undef ORD + +// Override functions wrapped by Evas_GL +#define ORD(f) EVAS_API_OVERRIDE(f, &gl_funcs, evgl_) + ORD(glBindFramebuffer); + ORD(glBindRenderbuffer); + +// GLES2.0 API compat on top of desktop gl + ORD(glClearDepthf); + ORD(glDepthRangef); + ORD(glGetShaderPrecisionFormat); + ORD(glReleaseShaderCompiler); + ORD(glShaderBinary); +#undef ORD + +#endif + + return &gl_funcs; +} + + static int module_open(Evas_Module *em) { @@ -2710,6 +2968,8 @@ module_open(Evas_Module *em) ORD(gl_make_current); ORD(gl_proc_address_get); ORD(gl_native_surface_get); + + ORD(gl_api_get); /* now advertise out own api */ em->functions = (void *)(&func); diff --git a/legacy/evas/src/modules/engines/gl_x11/evas_x_main.c b/legacy/evas/src/modules/engines/gl_x11/evas_x_main.c index 63cf43792b..d25de0e403 100644 --- a/legacy/evas/src/modules/engines/gl_x11/evas_x_main.c +++ b/legacy/evas/src/modules/engines/gl_x11/evas_x_main.c @@ -583,9 +583,9 @@ eng_window_use(Evas_GL_X11_Window *gw) evas_gl_common_context_use(_evas_gl_x11_window->gl_context); evas_gl_common_context_flush(_evas_gl_x11_window->gl_context); } - _evas_gl_x11_window = gw; - if (gw) - { + _evas_gl_x11_window = gw; + if (gw) + { // EGL / GLES #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX) if (gw->egl_surface[0] != EGL_NO_SURFACE) @@ -616,7 +616,7 @@ eng_window_use(Evas_GL_X11_Window *gw) } } #endif - } + } } if (gw) evas_gl_common_context_use(gw->gl_context); }