summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorDongyeon Kim <dy5.kim@samsung.com>2015-08-18 17:35:40 +0900
committerJean-Philippe Andre <jp.andre@samsung.com>2015-08-18 18:31:40 +0900
commitbea42e6a003bc7133a6703bada3a379154e93ae0 (patch)
tree32d015b5c7d97c0a4e13fde804afd526c34f3f76
parent8c8d254fbc8fbbe9be3660a2a0862035fc8983f0 (diff)
Evas GL: Restore current context to evas gl context when the backend has taken over
Summary: When Evas GL apis are called outside of on pixels callback, evas gl backend context may have been made current, and Evas GL will render into a wrong context. So here we provide context restore mechanism of keeping track of currently bound context and calling make current when needed. @feature Test Plan: Run Evas GL test cases Reviewers: jpeg, cedric Subscribers: mythri, mer.kim, wonsik, cedric Differential Revision: https://phab.enlightenment.org/D2956
-rw-r--r--src/modules/evas/engines/gl_common/evas_gl_api.c3031
-rw-r--r--src/modules/evas/engines/gl_common/evas_gl_api_def.h143
-rw-r--r--src/modules/evas/engines/gl_common/evas_gl_api_ext.c156
-rw-r--r--src/modules/evas/engines/gl_common/evas_gl_api_ext.h12
-rw-r--r--src/modules/evas/engines/gl_common/evas_gl_api_ext_def.h445
-rw-r--r--src/modules/evas/engines/gl_common/evas_gl_api_gles1.c730
-rw-r--r--src/modules/evas/engines/gl_common/evas_gl_api_gles3_def.h104
-rw-r--r--src/modules/evas/engines/gl_common/evas_gl_common.h4
-rw-r--r--src/modules/evas/engines/gl_common/evas_gl_core.c37
-rw-r--r--src/modules/evas/engines/gl_common/evas_gl_core_private.h5
-rw-r--r--src/modules/evas/engines/gl_generic/evas_engine.c51
-rw-r--r--src/modules/evas/engines/gl_x11/evas_engine.c3
-rw-r--r--src/modules/evas/engines/gl_x11/evas_engine.h3
-rw-r--r--src/modules/evas/engines/gl_x11/evas_x_main.c9
14 files changed, 1931 insertions, 2802 deletions
diff --git a/src/modules/evas/engines/gl_common/evas_gl_api.c b/src/modules/evas/engines/gl_common/evas_gl_api.c
index 8597bf8..b8c7240 100644
--- a/src/modules/evas/engines/gl_common/evas_gl_api.c
+++ b/src/modules/evas/engines/gl_common/evas_gl_api.c
@@ -3,12 +3,14 @@
3#include "evas_gl_api_ext.h" 3#include "evas_gl_api_ext.h"
4#include <dlfcn.h> 4#include <dlfcn.h>
5 5
6#define EVGL_FUNC_BEGIN() \ 6#define EVGL_FUNC_BEGIN() if (UNLIKELY(_need_context_restore)) _context_restore()
7
8#define EVGLD_FUNC_BEGIN() \
7{ \ 9{ \
8 _func_begin_debug(__FUNCTION__); \ 10 _func_begin_debug(__FUNCTION__); \
9} 11}
10 12
11#define EVGL_FUNC_END() GLERRV(__FUNCTION__) 13#define EVGLD_FUNC_END() GLERRV(__FUNCTION__)
12#define _EVGL_INT_INIT_VALUE -3 14#define _EVGL_INT_INIT_VALUE -3
13 15
14static void *_gles3_handle = NULL; 16static void *_gles3_handle = NULL;
@@ -996,868 +998,28 @@ _evgl_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
996} 998}
997//-------------------------------------------------------------// 999//-------------------------------------------------------------//
998 1000
1001// Open GLES 2.0 APIs
1002#define _EVASGL_FUNCTION_PRIVATE_BEGIN(ret, name, param1, param2) \
1003 static ret evgl_##name param1 { EVGL_FUNC_BEGIN(); return _evgl_##name param2; }
1004#define _EVASGL_FUNCTION_BEGIN(ret, name, param1, param2) \
1005 static ret evgl_##name param1 { EVGL_FUNC_BEGIN(); return name param2; }
999 1006
1000//-------------------------------------------------------------// 1007#include "evas_gl_api_def.h"
1001// Open GLES 3.0 APIs
1002
1003
1004static void
1005_evgl_glReadBuffer(GLenum mode)
1006{
1007 if (!_gles3_api.glReadBuffer)
1008 return;
1009 _gles3_api.glReadBuffer(mode);
1010}
1011
1012static void
1013_evgl_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
1014{
1015 if (!_gles3_api.glDrawRangeElements)
1016 return;
1017 _gles3_api.glDrawRangeElements(mode, start, end, count, type, indices);
1018}
1019
1020static void
1021_evgl_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
1022{
1023 if (!_gles3_api.glTexImage3D)
1024 return;
1025 _gles3_api.glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
1026}
1027
1028static void
1029_evgl_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
1030{
1031 if (!_gles3_api.glTexSubImage3D)
1032 return;
1033 _gles3_api.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
1034}
1035
1036static void
1037_evgl_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
1038{
1039 if (!_gles3_api.glCopyTexSubImage3D)
1040 return;
1041 _gles3_api.glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
1042}
1043
1044static void
1045_evgl_glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
1046{
1047 if (!_gles3_api.glCompressedTexImage3D)
1048 return;
1049 _gles3_api.glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
1050}
1051
1052static void
1053_evgl_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
1054{
1055 if (!_gles3_api.glCompressedTexSubImage3D)
1056 return;
1057 _gles3_api.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
1058}
1059
1060static void
1061_evgl_glGenQueries(GLsizei n, GLuint *ids)
1062{
1063 if (!_gles3_api.glGenQueries)
1064 return;
1065 _gles3_api.glGenQueries(n, ids);
1066}
1067
1068static void
1069_evgl_glDeleteQueries(GLsizei n, const GLuint *ids)
1070{
1071 if (!_gles3_api.glDeleteQueries)
1072 return;
1073 _gles3_api.glDeleteQueries(n, ids);
1074}
1075
1076static GLboolean
1077 _evgl_glIsQuery(GLuint id)
1078{
1079 GLboolean ret;
1080 if (!_gles3_api.glIsQuery)
1081 return EINA_FALSE;
1082 ret = _gles3_api.glIsQuery(id);
1083 return ret;
1084}
1085
1086static void
1087_evgl_glBeginQuery(GLenum target, GLuint id)
1088{
1089 if (!_gles3_api.glBeginQuery)
1090 return;
1091 _gles3_api.glBeginQuery(target, id);
1092}
1093
1094static void
1095_evgl_glEndQuery(GLenum target)
1096{
1097 if (!_gles3_api.glEndQuery)
1098 return;
1099 _gles3_api.glEndQuery(target);
1100}
1101
1102static void
1103_evgl_glGetQueryiv(GLenum target, GLenum pname, GLint *params)
1104{
1105 if (!_gles3_api.glGetQueryiv)
1106 return;
1107 _gles3_api.glGetQueryiv(target, pname, params);
1108}
1109
1110static void
1111_evgl_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
1112{
1113 if (!_gles3_api.glGetQueryObjectuiv)
1114 return;
1115 _gles3_api.glGetQueryObjectuiv(id, pname, params);
1116}
1117
1118static GLboolean
1119_evgl_glUnmapBuffer(GLenum target)
1120{
1121 GLboolean ret;
1122 if (!_gles3_api.glUnmapBuffer)
1123 return EINA_FALSE;
1124 ret = _gles3_api.glUnmapBuffer(target);
1125 return ret;
1126}
1127
1128static void
1129_evgl_glGetBufferPointerv(GLenum target, GLenum pname, GLvoid **params)
1130{
1131 if (!_gles3_api.glGetBufferPointerv)
1132 return;
1133 _gles3_api.glGetBufferPointerv(target, pname, params);
1134}
1135
1136static void
1137_evgl_glDrawBuffers(GLsizei n, const GLenum *bufs)
1138{
1139 if (!_gles3_api.glDrawBuffers)
1140 return;
1141 _gles3_api.glDrawBuffers(n, bufs);
1142}
1143
1144static void
1145_evgl_glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
1146{
1147 if (!_gles3_api.glUniformMatrix2x3fv)
1148 return;
1149 _gles3_api.glUniformMatrix2x3fv(location, count, transpose, value);
1150}
1151
1152static void
1153_evgl_glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
1154{
1155 if (!_gles3_api.glUniformMatrix3x2fv)
1156 return;
1157 _gles3_api.glUniformMatrix3x2fv(location, count, transpose, value);
1158}
1159
1160static void
1161_evgl_glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
1162{
1163 if (!_gles3_api.glUniformMatrix2x4fv)
1164 return;
1165 _gles3_api.glUniformMatrix2x4fv(location, count, transpose, value);
1166}
1167
1168static void
1169_evgl_glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
1170{
1171 if (!_gles3_api.glUniformMatrix4x2fv)
1172 return;
1173 _gles3_api.glUniformMatrix4x2fv(location, count, transpose, value);
1174}
1175
1176static void
1177_evgl_glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
1178{
1179 if (!_gles3_api.glUniformMatrix3x4fv)
1180 return;
1181 _gles3_api.glUniformMatrix3x4fv(location, count, transpose, value);
1182}
1183
1184static void
1185_evgl_glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
1186{
1187 if (!_gles3_api.glUniformMatrix4x3fv)
1188 return;
1189 _gles3_api.glUniformMatrix4x3fv(location, count, transpose, value);
1190}
1191
1192static void
1193_evgl_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
1194{
1195 if (!_gles3_api.glBlitFramebuffer)
1196 return;
1197 _gles3_api.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
1198}
1199
1200static void
1201_evgl_glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
1202{
1203 if (!_gles3_api.glRenderbufferStorageMultisample)
1204 return;
1205 _gles3_api.glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
1206}
1207
1208static void
1209_evgl_glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
1210{
1211 if (!_gles3_api.glFramebufferTextureLayer)
1212 return;
1213 _gles3_api.glFramebufferTextureLayer(target, attachment, texture, level, layer);
1214}
1215
1216static void*
1217_evgl_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
1218{
1219 void* ret;
1220 if (!_gles3_api.glMapBufferRange)
1221 return NULL;
1222 ret = _gles3_api.glMapBufferRange(target, offset, length, access);
1223 return ret;
1224}
1225
1226static GLsync
1227_evgl_glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
1228{
1229 GLsync ret;
1230 if (!_gles3_api.glFlushMappedBufferRange)
1231 return 0;
1232 ret = _gles3_api.glFlushMappedBufferRange(target, offset, length);
1233 return ret;
1234}
1235
1236static void
1237_evgl_glBindVertexArray(GLuint array)
1238{
1239 if (!_gles3_api.glBindVertexArray)
1240 return;
1241 _gles3_api.glBindVertexArray(array);
1242}
1243
1244static void
1245_evgl_glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
1246{
1247 if (!_gles3_api.glDeleteVertexArrays)
1248 return;
1249 _gles3_api.glDeleteVertexArrays(n, arrays);
1250}
1251
1252static void
1253_evgl_glGenVertexArrays(GLsizei n, GLuint *arrays)
1254{
1255 if (!_gles3_api.glGenVertexArrays)
1256 return;
1257 _gles3_api.glGenVertexArrays(n, arrays);
1258}
1259
1260static GLboolean
1261_evgl_glIsVertexArray(GLuint array)
1262{
1263 GLboolean ret;
1264 if (!_gles3_api.glIsVertexArray)
1265 return EINA_FALSE;
1266 ret = _gles3_api.glIsVertexArray(array);
1267 return ret;
1268}
1269
1270static void
1271_evgl_glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
1272{
1273 if (!_gles3_api.glGetIntegeri_v)
1274 return;
1275 _gles3_api.glGetIntegeri_v(target, index, data);
1276}
1277
1278static void
1279_evgl_glBeginTransformFeedback(GLenum primitiveMode)
1280{
1281 if (!_gles3_api.glBeginTransformFeedback)
1282 return;
1283 _gles3_api.glBeginTransformFeedback(primitiveMode);
1284}
1285
1286static void
1287_evgl_glEndTransformFeedback(void)
1288{
1289 if (!_gles3_api.glEndTransformFeedback)
1290 return;
1291 _gles3_api.glEndTransformFeedback();
1292}
1293
1294static void
1295_evgl_glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
1296{
1297 if (!_gles3_api.glBindBufferRange)
1298 return;
1299 _gles3_api.glBindBufferRange(target, index, buffer, offset, size);
1300}
1301
1302static void
1303_evgl_glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
1304{
1305 if (!_gles3_api.glBindBufferBase)
1306 return;
1307 _gles3_api.glBindBufferBase(target, index, buffer);
1308}
1309
1310static void
1311_evgl_glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode)
1312{
1313 if (!_gles3_api.glTransformFeedbackVaryings)
1314 return;
1315 _gles3_api.glTransformFeedbackVaryings(program, count, varyings, bufferMode);
1316}
1317
1318static void
1319_evgl_glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
1320{
1321 if (!_gles3_api.glGetTransformFeedbackVarying)
1322 return;
1323 _gles3_api.glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
1324}
1325
1326static void
1327_evgl_glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
1328{
1329 if (!_gles3_api.glVertexAttribIPointer)
1330 return;
1331 _gles3_api.glVertexAttribIPointer(index, size, type, stride, pointer);
1332}
1333
1334static void
1335_evgl_glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
1336{
1337 if (!_gles3_api.glGetVertexAttribIiv)
1338 return;
1339 _gles3_api.glGetVertexAttribIiv(index, pname, params);
1340}
1341
1342static void
1343_evgl_glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
1344{
1345 if (!_gles3_api.glGetVertexAttribIuiv)
1346 return;
1347 _gles3_api.glGetVertexAttribIuiv(index, pname, params);
1348}
1349
1350static void
1351_evgl_glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
1352{
1353 if (!_gles3_api.glVertexAttribI4i)
1354 return;
1355 _gles3_api.glVertexAttribI4i(index, x, y, z, w);
1356}
1357
1358static void
1359_evgl_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
1360{
1361 if (!_gles3_api.glVertexAttribI4ui)
1362 return;
1363 _gles3_api.glVertexAttribI4ui(index, x, y, z, w);
1364}
1365
1366static void
1367_evgl_glVertexAttribI4iv(GLuint index, const GLint *v)
1368{
1369 if (!_gles3_api.glVertexAttribI4iv)
1370 return;
1371 _gles3_api.glVertexAttribI4iv(index, v);
1372}
1373
1374static void
1375_evgl_glVertexAttribI4uiv(GLuint index, const GLuint *v)
1376{
1377 if (!_gles3_api.glVertexAttribI4uiv)
1378 return;
1379 _gles3_api.glVertexAttribI4uiv(index, v);
1380}
1381
1382static void
1383_evgl_glGetUniformuiv(GLuint program, GLint location, GLuint *params)
1384{
1385 if (!_gles3_api.glGetUniformuiv)
1386 return;
1387 _gles3_api.glGetUniformuiv(program, location, params);
1388}
1389
1390static GLint
1391_evgl_glGetFragDataLocation(GLuint program, const GLchar *name)
1392{
1393 GLint ret;
1394 if (!_gles3_api.glGetFragDataLocation)
1395 return EVAS_GL_NOT_INITIALIZED;
1396 ret = _gles3_api.glGetFragDataLocation(program, name);
1397 return ret;
1398}
1399
1400static void
1401_evgl_glUniform1ui(GLint location, GLuint v0)
1402{
1403 if (!_gles3_api.glUniform1ui)
1404 return;
1405 _gles3_api.glUniform1ui(location, v0);
1406}
1407
1408static void
1409_evgl_glUniform2ui(GLint location, GLuint v0, GLuint v1)
1410{
1411 if (!_gles3_api.glUniform2ui)
1412 return;
1413 _gles3_api.glUniform2ui(location, v0, v1);
1414}
1415
1416static void
1417_evgl_glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
1418{
1419 if (!_gles3_api.glUniform3ui)
1420 return;
1421 _gles3_api.glUniform3ui(location, v0, v1, v2);
1422}
1423
1424static void
1425_evgl_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
1426{
1427 if (!_gles3_api.glUniform4ui)
1428 return;
1429 _gles3_api.glUniform4ui(location, v0, v1, v2, v3);
1430}
1431
1432static void
1433_evgl_glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
1434{
1435 if (!_gles3_api.glUniform1uiv)
1436 return;
1437 _gles3_api.glUniform1uiv(location, count, value);
1438}
1439
1440static void
1441_evgl_glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
1442{
1443 if (!_gles3_api.glUniform2uiv)
1444 return;
1445 _gles3_api.glUniform2uiv(location, count, value);
1446}
1447
1448static void
1449_evgl_glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
1450{
1451 if (!_gles3_api.glUniform3uiv)
1452 return;
1453 _gles3_api.glUniform3uiv(location, count, value);
1454}
1455
1456static void
1457_evgl_glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
1458{
1459 if (!_gles3_api.glUniform4uiv)
1460 return;
1461 _gles3_api.glUniform4uiv(location, count, value);
1462}
1463
1464static void
1465_evgl_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
1466{
1467 if (!_gles3_api.glClearBufferiv)
1468 return;
1469 _gles3_api.glClearBufferiv(buffer, drawbuffer, value);
1470}
1471
1472static void
1473_evgl_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
1474{
1475 if (!_gles3_api.glClearBufferuiv)
1476 return;
1477 _gles3_api.glClearBufferuiv(buffer, drawbuffer, value);
1478}
1479
1480static void
1481_evgl_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
1482{
1483 if (!_gles3_api.glClearBufferfv)
1484 return;
1485 _gles3_api.glClearBufferfv(buffer, drawbuffer, value);
1486}
1487
1488static void
1489_evgl_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
1490{
1491 if (!_gles3_api.glClearBufferfi)
1492 return;
1493 _gles3_api.glClearBufferfi(buffer, drawbuffer, depth, stencil);
1494}
1495
1496static const GLubyte *
1497 _evgl_glGetStringi(GLenum name, GLuint index)
1498{
1499 const GLubyte *ret;
1500 if (!_gles3_api.glGetStringi)
1501 return NULL;
1502 ret = _gles3_api.glGetStringi(name, index);
1503 return ret;
1504}
1505
1506static void
1507_evgl_glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
1508{
1509 if (!_gles3_api.glCopyBufferSubData)
1510 return;
1511 _gles3_api.glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
1512}
1513
1514static void
1515_evgl_glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices)
1516{
1517 if (!_gles3_api.glGetUniformIndices)
1518 return;
1519 _gles3_api.glGetUniformIndices(program, uniformCount, uniformNames,uniformIndices);
1520}
1521
1522static void
1523_evgl_glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
1524{
1525 if (!_gles3_api.glGetActiveUniformsiv)
1526 return;
1527 _gles3_api.glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
1528}
1529
1530static GLuint
1531_evgl_glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
1532{
1533 GLuint ret;
1534 if (!_gles3_api.glGetUniformBlockIndex)
1535 return EVAS_GL_NOT_INITIALIZED;
1536 ret = _gles3_api.glGetUniformBlockIndex(program, uniformBlockName);
1537 return ret;
1538}
1539 1008
1540static void 1009#undef _EVASGL_FUNCTION_PRIVATE_BEGIN
1541_evgl_glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params) 1010#undef _EVASGL_FUNCTION_BEGIN
1542{
1543 if (!_gles3_api.glGetActiveUniformBlockiv)
1544 return;
1545 _gles3_api.glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
1546}
1547 1011
1548static void 1012//-------------------------------------------------------------//
1549_evgl_glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName) 1013// Open GLES 3.0 APIs
1550{ 1014//#define _CHECK_NULL(ret, name) if (!_gles3_api.##name) return (ret)0
1551 if (!_gles3_api.glGetActiveUniformBlockName) 1015#define _EVASGL_FUNCTION_BEGIN(ret, name, param1, param2) \
1552 return; 1016 static ret evgl_gles3_##name param1 {\
1553 _gles3_api.glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); 1017 if (!_gles3_api.name) return (ret)0;\
1554} 1018 return _gles3_api.name param2; }
1555
1556static void
1557_evgl_glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
1558{
1559 if (!_gles3_api.glUniformBlockBinding)
1560 return;
1561 _gles3_api.glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
1562}
1563
1564static void
1565_evgl_glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
1566{
1567 if (!_gles3_api.glDrawArraysInstanced)
1568 return;
1569 _gles3_api.glDrawArraysInstanced(mode, first, count, instancecount);
1570}
1571
1572static void
1573_evgl_glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
1574{
1575 if (!_gles3_api.glDrawElementsInstanced)
1576 return;
1577 _gles3_api.glDrawElementsInstanced(mode, count, type, indices, instancecount);
1578}
1579
1580static GLsync
1581_evgl_glFenceSync(GLenum condition, GLbitfield flags)
1582{
1583 GLsync ret;
1584 if (!_gles3_api.glFenceSync)
1585 return 0;
1586 ret = _gles3_api.glFenceSync(condition, flags);
1587 return ret;
1588}
1589
1590static GLboolean
1591_evgl_glIsSync(GLsync sync)
1592{
1593 GLboolean ret;
1594 if (!_gles3_api.glIsSync)
1595 return EINA_FALSE;
1596 ret = _gles3_api.glIsSync(sync);
1597 return ret;
1598}
1599
1600static void
1601_evgl_glDeleteSync(GLsync sync)
1602{
1603 if (!_gles3_api.glDeleteSync)
1604 return;
1605 _gles3_api.glDeleteSync(sync);
1606}
1607
1608static GLenum
1609_evgl_glClientWaitSync(GLsync sync, GLbitfield flags, EvasGLuint64 timeout)
1610{
1611 GLenum ret;
1612 if (!_gles3_api.glClientWaitSync)
1613 return EVAS_GL_NOT_INITIALIZED;
1614 ret = _gles3_api.glClientWaitSync(sync, flags, timeout);
1615 return ret;
1616}
1617
1618static void
1619_evgl_glWaitSync(GLsync sync, GLbitfield flags, EvasGLuint64 timeout)
1620{
1621 if (!_gles3_api.glWaitSync)
1622 return;
1623 _gles3_api.glWaitSync(sync, flags, timeout);
1624}
1625
1626static void
1627_evgl_glGetInteger64v(GLenum pname, EvasGLint64 *params)
1628{
1629 if (!_gles3_api.glGetInteger64v)
1630 return;
1631 _gles3_api.glGetInteger64v(pname, params);
1632}
1633
1634static void
1635_evgl_glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
1636{
1637 if (!_gles3_api.glGetSynciv)
1638 return;
1639 _gles3_api.glGetSynciv(sync, pname, bufSize, length, values);
1640}
1641
1642static void
1643_evgl_glGetInteger64i_v(GLenum target, GLuint index, EvasGLint64 *data)
1644{
1645 if (!_gles3_api.glGetInteger64i_v)
1646 return;
1647 _gles3_api.glGetInteger64i_v(target, index, data);
1648}
1649
1650static void
1651_evgl_glGetBufferParameteri64v(GLenum target, GLenum pname, EvasGLint64 *params)
1652{
1653 if (!_gles3_api.glGetBufferParameteri64v)
1654 return;
1655 _gles3_api.glGetBufferParameteri64v(target, pname, params);
1656}
1657
1658static void
1659_evgl_glGenSamplers(GLsizei count, GLuint *samplers)
1660{
1661 if (!_gles3_api.glGenSamplers)
1662 return;
1663 _gles3_api.glGenSamplers(count, samplers);
1664}
1665
1666static void
1667_evgl_glDeleteSamplers(GLsizei count, const GLuint *samplers)
1668{
1669 if (!_gles3_api.glDeleteSamplers)
1670 return;
1671 _gles3_api.glDeleteSamplers(count, samplers);
1672}
1673
1674static GLboolean
1675_evgl_glIsSampler(GLuint sampler)
1676{
1677 GLboolean ret;
1678 if (!_gles3_api.glIsSampler)
1679 return EINA_FALSE;
1680 ret = _gles3_api.glIsSampler(sampler);
1681 return ret;
1682}
1683
1684static void
1685_evgl_glBindSampler(GLuint unit, GLuint sampler)
1686{
1687 if (!_gles3_api.glBindSampler)
1688 return;
1689 _gles3_api.glBindSampler(unit, sampler);
1690}
1691
1692static void
1693_evgl_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
1694{
1695 if (!_gles3_api.glSamplerParameteri)
1696 return;
1697 _gles3_api.glSamplerParameteri(sampler, pname, param);
1698}
1699
1700static void
1701_evgl_glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
1702{
1703 if (!_gles3_api.glSamplerParameteriv)
1704 return;
1705 _gles3_api.glSamplerParameteriv(sampler, pname, param);
1706}
1707
1708static void
1709_evgl_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
1710{
1711 if (!_gles3_api.glSamplerParameterf)
1712 return;
1713 _gles3_api.glSamplerParameterf(sampler, pname, param);
1714}
1715
1716static void
1717_evgl_glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
1718{
1719 if (!_gles3_api.glSamplerParameterfv)
1720 return;
1721 _gles3_api.glSamplerParameterfv(sampler, pname, param);
1722}
1723
1724static void
1725_evgl_glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
1726{
1727 if (!_gles3_api.glGetSamplerParameteriv)
1728 return;
1729 _gles3_api.glGetSamplerParameteriv(sampler, pname, params);
1730}
1731
1732static void
1733_evgl_glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
1734{
1735 if (!_gles3_api.glGetSamplerParameterfv)
1736 return;
1737 _gles3_api.glGetSamplerParameterfv(sampler, pname, params);
1738}
1739
1740static void
1741_evgl_glVertexAttribDivisor(GLuint index, GLuint divisor)
1742{
1743 if (!_gles3_api.glVertexAttribDivisor)
1744 return;
1745 _gles3_api.glVertexAttribDivisor(index, divisor);
1746}
1747
1748static void
1749_evgl_glBindTransformFeedback(GLenum target, GLuint id)
1750{
1751 if (!_gles3_api.glBindTransformFeedback)
1752 return;
1753 _gles3_api.glBindTransformFeedback(target, id);
1754}
1755
1756static void
1757_evgl_glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
1758{
1759 if (!_gles3_api.glDeleteTransformFeedbacks)
1760 return;
1761 _gles3_api.glDeleteTransformFeedbacks(n, ids);
1762}
1763
1764static void
1765_evgl_glGenTransformFeedbacks(GLsizei n, GLuint *ids)
1766{
1767 if (!_gles3_api.glGenTransformFeedbacks)
1768 return;
1769 _gles3_api.glGenTransformFeedbacks(n, ids);
1770}
1771
1772static GLboolean
1773_evgl_glIsTransformFeedback(GLuint id)
1774{
1775 GLboolean ret;
1776 if (!_gles3_api.glIsTransformFeedback)
1777 return EINA_FALSE;
1778 ret = _gles3_api.glIsTransformFeedback(id);
1779 return ret;
1780}
1781
1782static void
1783_evgl_glPauseTransformFeedback(void)
1784{
1785 if (!_gles3_api.glPauseTransformFeedback)
1786 return;
1787 _gles3_api.glPauseTransformFeedback();
1788}
1789
1790static void
1791_evgl_glResumeTransformFeedback(void)
1792{
1793 if (!_gles3_api.glResumeTransformFeedback)
1794 return;
1795 _gles3_api.glResumeTransformFeedback();
1796}
1797
1798static void
1799_evgl_glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
1800{
1801 if (!_gles3_api.glGetProgramBinary)
1802 return;
1803 _gles3_api.glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
1804}
1805
1806static void
1807_evgl_glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)
1808{
1809 if (!_gles3_api.glProgramBinary)
1810 return;
1811 _gles3_api.glProgramBinary(program, binaryFormat, binary, length);
1812}
1813
1814static void
1815_evgl_glProgramParameteri(GLuint program, GLenum pname, GLint value)
1816{
1817 if (!_gles3_api.glProgramParameteri)
1818 return;
1819 _gles3_api.glProgramParameteri(program, pname, value);
1820}
1821
1822static void
1823_evgl_glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
1824{
1825 if (!_gles3_api.glInvalidateFramebuffer)
1826 return;
1827 _gles3_api.glInvalidateFramebuffer(target, numAttachments, attachments);
1828}
1829
1830static void
1831_evgl_glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
1832{
1833 if (!_gles3_api.glInvalidateSubFramebuffer)
1834 return;
1835 _gles3_api.glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
1836}
1837
1838static void
1839_evgl_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
1840{
1841 if (!_gles3_api.glTexStorage2D)
1842 return;
1843 _gles3_api.glTexStorage2D(target, levels, internalformat, width, height);
1844}
1845 1019
1846static void 1020#include "evas_gl_api_gles3_def.h"
1847_evgl_glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
1848{
1849 if (!_gles3_api.glTexStorage3D)
1850 return;
1851 _gles3_api.glTexStorage3D(target, levels, internalformat, width, height, depth);
1852}
1853 1021
1854static void 1022#undef _EVASGL_FUNCTION_BEGIN
1855_evgl_glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
1856{
1857 if (!_gles3_api.glGetInternalformativ)
1858 return;
1859 _gles3_api.glGetInternalformativ(target, internalformat, pname, bufSize, params);
1860}
1861 1023
1862//-------------------------------------------------------------// 1024//-------------------------------------------------------------//
1863// Debug Evas GL APIs 1025// Debug Evas GL APIs
@@ -1867,114 +1029,113 @@ _evgl_glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname,
1867void 1029void
1868_evgld_glActiveTexture(GLenum texture) 1030_evgld_glActiveTexture(GLenum texture)
1869{ 1031{
1870 EVGL_FUNC_BEGIN(); 1032 EVGLD_FUNC_BEGIN();
1871 glActiveTexture(texture); 1033 evgl_glActiveTexture(texture);
1872 EVGL_FUNC_END(); 1034 EVGLD_FUNC_END();
1873} 1035}
1874 1036
1875void 1037void
1876_evgld_glAttachShader(GLuint program, GLuint shader) 1038_evgld_glAttachShader(GLuint program, GLuint shader)
1877{ 1039{
1878 EVGL_FUNC_BEGIN(); 1040 EVGLD_FUNC_BEGIN();
1879 glAttachShader(program, shader); 1041 evgl_glAttachShader(program, shader);
1880 EVGL_FUNC_END(); 1042 EVGLD_FUNC_END();
1881} 1043}
1882 1044
1883void 1045void
1884_evgld_glBindAttribLocation(GLuint program, GLuint idx, const char* name) 1046_evgld_glBindAttribLocation(GLuint program, GLuint idx, const char* name)
1885{ 1047{
1886 EVGL_FUNC_BEGIN(); 1048 EVGLD_FUNC_BEGIN();
1887 glBindAttribLocation(program, idx, name); 1049 evgl_glBindAttribLocation(program, idx, name);
1888 EVGL_FUNC_END(); 1050 EVGLD_FUNC_END();
1889} 1051}
1890 1052
1891void 1053void
1892_evgld_glBindBuffer(GLenum target, GLuint buffer) 1054_evgld_glBindBuffer(GLenum target, GLuint buffer)
1893{ 1055{
1894 EVGL_FUNC_BEGIN(); 1056 EVGLD_FUNC_BEGIN();
1895 glBindBuffer(target, buffer); 1057 evgl_glBindBuffer(target, buffer);
1896 EVGL_FUNC_END(); 1058 EVGLD_FUNC_END();
1897} 1059}
1898 1060
1899void 1061void
1900_evgld_glBindFramebuffer(GLenum target, GLuint framebuffer) 1062_evgld_glBindFramebuffer(GLenum target, GLuint framebuffer)
1901{ 1063{
1902 EVGL_FUNC_BEGIN(); 1064 EVGLD_FUNC_BEGIN();
1903
1904 _evgl_glBindFramebuffer(target, framebuffer); 1065 _evgl_glBindFramebuffer(target, framebuffer);
1905 EVGL_FUNC_END(); 1066 EVGLD_FUNC_END();
1906} 1067}
1907 1068
1908void 1069void
1909_evgld_glBindRenderbuffer(GLenum target, GLuint renderbuffer) 1070_evgld_glBindRenderbuffer(GLenum target, GLuint renderbuffer)
1910{ 1071{
1911 EVGL_FUNC_BEGIN(); 1072 EVGLD_FUNC_BEGIN();
1912 glBindRenderbuffer(target, renderbuffer); 1073 evgl_glBindRenderbuffer(target, renderbuffer);
1913 EVGL_FUNC_END(); 1074 EVGLD_FUNC_END();
1914} 1075}
1915 1076
1916void 1077void
1917_evgld_glBindTexture(GLenum target, GLuint texture) 1078_evgld_glBindTexture(GLenum target, GLuint texture)
1918{ 1079{
1919 EVGL_FUNC_BEGIN(); 1080 EVGLD_FUNC_BEGIN();
1920 glBindTexture(target, texture); 1081 evgl_glBindTexture(target, texture);
1921 EVGL_FUNC_END(); 1082 EVGLD_FUNC_END();
1922} 1083}
1923 1084
1924void 1085void
1925_evgld_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) 1086_evgld_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
1926{ 1087{
1927 EVGL_FUNC_BEGIN(); 1088 EVGLD_FUNC_BEGIN();
1928 glBlendColor(red, green, blue, alpha); 1089 evgl_glBlendColor(red, green, blue, alpha);
1929 EVGL_FUNC_END(); 1090 EVGLD_FUNC_END();
1930} 1091}
1931 1092
1932void 1093void
1933_evgld_glBlendEquation(GLenum mode) 1094_evgld_glBlendEquation(GLenum mode)
1934{ 1095{
1935 EVGL_FUNC_BEGIN(); 1096 EVGLD_FUNC_BEGIN();
1936 glBlendEquation(mode); 1097 evgl_glBlendEquation(mode);
1937 EVGL_FUNC_END(); 1098 EVGLD_FUNC_END();
1938} 1099}
1939 1100
1940void 1101void
1941_evgld_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) 1102_evgld_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
1942{ 1103{
1943 EVGL_FUNC_BEGIN(); 1104 EVGLD_FUNC_BEGIN();
1944 glBlendEquationSeparate(modeRGB, modeAlpha); 1105 evgl_glBlendEquationSeparate(modeRGB, modeAlpha);
1945 EVGL_FUNC_END(); 1106 EVGLD_FUNC_END();
1946} 1107}
1947 1108
1948void 1109void
1949_evgld_glBlendFunc(GLenum sfactor, GLenum dfactor) 1110_evgld_glBlendFunc(GLenum sfactor, GLenum dfactor)
1950{ 1111{
1951 EVGL_FUNC_BEGIN(); 1112 EVGLD_FUNC_BEGIN();
1952 glBlendFunc(sfactor, dfactor); 1113 evgl_glBlendFunc(sfactor, dfactor);
1953 EVGL_FUNC_END(); 1114 EVGLD_FUNC_END();
1954} 1115}
1955 1116
1956void 1117void
1957_evgld_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) 1118_evgld_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
1958{ 1119{
1959 EVGL_FUNC_BEGIN(); 1120 EVGLD_FUNC_BEGIN();
1960 glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); 1121 evgl_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
1961 EVGL_FUNC_END(); 1122 EVGLD_FUNC_END();
1962} 1123}
1963 1124
1964void 1125void
1965_evgld_glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) 1126_evgld_glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
1966{ 1127{
1967 EVGL_FUNC_BEGIN(); 1128 EVGLD_FUNC_BEGIN();
1968 glBufferData(target, size, data, usage); 1129 evgl_glBufferData(target, size, data, usage);
1969 EVGL_FUNC_END(); 1130 EVGLD_FUNC_END();
1970} 1131}
1971 1132
1972void 1133void
1973_evgld_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) 1134_evgld_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
1974{ 1135{
1975 EVGL_FUNC_BEGIN(); 1136 EVGLD_FUNC_BEGIN();
1976 glBufferSubData(target, offset, size, data); 1137 evgl_glBufferSubData(target, offset, size, data);
1977 EVGL_FUNC_END(); 1138 EVGLD_FUNC_END();
1978} 1139}
1979 1140
1980GLenum 1141GLenum
@@ -1982,84 +1143,82 @@ _evgld_glCheckFramebufferStatus(GLenum target)
1982{ 1143{
1983 GLenum ret = GL_NONE; 1144 GLenum ret = GL_NONE;
1984 1145
1985 EVGL_FUNC_BEGIN(); 1146 EVGLD_FUNC_BEGIN();
1986 ret = glCheckFramebufferStatus(target); 1147 ret = glCheckFramebufferStatus(target);
1987 EVGL_FUNC_END(); 1148 EVGLD_FUNC_END();
1988 return ret; 1149 return ret;
1989} 1150}
1990 1151
1991void 1152void
1992_evgld_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) 1153_evgld_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
1993{ 1154{
1994 EVGL_FUNC_BEGIN(); 1155 EVGLD_FUNC_BEGIN();
1995 _evgl_glClearColor(red, green, blue, alpha); 1156 _evgl_glClearColor(red, green, blue, alpha);
1996 EVGL_FUNC_END(); 1157 EVGLD_FUNC_END();
1997} 1158}
1998 1159
1999void 1160void
2000_evgld_glClearDepthf(GLclampf depth) 1161_evgld_glClearDepthf(GLclampf depth)
2001{ 1162{
2002 EVGL_FUNC_BEGIN(); 1163 EVGLD_FUNC_BEGIN();
2003
2004 _evgl_glClearDepthf(depth); 1164 _evgl_glClearDepthf(depth);
2005 1165 EVGLD_FUNC_END();
2006 EVGL_FUNC_END();
2007} 1166}
2008 1167
2009void 1168void
2010_evgld_glClearStencil(GLint s) 1169_evgld_glClearStencil(GLint s)
2011{ 1170{
2012 EVGL_FUNC_BEGIN(); 1171 EVGLD_FUNC_BEGIN();
2013 glClearStencil(s); 1172 evgl_glClearStencil(s);
2014 EVGL_FUNC_END(); 1173 EVGLD_FUNC_END();
2015} 1174}
2016 1175
2017void 1176void
2018_evgld_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) 1177_evgld_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
2019{ 1178{
2020 EVGL_FUNC_BEGIN(); 1179 EVGLD_FUNC_BEGIN();
2021 glColorMask(red, green, blue, alpha); 1180 evgl_glColorMask(red, green, blue, alpha);
2022 EVGL_FUNC_END(); 1181 EVGLD_FUNC_END();
2023} 1182}
2024 1183
2025void 1184void
2026_evgld_glCompileShader(GLuint shader) 1185_evgld_glCompileShader(GLuint shader)
2027{ 1186{
2028 EVGL_FUNC_BEGIN(); 1187 EVGLD_FUNC_BEGIN();
2029 glCompileShader(shader); 1188 evgl_glCompileShader(shader);
2030 EVGL_FUNC_END(); 1189 EVGLD_FUNC_END();
2031} 1190}
2032 1191
2033void 1192void
2034_evgld_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) 1193_evgld_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
2035{ 1194{
2036 EVGL_FUNC_BEGIN(); 1195 EVGLD_FUNC_BEGIN();
2037 glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); 1196 evgl_glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
2038 EVGL_FUNC_END(); 1197 EVGLD_FUNC_END();
2039} 1198}
2040 1199
2041void 1200void
2042_evgld_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) 1201_evgld_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
2043{ 1202{
2044 EVGL_FUNC_BEGIN(); 1203 EVGLD_FUNC_BEGIN();
2045 glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); 1204 evgl_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
2046 EVGL_FUNC_END(); 1205 EVGLD_FUNC_END();
2047} 1206}
2048 1207
2049void 1208void
2050_evgld_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) 1209_evgld_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
2051{ 1210{
2052 EVGL_FUNC_BEGIN(); 1211 EVGLD_FUNC_BEGIN();
2053 glCopyTexImage2D(target, level, internalformat, x, y, width, height, border); 1212 evgl_glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
2054 EVGL_FUNC_END(); 1213 EVGLD_FUNC_END();
2055} 1214}
2056 1215
2057void 1216void
2058_evgld_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) 1217_evgld_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
2059{ 1218{
2060 EVGL_FUNC_BEGIN(); 1219 EVGLD_FUNC_BEGIN();
2061 glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); 1220 evgl_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
2062 EVGL_FUNC_END(); 1221 EVGLD_FUNC_END();
2063} 1222}
2064 1223
2065GLuint 1224GLuint
@@ -2067,9 +1226,9 @@ _evgld_glCreateProgram(void)
2067{ 1226{
2068 GLuint ret = _EVGL_INT_INIT_VALUE; 1227 GLuint ret = _EVGL_INT_INIT_VALUE;
2069 1228
2070 EVGL_FUNC_BEGIN(); 1229 EVGLD_FUNC_BEGIN();
2071 ret = glCreateProgram(); 1230 ret = evgl_glCreateProgram();
2072 EVGL_FUNC_END(); 1231 EVGLD_FUNC_END();
2073 return ret; 1232 return ret;
2074} 1233}
2075 1234
@@ -2077,298 +1236,292 @@ GLuint
2077_evgld_glCreateShader(GLenum type) 1236_evgld_glCreateShader(GLenum type)
2078{ 1237{
2079 GLuint ret = _EVGL_INT_INIT_VALUE; 1238 GLuint ret = _EVGL_INT_INIT_VALUE;
2080 EVGL_FUNC_BEGIN(); 1239 EVGLD_FUNC_BEGIN();
2081 ret = glCreateShader(type); 1240 ret = evgl_glCreateShader(type);
2082 EVGL_FUNC_END(); 1241 EVGLD_FUNC_END();
2083 return ret; 1242 return ret;
2084} 1243}
2085 1244
2086void 1245void
2087_evgld_glCullFace(GLenum mode) 1246_evgld_glCullFace(GLenum mode)
2088{ 1247{
2089 EVGL_FUNC_BEGIN(); 1248 EVGLD_FUNC_BEGIN();
2090 glCullFace(mode); 1249 evgl_glCullFace(mode);
2091 EVGL_FUNC_END(); 1250 EVGLD_FUNC_END();
2092} 1251}
2093 1252
2094void 1253void
2095_evgld_glDeleteBuffers(GLsizei n, const GLuint* buffers) 1254_evgld_glDeleteBuffers(GLsizei n, const GLuint* buffers)
2096{ 1255{
2097 EVGL_FUNC_BEGIN(); 1256 EVGLD_FUNC_BEGIN();
2098 glDeleteBuffers(n, buffers); 1257 evgl_glDeleteBuffers(n, buffers);
2099 EVGL_FUNC_END(); 1258 EVGLD_FUNC_END();
2100} 1259}
2101 1260
2102void 1261void
2103_evgld_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) 1262_evgld_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
2104{ 1263{
2105 EVGL_FUNC_BEGIN(); 1264 EVGLD_FUNC_BEGIN();
2106 glDeleteFramebuffers(n, framebuffers); 1265 evgl_glDeleteFramebuffers(n, framebuffers);
2107 EVGL_FUNC_END(); 1266 EVGLD_FUNC_END();
2108} 1267}
2109 1268
2110void 1269void
2111_evgld_glDeleteProgram(GLuint program) 1270_evgld_glDeleteProgram(GLuint program)
2112{ 1271{
2113 EVGL_FUNC_BEGIN(); 1272 EVGLD_FUNC_BEGIN();
2114 glDeleteProgram(program); 1273 evgl_glDeleteProgram(program);
2115 EVGL_FUNC_END(); 1274 EVGLD_FUNC_END();
2116} 1275}
2117 1276
2118void 1277void
2119_evgld_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) 1278_evgld_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
2120{ 1279{
2121 EVGL_FUNC_BEGIN(); 1280 EVGLD_FUNC_BEGIN();
2122 glDeleteRenderbuffers(n, renderbuffers); 1281 evgl_glDeleteRenderbuffers(n, renderbuffers);
2123 EVGL_FUNC_END(); 1282 EVGLD_FUNC_END();
2124} 1283}
2125 1284
2126void 1285void
2127_evgld_glDeleteShader(GLuint shader) 1286_evgld_glDeleteShader(GLuint shader)
2128{ 1287{
2129 EVGL_FUNC_BEGIN(); 1288 EVGLD_FUNC_BEGIN();
2130 glDeleteShader(shader); 1289 evgl_glDeleteShader(shader);
2131 EVGL_FUNC_END(); 1290 EVGLD_FUNC_END();
2132} 1291}
2133 1292
2134void 1293void
2135_evgld_glDeleteTextures(GLsizei n, const GLuint* textures) 1294_evgld_glDeleteTextures(GLsizei n, const GLuint* textures)
2136{ 1295{
2137 EVGL_FUNC_BEGIN(); 1296 EVGLD_FUNC_BEGIN();
2138 glDeleteTextures(n, textures); 1297 evgl_glDeleteTextures(n, textures);
2139 EVGL_FUNC_END(); 1298 EVGLD_FUNC_END();
2140} 1299}
2141 1300
2142void 1301void
2143_evgld_glDepthFunc(GLenum func) 1302_evgld_glDepthFunc(GLenum func)
2144{ 1303{
2145 EVGL_FUNC_BEGIN(); 1304 EVGLD_FUNC_BEGIN();
2146 glDepthFunc(func); 1305 evgl_glDepthFunc(func);
2147 EVGL_FUNC_END(); 1306 EVGLD_FUNC_END();
2148} 1307}
2149 1308
2150void 1309void
2151_evgld_glDepthMask(GLboolean flag) 1310_evgld_glDepthMask(GLboolean flag)
2152{ 1311{
2153 EVGL_FUNC_BEGIN(); 1312 EVGLD_FUNC_BEGIN();
2154 glDepthMask(flag); 1313 evgl_glDepthMask(flag);
2155 EVGL_FUNC_END(); 1314 EVGLD_FUNC_END();
2156} 1315}
2157 1316
2158void 1317void
2159_evgld_glDepthRangef(GLclampf zNear, GLclampf zFar) 1318_evgld_glDepthRangef(GLclampf zNear, GLclampf zFar)
2160{ 1319{
2161 EVGL_FUNC_BEGIN(); 1320 EVGLD_FUNC_BEGIN();
2162 1321 evgl_glDepthRangef(zNear, zFar);
2163 _evgl_glDepthRangef(zNear, zFar); 1322 EVGLD_FUNC_END();
2164
2165 EVGL_FUNC_END();
2166} 1323}
2167 1324
2168void 1325void
2169_evgld_glDetachShader(GLuint program, GLuint shader) 1326_evgld_glDetachShader(GLuint program, GLuint shader)
2170{ 1327{
2171 EVGL_FUNC_BEGIN(); 1328 EVGLD_FUNC_BEGIN();
2172 glDetachShader(program, shader); 1329 evgl_glDetachShader(program, shader);
2173 EVGL_FUNC_END(); 1330 EVGLD_FUNC_END();
2174} 1331}
2175 1332
2176void 1333void
2177_evgld_glDisableVertexAttribArray(GLuint idx) 1334_evgld_glDisableVertexAttribArray(GLuint idx)
2178{ 1335{
2179 EVGL_FUNC_BEGIN(); 1336 EVGLD_FUNC_BEGIN();
2180 glDisableVertexAttribArray(idx); 1337 evgl_glDisableVertexAttribArray(idx);
2181 EVGL_FUNC_END(); 1338 EVGLD_FUNC_END();
2182} 1339}
2183 1340
2184void 1341void
2185_evgld_glDrawArrays(GLenum mode, GLint first, GLsizei count) 1342_evgld_glDrawArrays(GLenum mode, GLint first, GLsizei count)
2186{ 1343{
2187 EVGL_FUNC_BEGIN(); 1344 EVGLD_FUNC_BEGIN();
2188 glDrawArrays(mode, first, count); 1345 evgl_glDrawArrays(mode, first, count);
2189 EVGL_FUNC_END(); 1346 EVGLD_FUNC_END();
2190} 1347}
2191 1348
2192void 1349void
2193_evgld_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) 1350_evgld_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
2194{ 1351{
2195 EVGL_FUNC_BEGIN(); 1352 EVGLD_FUNC_BEGIN();
2196 glDrawElements(mode, count, type, indices); 1353 evgl_glDrawElements(mode, count, type, indices);
2197 EVGL_FUNC_END(); 1354 EVGLD_FUNC_END();
2198} 1355}
2199 1356
2200void 1357void
2201_evgld_glEnableVertexAttribArray(GLuint idx) 1358_evgld_glEnableVertexAttribArray(GLuint idx)
2202{ 1359{
2203 EVGL_FUNC_BEGIN(); 1360 EVGLD_FUNC_BEGIN();
2204 glEnableVertexAttribArray(idx); 1361 evgl_glEnableVertexAttribArray(idx);
2205 EVGL_FUNC_END(); 1362 EVGLD_FUNC_END();
2206} 1363}
2207 1364
2208void 1365void
2209_evgld_glFinish(void) 1366_evgld_glFinish(void)
2210{ 1367{
2211 EVGL_FUNC_BEGIN(); 1368 EVGLD_FUNC_BEGIN();
2212 glFinish(); 1369 evgl_glFinish();
2213 EVGL_FUNC_END(); 1370 EVGLD_FUNC_END();
2214} 1371}
2215 1372
2216void 1373void
2217_evgld_glFlush(void) 1374_evgld_glFlush(void)
2218{ 1375{
2219 EVGL_FUNC_BEGIN(); 1376 EVGLD_FUNC_BEGIN();
2220 glFlush(); 1377 evgl_glFlush();
2221 EVGL_FUNC_END(); 1378 EVGLD_FUNC_END();
2222} 1379}
2223 1380
2224void 1381void
2225_evgld_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) 1382_evgld_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
2226{ 1383{
2227 EVGL_FUNC_BEGIN(); 1384 EVGLD_FUNC_BEGIN();
2228 glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); 1385 evgl_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
2229 EVGL_FUNC_END(); 1386 EVGLD_FUNC_END();
2230} 1387}
2231 1388
2232void 1389void
2233_evgld_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) 1390_evgld_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
2234{ 1391{
2235 EVGL_FUNC_BEGIN(); 1392 EVGLD_FUNC_BEGIN();
2236 glFramebufferTexture2D(target, attachment, textarget, texture, level); 1393 evgl_glFramebufferTexture2D(target, attachment, textarget, texture, level);
2237 EVGL_FUNC_END(); 1394 EVGLD_FUNC_END();
2238} 1395}
2239 1396
2240void 1397void
2241_evgld_glFrontFace(GLenum mode) 1398_evgld_glFrontFace(GLenum mode)
2242{ 1399{
2243 EVGL_FUNC_BEGIN(); 1400 EVGLD_FUNC_BEGIN();
2244 glFrontFace(mode); 1401 evgl_glFrontFace(mode);
2245 EVGL_FUNC_END(); 1402 EVGLD_FUNC_END();
2246} 1403}
2247 1404
2248void 1405void
2249_evgld_glGetVertexAttribfv(GLuint idx, GLenum pname, GLfloat* params) 1406_evgld_glGetVertexAttribfv(GLuint idx, GLenum pname, GLfloat* params)
2250{ 1407{
2251 EVGL_FUNC_BEGIN(); 1408 EVGLD_FUNC_BEGIN();
2252 glGetVertexAttribfv(idx, pname, params); 1409 evgl_glGetVertexAttribfv(idx, pname, params);
2253 1410 EVGLD_FUNC_END();
2254 EVGL_FUNC_END();
2255} 1411}
2256 1412
2257void 1413void
2258_evgld_glGetVertexAttribiv(GLuint idx, GLenum pname, GLint* params) 1414_evgld_glGetVertexAttribiv(GLuint idx, GLenum pname, GLint* params)
2259{ 1415{
2260 EVGL_FUNC_BEGIN(); 1416 EVGLD_FUNC_BEGIN();
2261 glGetVertexAttribiv(idx, pname, params); 1417 evgl_glGetVertexAttribiv(idx, pname, params);
2262 1418 EVGLD_FUNC_END();
2263 EVGL_FUNC_END();
2264} 1419}
2265 1420
2266void 1421void
2267_evgld_glGetVertexAttribPointerv(GLuint idx, GLenum pname, void** pointer) 1422_evgld_glGetVertexAttribPointerv(GLuint idx, GLenum pname, void** pointer)
2268{ 1423{
2269 EVGL_FUNC_BEGIN(); 1424 EVGLD_FUNC_BEGIN();
2270 glGetVertexAttribPointerv(idx, pname, pointer); 1425 evgl_glGetVertexAttribPointerv(idx, pname, pointer);
2271 1426 EVGLD_FUNC_END();
2272
2273 EVGL_FUNC_END();
2274} 1427}
2275 1428
2276void 1429void
2277_evgld_glHint(GLenum target, GLenum mode) 1430_evgld_glHint(GLenum target, GLenum mode)
2278{ 1431{
2279 EVGL_FUNC_BEGIN(); 1432 EVGLD_FUNC_BEGIN();
2280 glHint(target, mode); 1433 evgl_glHint(target, mode);
2281 EVGL_FUNC_END(); 1434 EVGLD_FUNC_END();
2282} 1435}
2283 1436
2284void 1437void
2285_evgld_glGenBuffers(GLsizei n, GLuint* buffers) 1438_evgld_glGenBuffers(GLsizei n, GLuint* buffers)
2286{ 1439{
2287 EVGL_FUNC_BEGIN(); 1440 EVGLD_FUNC_BEGIN();
2288 glGenBuffers(n, buffers); 1441 evgl_glGenBuffers(n, buffers);
2289 EVGL_FUNC_END(); 1442 EVGLD_FUNC_END();
2290} 1443}
2291 1444
2292void 1445void
2293_evgld_glGenerateMipmap(GLenum target) 1446_evgld_glGenerateMipmap(GLenum target)
2294{ 1447{
2295 EVGL_FUNC_BEGIN(); 1448 EVGLD_FUNC_BEGIN();
2296 glGenerateMipmap(target); 1449 evgl_glGenerateMipmap(target);
2297 EVGL_FUNC_END(); 1450 EVGLD_FUNC_END();
2298} 1451}
2299 1452
2300void 1453void
2301_evgld_glGenFramebuffers(GLsizei n, GLuint* framebuffers) 1454_evgld_glGenFramebuffers(GLsizei n, GLuint* framebuffers)
2302{ 1455{
2303 EVGL_FUNC_BEGIN(); 1456 EVGLD_FUNC_BEGIN();
2304 glGenFramebuffers(n, framebuffers); 1457 evgl_glGenFramebuffers(n, framebuffers);
2305 EVGL_FUNC_END(); 1458 EVGLD_FUNC_END();
2306} 1459}
2307 1460
2308void 1461void
2309_evgld_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) 1462_evgld_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
2310{ 1463{
2311 EVGL_FUNC_BEGIN(); 1464 EVGLD_FUNC_BEGIN();
2312 glGenRenderbuffers(n, renderbuffers); 1465 evgl_glGenRenderbuffers(n, renderbuffers);
2313 EVGL_FUNC_END(); 1466 EVGLD_FUNC_END();
2314} 1467}
2315 1468
2316void 1469void
2317_evgld_glGenTextures(GLsizei n, GLuint* textures) 1470_evgld_glGenTextures(GLsizei n, GLuint* textures)
2318{ 1471{
2319 EVGL_FUNC_BEGIN(); 1472 EVGLD_FUNC_BEGIN();
2320 glGenTextures(n, textures); 1473 evgl_glGenTextures(n, textures);
2321 EVGL_FUNC_END(); 1474 EVGLD_FUNC_END();
2322} 1475}
2323 1476
2324void 1477void
2325_evgld_glGetActiveAttrib(GLuint program, GLuint idx, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) 1478_evgld_glGetActiveAttrib(GLuint program, GLuint idx, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
2326{ 1479{
2327 EVGL_FUNC_BEGIN(); 1480 EVGLD_FUNC_BEGIN();
2328 glGetActiveAttrib(program, idx, bufsize, length, size, type, name); 1481 evgl_glGetActiveAttrib(program, idx, bufsize, length, size, type, name);
2329 EVGL_FUNC_END(); 1482 EVGLD_FUNC_END();
2330} 1483}
2331 1484
2332void 1485void
2333_evgld_glGetActiveUniform(GLuint program, GLuint idx, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) 1486_evgld_glGetActiveUniform(GLuint program, GLuint idx, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
2334{ 1487{
2335 EVGL_FUNC_BEGIN(); 1488 EVGLD_FUNC_BEGIN();
2336 glGetActiveUniform(program, idx, bufsize, length, size, type, name); 1489 evgl_glGetActiveUniform(program, idx, bufsize, length, size, type, name);
2337 EVGL_FUNC_END(); 1490 EVGLD_FUNC_END();
2338} 1491}
2339 1492
2340void 1493void
2341_evgld_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) 1494_evgld_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
2342{ 1495{
2343 EVGL_FUNC_BEGIN(); 1496 EVGLD_FUNC_BEGIN();
2344 glGetAttachedShaders(program, maxcount, count, shaders); 1497 evgl_glGetAttachedShaders(program, maxcount, count, shaders);
2345 EVGL_FUNC_END(); 1498 EVGLD_FUNC_END();
2346} 1499}
2347 1500
2348int 1501int
2349_evgld_glGetAttribLocation(GLuint program, const char* name) 1502_evgld_glGetAttribLocation(GLuint program, const char* name)
2350{ 1503{
2351 int ret = _EVGL_INT_INIT_VALUE; 1504 int ret = _EVGL_INT_INIT_VALUE;
2352 EVGL_FUNC_BEGIN(); 1505 EVGLD_FUNC_BEGIN();
2353 ret = glGetAttribLocation(program, name); 1506 ret = evgl_glGetAttribLocation(program, name);
2354 EVGL_FUNC_END(); 1507 EVGLD_FUNC_END();
2355 return ret; 1508 return ret;
2356} 1509}
2357 1510
2358void 1511void
2359_evgld_glGetBooleanv(GLenum pname, GLboolean* params) 1512_evgld_glGetBooleanv(GLenum pname, GLboolean* params)
2360{ 1513{
2361 EVGL_FUNC_BEGIN(); 1514 EVGLD_FUNC_BEGIN();
2362 glGetBooleanv(pname, params); 1515 evgl_glGetBooleanv(pname, params);
2363 EVGL_FUNC_END(); 1516 EVGLD_FUNC_END();
2364} 1517}
2365 1518
2366void 1519void
2367_evgld_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) 1520_evgld_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
2368{ 1521{
2369 EVGL_FUNC_BEGIN(); 1522 EVGLD_FUNC_BEGIN();
2370 glGetBufferParameteriv(target, pname, params); 1523 evgl_glGetBufferParameteriv(target, pname, params);
2371 EVGL_FUNC_END(); 1524 EVGLD_FUNC_END();
2372} 1525}
2373 1526
2374GLenum 1527GLenum
@@ -2376,84 +1529,82 @@ _evgld_glGetError(void)
2376{ 1529{
2377 GLenum ret = GL_NONE; 1530 GLenum ret = GL_NONE;
2378 1531
2379 EVGL_FUNC_BEGIN(); 1532 EVGLD_FUNC_BEGIN();
2380 ret = glGetError(); 1533 ret = evgl_glGetError();
2381 EVGL_FUNC_END(); 1534 EVGLD_FUNC_END();
2382 return ret; 1535 return ret;
2383} 1536}
2384 1537
2385void 1538void
2386_evgld_glGetFloatv(GLenum pname, GLfloat* params) 1539_evgld_glGetFloatv(GLenum pname, GLfloat* params)
2387{ 1540{
2388 EVGL_FUNC_BEGIN(); 1541 EVGLD_FUNC_BEGIN();
2389 glGetFloatv(pname, params); 1542 evgl_glGetFloatv(pname, params);
2390 EVGL_FUNC_END(); 1543 EVGLD_FUNC_END();
2391} 1544}
2392 1545
2393void 1546void
2394_evgld_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) 1547_evgld_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
2395{ 1548{
2396 EVGL_FUNC_BEGIN(); 1549 EVGLD_FUNC_BEGIN();
2397 glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); 1550 evgl_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
2398 EVGL_FUNC_END(); 1551 EVGLD_FUNC_END();
2399} 1552}
2400 1553
2401void 1554void
2402_evgld_glGetProgramiv(GLuint program, GLenum pname, GLint* params) 1555_evgld_glGetProgramiv(GLuint program, GLenum pname, GLint* params)
2403{ 1556{
2404 EVGL_FUNC_BEGIN(); 1557 EVGLD_FUNC_BEGIN();
2405 glGetProgramiv(program, pname, params); 1558 evgl_glGetProgramiv(program, pname, params);
2406 EVGL_FUNC_END(); 1559 EVGLD_FUNC_END();
2407} 1560}
2408 1561
2409void 1562void
2410_evgld_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) 1563_evgld_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
2411{ 1564{
2412 EVGL_FUNC_BEGIN(); 1565 EVGLD_FUNC_BEGIN();
2413 glGetProgramInfoLog(program, bufsize, length, infolog); 1566 evgl_glGetProgramInfoLog(program, bufsize, length, infolog);
2414 EVGL_FUNC_END(); 1567 EVGLD_FUNC_END();
2415} 1568}
2416 1569
2417void 1570void
2418_evgld_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) 1571_evgld_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
2419{ 1572{
2420 EVGL_FUNC_BEGIN(); 1573 EVGLD_FUNC_BEGIN();
2421 glGetRenderbufferParameteriv(target, pname, params); 1574 evgl_glGetRenderbufferParameteriv(target, pname, params);
2422 EVGL_FUNC_END(); 1575 EVGLD_FUNC_END();
2423} 1576}
2424 1577
2425void 1578void
2426_evgld_glGetShaderiv(GLuint shader, GLenum pname, GLint* params) 1579_evgld_glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
2427{ 1580{
2428 EVGL_FUNC_BEGIN(); 1581 EVGLD_FUNC_BEGIN();
2429 glGetShaderiv(shader, pname, params); 1582 evgl_glGetShaderiv(shader, pname, params);
2430 EVGL_FUNC_END(); 1583 EVGLD_FUNC_END();
2431} 1584}
2432 1585
2433void 1586void
2434_evgld_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) 1587_evgld_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
2435{ 1588{
2436 EVGL_FUNC_BEGIN(); 1589 EVGLD_FUNC_BEGIN();
2437 glGetShaderInfoLog(shader, bufsize, length, infolog); 1590 evgl_glGetShaderInfoLog(shader, bufsize, length, infolog);
2438 EVGL_FUNC_END(); 1591 EVGLD_FUNC_END();
2439} 1592}
2440 1593
2441void 1594void
2442_evgld_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) 1595_evgld_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
2443{ 1596{
2444 EVGL_FUNC_BEGIN(); 1597 EVGLD_FUNC_BEGIN();
2445 1598 evgl_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
2446 _evgl_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision); 1599 EVGLD_FUNC_END();
2447
2448 EVGL_FUNC_END();
2449} 1600}
2450 1601
2451void 1602void
2452_evgld_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) 1603_evgld_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
2453{ 1604{
2454 EVGL_FUNC_BEGIN(); 1605 EVGLD_FUNC_BEGIN();
2455 glGetShaderSource(shader, bufsize, length, source); 1606 evgl_glGetShaderSource(shader, bufsize, length, source);
2456 EVGL_FUNC_END(); 1607 EVGLD_FUNC_END();
2457} 1608}
2458 1609
2459const GLubyte * 1610const GLubyte *
@@ -2461,51 +1612,51 @@ _evgld_glGetString(GLenum name)
2461{ 1612{
2462 const GLubyte *ret = NULL; 1613 const GLubyte *ret = NULL;
2463 1614
2464 EVGL_FUNC_BEGIN(); 1615 EVGLD_FUNC_BEGIN();
2465 ret = _evgl_glGetString(name); 1616 ret = evgl_glGetString(name);
2466 EVGL_FUNC_END(); 1617 EVGLD_FUNC_END();
2467 return ret; 1618 return ret;
2468} 1619}
2469 1620
2470void 1621void
2471_evgld_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) 1622_evgld_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
2472{ 1623{
2473 EVGL_FUNC_BEGIN(); 1624 EVGLD_FUNC_BEGIN();
2474 glGetTexParameterfv(target, pname, params); 1625 evgl_glGetTexParameterfv(target, pname, params);
2475 EVGL_FUNC_END(); 1626 EVGLD_FUNC_END();
2476} 1627}
2477 1628
2478void 1629void
2479_evgld_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params) 1630_evgld_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
2480{ 1631{
2481 EVGL_FUNC_BEGIN(); 1632 EVGLD_FUNC_BEGIN();
2482 glGetTexParameteriv(target, pname, params); 1633 evgl_glGetTexParameteriv(target, pname, params);
2483 EVGL_FUNC_END(); 1634 EVGLD_FUNC_END();
2484} 1635}
2485 1636
2486void 1637void
2487_evgld_glGetUniformfv(GLuint program, GLint location, GLfloat* params) 1638_evgld_glGetUniformfv(GLuint program, GLint location, GLfloat* params)
2488{ 1639{
2489 EVGL_FUNC_BEGIN(); 1640 EVGLD_FUNC_BEGIN();
2490 glGetUniformfv(program, location, params); 1641 evgl_glGetUniformfv(program, location, params);
2491 EVGL_FUNC_END(); 1642 EVGLD_FUNC_END();
2492} 1643}
2493 1644
2494void 1645void
2495_evgld_glGetUniformiv(GLuint program, GLint location, GLint* params) 1646_evgld_glGetUniformiv(GLuint program, GLint location, GLint* params)
2496{ 1647{
2497 EVGL_FUNC_BEGIN(); 1648 EVGLD_FUNC_BEGIN();
2498 glGetUniformiv(program, location, params); 1649 evgl_glGetUniformiv(program, location, params);
2499 EVGL_FUNC_END(); 1650 EVGLD_FUNC_END();
2500} 1651}
2501int 1652int
2502_evgld_glGetUniformLocation(GLuint program, const char* name) 1653_evgld_glGetUniformLocation(GLuint program, const char* name)
2503{ 1654{
2504 int ret = _EVGL_INT_INIT_VALUE; 1655 int ret = _EVGL_INT_INIT_VALUE;
2505 1656
2506 EVGL_FUNC_BEGIN(); 1657 EVGLD_FUNC_BEGIN();
2507 ret = glGetUniformLocation(program, name); 1658 ret = evgl_glGetUniformLocation(program, name);
2508 EVGL_FUNC_END(); 1659 EVGLD_FUNC_END();
2509 return ret; 1660 return ret;
2510} 1661}
2511 1662
@@ -2514,9 +1665,9 @@ _evgld_glIsBuffer(GLuint buffer)
2514{ 1665{
2515 GLboolean ret = GL_FALSE; 1666 GLboolean ret = GL_FALSE;
2516 1667
2517 EVGL_FUNC_BEGIN(); 1668 EVGLD_FUNC_BEGIN();
2518 ret = glIsBuffer(buffer); 1669 ret = evgl_glIsBuffer(buffer);
2519 EVGL_FUNC_END(); 1670 EVGLD_FUNC_END();
2520 return ret; 1671 return ret;
2521} 1672}
2522 1673
@@ -2525,9 +1676,9 @@ _evgld_glIsEnabled(GLenum cap)
2525{ 1676{
2526 GLboolean ret = GL_FALSE; 1677 GLboolean ret = GL_FALSE;
2527 1678
2528 EVGL_FUNC_BEGIN(); 1679 EVGLD_FUNC_BEGIN();
2529 ret = glIsEnabled(cap); 1680 ret = evgl_glIsEnabled(cap);
2530 EVGL_FUNC_END(); 1681 EVGLD_FUNC_END();
2531 return ret; 1682 return ret;
2532} 1683}
2533 1684
@@ -2536,9 +1687,9 @@ _evgld_glIsFramebuffer(GLuint framebuffer)
2536{ 1687{
2537 GLboolean ret = GL_FALSE; 1688 GLboolean ret = GL_FALSE;
2538 1689
2539 EVGL_FUNC_BEGIN(); 1690 EVGLD_FUNC_BEGIN();
2540 ret = glIsFramebuffer(framebuffer); 1691 ret = evgl_glIsFramebuffer(framebuffer);
2541 EVGL_FUNC_END(); 1692 EVGLD_FUNC_END();
2542 return ret; 1693 return ret;
2543} 1694}
2544 1695
@@ -2546,9 +1697,9 @@ GLboolean
2546_evgld_glIsProgram(GLuint program) 1697_evgld_glIsProgram(GLuint program)
2547{ 1698{
2548 GLboolean ret; 1699 GLboolean ret;
2549 EVGL_FUNC_BEGIN(); 1700 EVGLD_FUNC_BEGIN();
2550 ret = glIsProgram(program); 1701 ret = evgl_glIsProgram(program);
2551 EVGL_FUNC_END(); 1702 EVGLD_FUNC_END();
2552 return ret; 1703 return ret;
2553} 1704}
2554 1705
@@ -2556,9 +1707,9 @@ GLboolean
2556_evgld_glIsRenderbuffer(GLuint renderbuffer) 1707_evgld_glIsRenderbuffer(GLuint renderbuffer)
2557{ 1708{
2558 GLboolean ret; 1709 GLboolean ret;
2559 EVGL_FUNC_BEGIN(); 1710 EVGLD_FUNC_BEGIN();
2560 ret = glIsRenderbuffer(renderbuffer); 1711 ret = evgl_glIsRenderbuffer(renderbuffer);
2561 EVGL_FUNC_END(); 1712 EVGLD_FUNC_END();
2562 return ret; 1713 return ret;
2563} 1714}
2564 1715
@@ -2566,9 +1717,9 @@ GLboolean
2566_evgld_glIsShader(GLuint shader) 1717_evgld_glIsShader(GLuint shader)
2567{ 1718{
2568 GLboolean ret; 1719 GLboolean ret;
2569 EVGL_FUNC_BEGIN(); 1720 EVGLD_FUNC_BEGIN();
2570 ret = glIsShader(shader); 1721 ret = evgl_glIsShader(shader);
2571 EVGL_FUNC_END(); 1722 EVGLD_FUNC_END();
2572 return ret; 1723 return ret;
2573} 1724}
2574 1725
@@ -2576,426 +1727,418 @@ GLboolean
2576_evgld_glIsTexture(GLuint texture) 1727_evgld_glIsTexture(GLuint texture)
2577{ 1728{
2578 GLboolean ret; 1729 GLboolean ret;
2579 EVGL_FUNC_BEGIN(); 1730 EVGLD_FUNC_BEGIN();
2580 ret = glIsTexture(texture); 1731 ret = evgl_glIsTexture(texture);
2581 EVGL_FUNC_END(); 1732 EVGLD_FUNC_END();
2582 return ret; 1733 return ret;
2583} 1734}
2584 1735
2585void 1736void
2586_evgld_glLineWidth(GLfloat width) 1737_evgld_glLineWidth(GLfloat width)
2587{ 1738{
2588 EVGL_FUNC_BEGIN(); 1739 EVGLD_FUNC_BEGIN();
2589 glLineWidth(width); 1740 evgl_glLineWidth(width);
2590 EVGL_FUNC_END(); 1741 EVGLD_FUNC_END();
2591} 1742}
2592 1743
2593void 1744void
2594_evgld_glLinkProgram(GLuint program) 1745_evgld_glLinkProgram(GLuint program)
2595{ 1746{
2596 EVGL_FUNC_BEGIN(); 1747 EVGLD_FUNC_BEGIN();
2597 glLinkProgram(program); 1748 evgl_glLinkProgram(program);
2598 EVGL_FUNC_END(); 1749 EVGLD_FUNC_END();
2599} 1750}
2600 1751
2601void 1752void
2602_evgld_glPixelStorei(GLenum pname, GLint param) 1753_evgld_glPixelStorei(GLenum pname, GLint param)
2603{ 1754{
2604 EVGL_FUNC_BEGIN(); 1755 EVGLD_FUNC_BEGIN();
2605 glPixelStorei(pname, param); 1756 evgl_glPixelStorei(pname, param);
2606 EVGL_FUNC_END(); 1757 EVGLD_FUNC_END();
2607} 1758}
2608 1759
2609void 1760void
2610_evgld_glPolygonOffset(GLfloat factor, GLfloat units) 1761_evgld_glPolygonOffset(GLfloat factor, GLfloat units)
2611{ 1762{
2612 EVGL_FUNC_BEGIN(); 1763 EVGLD_FUNC_BEGIN();
2613 glPolygonOffset(factor, units); 1764 evgl_glPolygonOffset(factor, units);
2614 EVGL_FUNC_END(); 1765 EVGLD_FUNC_END();
2615} 1766}
2616 1767
2617void 1768void
2618_evgld_glReleaseShaderCompiler(void) 1769_evgld_glReleaseShaderCompiler(void)
2619{ 1770{
2620 EVGL_FUNC_BEGIN(); 1771 EVGLD_FUNC_BEGIN();
2621 1772 evgl_glReleaseShaderCompiler();
2622 _evgl_glReleaseShaderCompiler(); 1773 EVGLD_FUNC_END();
2623
2624 EVGL_FUNC_END();
2625} 1774}
2626 1775
2627void 1776void
2628_evgld_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) 1777_evgld_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
2629{ 1778{
2630 EVGL_FUNC_BEGIN(); 1779 EVGLD_FUNC_BEGIN();
2631 glRenderbufferStorage(target, internalformat, width, height); 1780 evgl_glRenderbufferStorage(target, internalformat, width, height);
2632 EVGL_FUNC_END(); 1781 EVGLD_FUNC_END();
2633} 1782}
2634 1783
2635void 1784void
2636_evgld_glSampleCoverage(GLclampf value, GLboolean invert) 1785_evgld_glSampleCoverage(GLclampf value, GLboolean invert)
2637{ 1786{
2638 EVGL_FUNC_BEGIN(); 1787 EVGLD_FUNC_BEGIN();
2639 glSampleCoverage(value, invert); 1788 evgl_glSampleCoverage(value, invert);
2640 EVGL_FUNC_END(); 1789 EVGLD_FUNC_END();
2641} 1790}
2642 1791
2643void 1792void
2644_evgld_glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) 1793_evgld_glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
2645{ 1794{
2646 EVGL_FUNC_BEGIN(); 1795 EVGLD_FUNC_BEGIN();
2647 1796 evgl_glShaderBinary(n, shaders, binaryformat, binary, length);
2648 _evgl_glShaderBinary(n, shaders, binaryformat, binary, length); 1797 EVGLD_FUNC_END();
2649
2650 EVGL_FUNC_END();
2651} 1798}
2652 1799
2653void 1800void
2654_evgld_glShaderSource(GLuint shader, GLsizei count, const char* const * string, const GLint* length) 1801_evgld_glShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length)
2655{ 1802{
2656 EVGL_FUNC_BEGIN(); 1803 EVGLD_FUNC_BEGIN();
2657#ifdef GL_GLES 1804 evgl_glShaderSource(shader, count, (const GLchar* const*) string, length);
2658 glShaderSource(shader, count, (const GLchar * const *) string, length); 1805 EVGLD_FUNC_END();
2659#else
2660 glShaderSource(shader, count, (const GLchar **) string, length);
2661#endif
2662 EVGL_FUNC_END();
2663} 1806}
2664 1807
2665void 1808void
2666_evgld_glStencilFunc(GLenum func, GLint ref, GLuint mask) 1809_evgld_glStencilFunc(GLenum func, GLint ref, GLuint mask)
2667{ 1810{
2668 EVGL_FUNC_BEGIN(); 1811 EVGLD_FUNC_BEGIN();
2669 glStencilFunc(func, ref, mask); 1812 evgl_glStencilFunc(func, ref, mask);
2670 EVGL_FUNC_END(); 1813 EVGLD_FUNC_END();
2671} 1814}
2672 1815
2673void 1816void
2674_evgld_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) 1817_evgld_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
2675{ 1818{
2676 EVGL_FUNC_BEGIN(); 1819 EVGLD_FUNC_BEGIN();
2677 glStencilFuncSeparate(face, func, ref, mask); 1820 evgl_glStencilFuncSeparate(face, func, ref, mask);
2678 EVGL_FUNC_END(); 1821 EVGLD_FUNC_END();
2679} 1822}
2680 1823
2681void 1824void
2682_evgld_glStencilMask(GLuint mask) 1825_evgld_glStencilMask(GLuint mask)
2683{ 1826{
2684 EVGL_FUNC_BEGIN(); 1827 EVGLD_FUNC_BEGIN();
2685 glStencilMask(mask); 1828 evgl_glStencilMask(mask);
2686 EVGL_FUNC_END(); 1829 EVGLD_FUNC_END();
2687} 1830}
2688 1831
2689void 1832void
2690_evgld_glStencilMaskSeparate(GLenum face, GLuint mask) 1833_evgld_glStencilMaskSeparate(GLenum face, GLuint mask)
2691{ 1834{
2692 EVGL_FUNC_BEGIN(); 1835 EVGLD_FUNC_BEGIN();
2693 glStencilMaskSeparate(face, mask); 1836 evgl_glStencilMaskSeparate(face, mask);
2694 EVGL_FUNC_END(); 1837 EVGLD_FUNC_END();
2695} 1838}
2696 1839
2697void 1840void
2698_evgld_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) 1841_evgld_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
2699{ 1842{
2700 EVGL_FUNC_BEGIN(); 1843 EVGLD_FUNC_BEGIN();
2701 glStencilOp(fail, zfail, zpass); 1844 evgl_glStencilOp(fail, zfail, zpass);
2702 EVGL_FUNC_END(); 1845 EVGLD_FUNC_END();
2703} 1846}
2704 1847
2705void 1848void
2706_evgld_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) 1849_evgld_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
2707{ 1850{
2708 EVGL_FUNC_BEGIN(); 1851 EVGLD_FUNC_BEGIN();
2709 glStencilOpSeparate(face, fail, zfail, zpass); 1852 evgl_glStencilOpSeparate(face, fail, zfail, zpass);
2710 EVGL_FUNC_END(); 1853 EVGLD_FUNC_END();
2711} 1854}
2712 1855
2713void 1856void
2714_evgld_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) 1857_evgld_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
2715{ 1858{
2716 EVGL_FUNC_BEGIN(); 1859 EVGLD_FUNC_BEGIN();
2717 glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); 1860 evgl_glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
2718 EVGL_FUNC_END(); 1861 EVGLD_FUNC_END();
2719} 1862}
2720 1863
2721void 1864void
2722_evgld_glTexParameterf(GLenum target, GLenum pname, GLfloat param) 1865_evgld_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
2723{ 1866{
2724 EVGL_FUNC_BEGIN(); 1867 EVGLD_FUNC_BEGIN();
2725 glTexParameterf(target, pname, param); 1868 evgl_glTexParameterf(target, pname, param);
2726 EVGL_FUNC_END(); 1869 EVGLD_FUNC_END();
2727} 1870}
2728 1871
2729void 1872void
2730_evgld_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) 1873_evgld_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
2731{ 1874{
2732 EVGL_FUNC_BEGIN(); 1875 EVGLD_FUNC_BEGIN();
2733 glTexParameterfv(target, pname, params); 1876 evgl_glTexParameterfv(target, pname, params);
2734 EVGL_FUNC_END(); 1877 EVGLD_FUNC_END();
2735} 1878}
2736 1879
2737void 1880void
2738_evgld_glTexParameteri(GLenum target, GLenum pname, GLint param) 1881_evgld_glTexParameteri(GLenum target, GLenum pname, GLint param)
2739{ 1882{
2740 EVGL_FUNC_BEGIN(); 1883 EVGLD_FUNC_BEGIN();
2741 glTexParameteri(target, pname, param); 1884 evgl_glTexParameteri(target, pname, param);
2742 EVGL_FUNC_END(); 1885 EVGLD_FUNC_END();
2743} 1886}
2744 1887
2745void 1888void
2746_evgld_glTexParameteriv(GLenum target, GLenum pname, const GLint* params) 1889_evgld_glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
2747{ 1890{
2748 EVGL_FUNC_BEGIN(); 1891 EVGLD_FUNC_BEGIN();
2749 glTexParameteriv(target, pname, params); 1892 evgl_glTexParameteriv(target, pname, params);
2750 EVGL_FUNC_END(); 1893 EVGLD_FUNC_END();
2751} 1894}
2752 1895
2753void 1896void
2754_evgld_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) 1897_evgld_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
2755{ 1898{
2756 EVGL_FUNC_BEGIN(); 1899 EVGLD_FUNC_BEGIN();
2757 glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); 1900 evgl_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
2758 EVGL_FUNC_END(); 1901 EVGLD_FUNC_END();
2759} 1902}
2760 1903
2761void 1904void
2762_evgld_glUniform1f(GLint location, GLfloat x) 1905_evgld_glUniform1f(GLint location, GLfloat x)
2763{ 1906{
2764 EVGL_FUNC_BEGIN(); 1907 EVGLD_FUNC_BEGIN();
2765 glUniform1f(location, x); 1908 evgl_glUniform1f(location, x);
2766 EVGL_FUNC_END(); 1909 EVGLD_FUNC_END();
2767} 1910}
2768 1911
2769void 1912void
2770_evgld_glUniform1fv(GLint location, GLsizei count, const GLfloat* v) 1913_evgld_glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
2771{ 1914{
2772 EVGL_FUNC_BEGIN(); 1915 EVGLD_FUNC_BEGIN();
2773 glUniform1fv(location, count, v); 1916 evgl_glUniform1fv(location, count, v);
2774 EVGL_FUNC_END(); 1917 EVGLD_FUNC_END();
2775} 1918}
2776 1919
2777void 1920void
2778_evgld_glUniform1i(GLint location, GLint x) 1921_evgld_glUniform1i(GLint location, GLint x)
2779{ 1922{
2780 EVGL_FUNC_BEGIN(); 1923 EVGLD_FUNC_BEGIN();
2781 glUniform1i(location, x); 1924 evgl_glUniform1i(location, x);
2782 EVGL_FUNC_END(); 1925 EVGLD_FUNC_END();
2783} 1926}
2784 1927
2785void 1928void
2786_evgld_glUniform1iv(GLint location, GLsizei count, const GLint* v) 1929_evgld_glUniform1iv(GLint location, GLsizei count, const GLint* v)
2787{ 1930{
2788 EVGL_FUNC_BEGIN(); 1931 EVGLD_FUNC_BEGIN();
2789 glUniform1iv(location, count, v); 1932 evgl_glUniform1iv(location, count, v);
2790 EVGL_FUNC_END(); 1933 EVGLD_FUNC_END();
2791} 1934}
2792 1935
2793void 1936void
2794_evgld_glUniform2f(GLint location, GLfloat x, GLfloat y) 1937_evgld_glUniform2f(GLint location, GLfloat x, GLfloat y)
2795{ 1938{
2796 EVGL_FUNC_BEGIN(); 1939 EVGLD_FUNC_BEGIN();
2797 glUniform2f(location, x, y); 1940 evgl_glUniform2f(location, x, y);
2798 EVGL_FUNC_END(); 1941 EVGLD_FUNC_END();
2799} 1942}
2800 1943
2801void 1944void
2802_evgld_glUniform2fv(GLint location, GLsizei count, const GLfloat* v) 1945_evgld_glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
2803{ 1946{
2804 EVGL_FUNC_BEGIN(); 1947 EVGLD_FUNC_BEGIN();
2805 glUniform2fv(location, count, v); 1948 evgl_glUniform2fv(location, count, v);
2806 EVGL_FUNC_END(); 1949 EVGLD_FUNC_END();
2807} 1950}
2808 1951
2809void 1952void
2810_evgld_glUniform2i(GLint location, GLint x, GLint y) 1953_evgld_glUniform2i(GLint location, GLint x, GLint y)
2811{ 1954{
2812 EVGL_FUNC_BEGIN(); 1955 EVGLD_FUNC_BEGIN();
2813 glUniform2i(location, x, y); 1956 evgl_glUniform2i(location, x, y);
2814 EVGL_FUNC_END(); 1957 EVGLD_FUNC_END();
2815} 1958}
2816 1959
2817void 1960void
2818_evgld_glUniform2iv(GLint location, GLsizei count, const GLint* v) 1961_evgld_glUniform2iv(GLint location, GLsizei count, const GLint* v)
2819{ 1962{
2820 EVGL_FUNC_BEGIN(); 1963 EVGLD_FUNC_BEGIN();
2821 glUniform2iv(location, count, v); 1964 evgl_glUniform2iv(location, count, v);
2822 EVGL_FUNC_END(); 1965 EVGLD_FUNC_END();
2823} 1966}
2824 1967
2825void 1968void
2826_evgld_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) 1969_evgld_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
2827{ 1970{
2828 EVGL_FUNC_BEGIN(); 1971 EVGLD_FUNC_BEGIN();
2829 glUniform3f(location, x, y, z); 1972 evgl_glUniform3f(location, x, y, z);
2830 EVGL_FUNC_END(); 1973 EVGLD_FUNC_END();
2831} 1974}
2832 1975
2833void 1976void
2834_evgld_glUniform3fv(GLint location, GLsizei count, const GLfloat* v) 1977_evgld_glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
2835{ 1978{
2836 EVGL_FUNC_BEGIN(); 1979 EVGLD_FUNC_BEGIN();
2837 glUniform3fv(location, count, v); 1980 evgl_glUniform3fv(location, count, v);
2838 EVGL_FUNC_END(); 1981 EVGLD_FUNC_END();
2839} 1982}
2840 1983
2841void 1984void
2842_evgld_glUniform3i(GLint location, GLint x, GLint y, GLint z) 1985_evgld_glUniform3i(GLint location, GLint x, GLint y, GLint z)
2843{ 1986{
2844 EVGL_FUNC_BEGIN(); 1987 EVGLD_FUNC_BEGIN();
2845 glUniform3i(location, x, y, z); 1988 evgl_glUniform3i(location, x, y, z);
2846 EVGL_FUNC_END(); 1989 EVGLD_FUNC_END();
2847} 1990}
2848 1991
2849void 1992void
2850_evgld_glUniform3iv(GLint location, GLsizei count, const GLint* v) 1993_evgld_glUniform3iv(GLint location, GLsizei count, const GLint* v)
2851{ 1994{
2852 EVGL_FUNC_BEGIN(); 1995 EVGLD_FUNC_BEGIN();
2853 glUniform3iv(location, count, v); 1996 evgl_glUniform3iv(location, count, v);
2854 EVGL_FUNC_END(); 1997 EVGLD_FUNC_END();
2855} 1998}
2856 1999
2857void 2000void
2858_evgld_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) 2001_evgld_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2859{ 2002{
2860 EVGL_FUNC_BEGIN(); 2003 EVGLD_FUNC_BEGIN();
2861 glUniform4f(location, x, y, z, w); 2004 evgl_glUniform4f(location, x, y, z, w);
2862 EVGL_FUNC_END(); 2005 EVGLD_FUNC_END();
2863} 2006}
2864 2007
2865void 2008void
2866_evgld_glUniform4fv(GLint location, GLsizei count, const GLfloat* v) 2009_evgld_glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
2867{ 2010{
2868 EVGL_FUNC_BEGIN(); 2011 EVGLD_FUNC_BEGIN();
2869 glUniform4fv(location, count, v); 2012 evgl_glUniform4fv(location, count, v);
2870 EVGL_FUNC_END(); 2013 EVGLD_FUNC_END();
2871} 2014}
2872 2015
2873void 2016void
2874_evgld_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) 2017_evgld_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
2875{ 2018{
2876 EVGL_FUNC_BEGIN(); 2019 EVGLD_FUNC_BEGIN();
2877 glUniform4i(location, x, y, z, w); 2020 evgl_glUniform4i(location, x, y, z, w);
2878 EVGL_FUNC_END(); 2021 EVGLD_FUNC_END();
2879} 2022}
2880 2023
2881void 2024void
2882_evgld_glUniform4iv(GLint location, GLsizei count, const GLint* v) 2025_evgld_glUniform4iv(GLint location, GLsizei count, const GLint* v)
2883{ 2026{
2884 EVGL_FUNC_BEGIN(); 2027 EVGLD_FUNC_BEGIN();
2885 glUniform4iv(location, count, v); 2028 evgl_glUniform4iv(location, count, v);
2886 EVGL_FUNC_END(); 2029 EVGLD_FUNC_END();
2887} 2030}
2888 2031
2889void 2032void
2890_evgld_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) 2033_evgld_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2891{ 2034{
2892 EVGL_FUNC_BEGIN(); 2035 EVGLD_FUNC_BEGIN();
2893 glUniformMatrix2fv(location, count, transpose, value); 2036 evgl_glUniformMatrix2fv(location, count, transpose, value);
2894 EVGL_FUNC_END(); 2037 EVGLD_FUNC_END();
2895} 2038}
2896 2039
2897void 2040void
2898_evgld_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) 2041_evgld_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2899{ 2042{
2900 EVGL_FUNC_BEGIN(); 2043 EVGLD_FUNC_BEGIN();
2901 glUniformMatrix3fv(location, count, transpose, value); 2044 evgl_glUniformMatrix3fv(location, count, transpose, value);
2902 EVGL_FUNC_END(); 2045 EVGLD_FUNC_END();
2903} 2046}
2904 2047
2905void 2048void
2906_evgld_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) 2049_evgld_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2907{ 2050{
2908 EVGL_FUNC_BEGIN(); 2051 EVGLD_FUNC_BEGIN();
2909 glUniformMatrix4fv(location, count, transpose, value); 2052 evgl_glUniformMatrix4fv(location, count, transpose, value);
2910 EVGL_FUNC_END(); 2053 EVGLD_FUNC_END();
2911} 2054}
2912 2055
2913void 2056void
2914_evgld_glUseProgram(GLuint program) 2057_evgld_glUseProgram(GLuint program)
2915{ 2058{
2916 EVGL_FUNC_BEGIN(); 2059 EVGLD_FUNC_BEGIN();
2917 glUseProgram(program); 2060 evgl_glUseProgram(program);
2918 EVGL_FUNC_END(); 2061 EVGLD_FUNC_END();
2919} 2062}
2920 2063
2921void 2064void
2922_evgld_glValidateProgram(GLuint program) 2065_evgld_glValidateProgram(GLuint program)
2923{ 2066{
2924 EVGL_FUNC_BEGIN(); 2067 EVGLD_FUNC_BEGIN();
2925 glValidateProgram(program); 2068 evgl_glValidateProgram(program);
2926 EVGL_FUNC_END(); 2069 EVGLD_FUNC_END();
2927} 2070}
2928 2071
2929void 2072void
2930_evgld_glVertexAttrib1f(GLuint indx, GLfloat x) 2073_evgld_glVertexAttrib1f(GLuint indx, GLfloat x)
2931{ 2074{
2932 EVGL_FUNC_BEGIN(); 2075 EVGLD_FUNC_BEGIN();
2933 glVertexAttrib1f(indx, x); 2076 evgl_glVertexAttrib1f(indx, x);
2934 EVGL_FUNC_END(); 2077 EVGLD_FUNC_END();
2935} 2078}
2936 2079
2937void 2080void
2938_evgld_glVertexAttrib1fv(GLuint indx, const GLfloat* values) 2081_evgld_glVertexAttrib1fv(GLuint indx, const GLfloat* values)
2939{ 2082{
2940 EVGL_FUNC_BEGIN(); 2083 EVGLD_FUNC_BEGIN();
2941 glVertexAttrib1fv(indx, values); 2084 evgl_glVertexAttrib1fv(indx, values);
2942 EVGL_FUNC_END(); 2085 EVGLD_FUNC_END();
2943} 2086}
2944 2087
2945void 2088void
2946_evgld_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) 2089_evgld_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
2947{ 2090{
2948 EVGL_FUNC_BEGIN(); 2091 EVGLD_FUNC_BEGIN();
2949 glVertexAttrib2f(indx, x, y); 2092 evgl_glVertexAttrib2f(indx, x, y);
2950 EVGL_FUNC_END(); 2093 EVGLD_FUNC_END();
2951} 2094}
2952 2095
2953void 2096void
2954_evgld_glVertexAttrib2fv(GLuint indx, const GLfloat* values) 2097_evgld_glVertexAttrib2fv(GLuint indx, const GLfloat* values)
2955{ 2098{
2956 EVGL_FUNC_BEGIN(); 2099 EVGLD_FUNC_BEGIN();
2957 glVertexAttrib2fv(indx, values); 2100 evgl_glVertexAttrib2fv(indx, values);
2958 EVGL_FUNC_END(); 2101 EVGLD_FUNC_END();
2959} 2102}
2960 2103
2961void 2104void
2962_evgld_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) 2105_evgld_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
2963{ 2106{
2964 EVGL_FUNC_BEGIN(); 2107 EVGLD_FUNC_BEGIN();
2965 glVertexAttrib3f(indx, x, y, z); 2108 evgl_glVertexAttrib3f(indx, x, y, z);
2966 EVGL_FUNC_END(); 2109 EVGLD_FUNC_END();
2967} 2110}
2968 2111
2969void 2112void
2970_evgld_glVertexAttrib3fv(GLuint indx, const GLfloat* values) 2113_evgld_glVertexAttrib3fv(GLuint indx, const GLfloat* values)
2971{ 2114{
2972 EVGL_FUNC_BEGIN(); 2115 EVGLD_FUNC_BEGIN();
2973 glVertexAttrib3fv(indx, values); 2116 evgl_glVertexAttrib3fv(indx, values);
2974 EVGL_FUNC_END(); 2117 EVGLD_FUNC_END();
2975} 2118}
2976 2119
2977void 2120void
2978_evgld_glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) 2121_evgld_glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2979{ 2122{
2980 EVGL_FUNC_BEGIN(); 2123 EVGLD_FUNC_BEGIN();
2981 glVertexAttrib4f(indx, x, y, z, w); 2124 evgl_glVertexAttrib4f(indx, x, y, z, w);
2982 EVGL_FUNC_END(); 2125 EVGLD_FUNC_END();
2983} 2126}
2984 2127
2985void 2128void
2986_evgld_glVertexAttrib4fv(GLuint indx, const GLfloat* values) 2129_evgld_glVertexAttrib4fv(GLuint indx, const GLfloat* values)
2987{ 2130{
2988 EVGL_FUNC_BEGIN(); 2131 EVGLD_FUNC_BEGIN();
2989 glVertexAttrib4fv(indx, values); 2132 evgl_glVertexAttrib4fv(indx, values);
2990 EVGL_FUNC_END(); 2133 EVGLD_FUNC_END();
2991} 2134}
2992 2135
2993void 2136void
2994_evgld_glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) 2137_evgld_glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
2995{ 2138{
2996 EVGL_FUNC_BEGIN(); 2139 EVGLD_FUNC_BEGIN();
2997 glVertexAttribPointer(indx, size, type, normalized, stride, ptr); 2140 evgl_glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
2998 EVGL_FUNC_END(); 2141 EVGLD_FUNC_END();
2999} 2142}
3000 2143
3001//-------------------------------------------------------------// 2144//-------------------------------------------------------------//
@@ -3004,1379 +2147,859 @@ _evgld_glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean nor
3004void 2147void
3005_evgld_glReadBuffer(GLenum mode) 2148_evgld_glReadBuffer(GLenum mode)
3006{ 2149{
3007 if (!_gles3_api.glReadBuffer) 2150 EVGLD_FUNC_BEGIN();
3008 { 2151 evgl_gles3_glReadBuffer(mode);
3009 ERR("Can not call glReadBuffer() in this context!"); 2152 EVGLD_FUNC_END();
3010 return;
3011 }
3012 EVGL_FUNC_BEGIN();
3013 _evgl_glReadBuffer(mode);
3014 EVGL_FUNC_END();
3015} 2153}
3016 2154
3017void 2155void
3018_evgld_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) 2156_evgld_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
3019{ 2157{
3020 if (!_gles3_api.glDrawRangeElements) 2158 EVGLD_FUNC_BEGIN();
3021 { 2159 evgl_gles3_glDrawRangeElements(mode, start, end, count, type, indices);
3022 ERR("Can not call glDrawRangeElements() in this context!"); 2160 EVGLD_FUNC_END();
3023 return;
3024 }
3025 EVGL_FUNC_BEGIN();
3026 _evgl_glDrawRangeElements(mode, start, end, count, type, indices);
3027 EVGL_FUNC_END();
3028} 2161}
3029 2162
3030void 2163void
3031_evgld_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) 2164_evgld_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
3032{ 2165{
3033 if (!_gles3_api.glTexImage3D) 2166 EVGLD_FUNC_BEGIN();
3034 { 2167 evgl_gles3_glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
3035 ERR("Can not call glTexImage3D() in this context!"); 2168 EVGLD_FUNC_END();
3036 return;
3037 }
3038 EVGL_FUNC_BEGIN();
3039 _evgl_glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
3040 EVGL_FUNC_END();
3041} 2169}
3042 2170
3043void 2171void
3044_evgld_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) 2172_evgld_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
3045{ 2173{
3046 if (!_gles3_api.glTexSubImage3D) 2174 EVGLD_FUNC_BEGIN();
3047 { 2175 evgl_gles3_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
3048 ERR("Can not call glTexSubImage3D() in this context!"); 2176 EVGLD_FUNC_END();
3049 return;
3050 }
3051 EVGL_FUNC_BEGIN();
3052 _evgl_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
3053 EVGL_FUNC_END();
3054} 2177}
3055 2178
3056void 2179void
3057_evgld_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) 2180_evgld_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
3058{ 2181{
3059 if (!_gles3_api.glCopyTexSubImage3D) 2182 EVGLD_FUNC_BEGIN();
3060 { 2183 evgl_gles3_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
3061 ERR("Can not call glCopyTexSubImage3D() in this context!"); 2184 EVGLD_FUNC_END();
3062 return;
3063 }
3064 EVGL_FUNC_BEGIN();
3065 _evgl_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
3066 EVGL_FUNC_END();
3067} 2185}
3068 2186
3069void 2187void
3070_evgld_glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) 2188_evgld_glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
3071{ 2189{
3072 if (!_gles3_api.glCompressedTexImage3D) 2190 EVGLD_FUNC_BEGIN();
3073 { 2191 evgl_gles3_glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
3074 ERR("Can not call glCompressedTexImage3D() in this context!"); 2192 EVGLD_FUNC_END();
3075 return;
3076 }
3077 EVGL_FUNC_BEGIN();
3078 _evgl_glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
3079 EVGL_FUNC_END();
3080} 2193}
3081 2194
3082void 2195void
3083_evgld_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) 2196_evgld_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
3084{ 2197{
3085 if (!_gles3_api.glCompressedTexSubImage3D) 2198 EVGLD_FUNC_BEGIN();
3086 { 2199 evgl_gles3_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
3087 ERR("Can not call glCompressedTexSubImage3D() in this context!"); 2200 EVGLD_FUNC_END();
3088 return;
3089 }
3090 EVGL_FUNC_BEGIN();
3091 _evgl_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
3092 EVGL_FUNC_END();
3093} 2201}
3094 2202
3095void 2203void
3096_evgld_glGenQueries(GLsizei n, GLuint *ids) 2204_evgld_glGenQueries(GLsizei n, GLuint *ids)
3097{ 2205{
3098 if (!_gles3_api.glGenQueries) 2206 EVGLD_FUNC_BEGIN();
3099 { 2207 evgl_gles3_glGenQueries(n, ids);
3100 ERR("Can not call glGenQueries() in this context!"); 2208 EVGLD_FUNC_END();
3101 return;
3102 }
3103 EVGL_FUNC_BEGIN();
3104 _evgl_glGenQueries(n, ids);
3105 EVGL_FUNC_END();
3106} 2209}
3107 2210
3108void 2211void
3109_evgld_glDeleteQueries(GLsizei n, const GLuint *ids) 2212_evgld_glDeleteQueries(GLsizei n, const GLuint *ids)
3110{ 2213{
3111 if (!_gles3_api.glDeleteQueries) 2214 EVGLD_FUNC_BEGIN();
3112 { 2215 evgl_gles3_glDeleteQueries(n, ids);
3113 ERR("Can not call glDeleteQueries() in this context!"); 2216 EVGLD_FUNC_END();
3114 return;
3115 }
3116 EVGL_FUNC_BEGIN();
3117 _evgl_glDeleteQueries(n, ids);
3118 EVGL_FUNC_END();
3119} 2217}
3120 2218
3121GLboolean 2219GLboolean
3122 _evgld_glIsQuery(GLuint id) 2220 _evgld_glIsQuery(GLuint id)
3123{ 2221{
3124 if (!_gles3_api.glIsQuery)
3125 {
3126 ERR("Can not call glIsQuery() in this context!");
3127 return EINA_FALSE;
3128 }
3129 GLboolean ret; 2222 GLboolean ret;
3130 EVGL_FUNC_BEGIN(); 2223 EVGLD_FUNC_BEGIN();
3131 ret = _evgl_glIsQuery(id); 2224 ret = evgl_gles3_glIsQuery(id);
3132 EVGL_FUNC_END(); 2225 EVGLD_FUNC_END();
3133 return ret; 2226 return ret;
3134} 2227}
3135 2228
3136void 2229void
3137_evgld_glBeginQuery(GLenum target, GLuint id) 2230_evgld_glBeginQuery(GLenum target, GLuint id)
3138{ 2231{
3139 if (!_gles3_api.glBeginQuery) 2232 EVGLD_FUNC_BEGIN();
3140 { 2233 evgl_gles3_glBeginQuery(target, id);
3141 ERR("Can not call glBeginQuery() in this context!"); 2234 EVGLD_FUNC_END();
3142 return;
3143 }
3144 EVGL_FUNC_BEGIN();
3145 _evgl_glBeginQuery(target, id);
3146 EVGL_FUNC_END();
3147} 2235}
3148 2236
3149void 2237void
3150_evgld_glEndQuery(GLenum target) 2238_evgld_glEndQuery(GLenum target)
3151{ 2239{
3152 if (!_gles3_api.glEndQuery) 2240 EVGLD_FUNC_BEGIN();
3153 { 2241 evgl_gles3_glEndQuery(target);
3154 ERR("Can not call glEndQuery() in this context!"); 2242 EVGLD_FUNC_END();
3155 return;
3156 }
3157 EVGL_FUNC_BEGIN();
3158 _evgl_glEndQuery(target);
3159 EVGL_FUNC_END();
3160} 2243}
3161 2244
3162void 2245void
3163_evgld_glGetQueryiv(GLenum target, GLenum pname, GLint *params) 2246_evgld_glGetQueryiv(GLenum target, GLenum pname, GLint *params)
3164{ 2247{
3165 if (!_gles3_api.glGetQueryiv) 2248 EVGLD_FUNC_BEGIN();
3166 { 2249 evgl_gles3_glGetQueryiv(target, pname, params);
3167 ERR("Can not call glGetQueryiv() in this context!"); 2250 EVGLD_FUNC_END();
3168 return;
3169 }
3170 EVGL_FUNC_BEGIN();
3171 _evgl_glGetQueryiv(target, pname, params);
3172 EVGL_FUNC_END();
3173} 2251}
3174 2252
3175void 2253void
3176_evgld_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) 2254_evgld_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
3177{ 2255{
3178 if (!_gles3_api.glGetQueryObjectuiv) 2256 EVGLD_FUNC_BEGIN();
3179 { 2257 evgl_gles3_glGetQueryObjectuiv(id, pname, params);
3180 ERR("Can not call glGetQueryObjectuiv() in this context!"); 2258 EVGLD_FUNC_END();
3181 return;
3182 }
3183 EVGL_FUNC_BEGIN();
3184 _evgl_glGetQueryObjectuiv(id, pname, params);
3185 EVGL_FUNC_END();
3186} 2259}
3187 2260
3188GLboolean 2261GLboolean
3189_evgld_glUnmapBuffer(GLenum target) 2262_evgld_glUnmapBuffer(GLenum target)
3190{ 2263{
3191 if (!_gles3_api.glUnmapBuffer)
3192 {
3193 ERR("Can not call glUnmapBuffer() in this context!");
3194 return EINA_FALSE;
3195 }
3196 GLboolean ret; 2264 GLboolean ret;
3197 EVGL_FUNC_BEGIN(); 2265 EVGLD_FUNC_BEGIN();
3198 ret = _evgl_glUnmapBuffer(target); 2266 ret = evgl_gles3_glUnmapBuffer(target);
3199 EVGL_FUNC_END(); 2267 EVGLD_FUNC_END();
3200 return ret; 2268 return ret;
3201} 2269}
3202 2270
3203void 2271void
3204_evgld_glGetBufferPointerv(GLenum target, GLenum pname, GLvoid **params) 2272_evgld_glGetBufferPointerv(GLenum target, GLenum pname, GLvoid **params)
3205{ 2273{
3206 if (!_gles3_api.glGetBufferPointerv) 2274 EVGLD_FUNC_BEGIN();
3207 { 2275 evgl_gles3_glGetBufferPointerv(target, pname, params);
3208 ERR("Can not call glGetBufferPointerv() in this context!"); 2276 EVGLD_FUNC_END();
3209 return;
3210 }
3211 EVGL_FUNC_BEGIN();
3212 _evgl_glGetBufferPointerv(target, pname, params);
3213 EVGL_FUNC_END();
3214} 2277}
3215 2278
3216void 2279void
3217_evgld_glDrawBuffers(GLsizei n, const GLenum *bufs) 2280_evgld_glDrawBuffers(GLsizei n, const GLenum *bufs)
3218{ 2281{
3219 if (!_gles3_api.glDrawBuffers) 2282 EVGLD_FUNC_BEGIN();
3220 { 2283 evgl_gles3_glDrawBuffers(n, bufs);
3221 ERR("Can not call glDrawBuffers() in this context!"); 2284 EVGLD_FUNC_END();
3222 return;
3223 }
3224 EVGL_FUNC_BEGIN();
3225 _evgl_glDrawBuffers(n, bufs);
3226 EVGL_FUNC_END();
3227} 2285}
3228 2286
3229void 2287void
3230_evgld_glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) 2288_evgld_glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3231{ 2289{
3232 if (!_gles3_api.glUniformMatrix2x3fv) 2290 EVGLD_FUNC_BEGIN();
3233 { 2291 evgl_gles3_glUniformMatrix2x3fv(location, count, transpose, value);
3234 ERR("Can not call glUniformMatrix2x3fv() in this context!"); 2292 EVGLD_FUNC_END();
3235 return;
3236 }
3237 EVGL_FUNC_BEGIN();
3238 _evgl_glUniformMatrix2x3fv(location, count, transpose, value);
3239 EVGL_FUNC_END();
3240} 2293}
3241 2294
3242void 2295void
3243_evgld_glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) 2296_evgld_glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3244{ 2297{
3245 if (!_gles3_api.glUniformMatrix3x2fv) 2298 EVGLD_FUNC_BEGIN();
3246 { 2299 evgl_gles3_glUniformMatrix3x2fv(location, count, transpose, value);
3247 ERR("Can not call glUniformMatrix3x2fv() in this context!"); 2300 EVGLD_FUNC_END();
3248 return;
3249 }
3250 EVGL_FUNC_BEGIN();
3251 _evgl_glUniformMatrix3x2fv(location, count, transpose, value);
3252 EVGL_FUNC_END();
3253} 2301}
3254 2302
3255void 2303void
3256_evgld_glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) 2304_evgld_glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3257{ 2305{
3258 if (!_gles3_api.glUniformMatrix2x4fv) 2306 EVGLD_FUNC_BEGIN();
3259 { 2307 evgl_gles3_glUniformMatrix2x4fv(location, count, transpose, value);
3260 ERR("Can not call glUniformMatrix2x4fv() in this context!"); 2308 EVGLD_FUNC_END();
3261 return;
3262 }
3263 EVGL_FUNC_BEGIN();
3264 _evgl_glUniformMatrix2x4fv(location, count, transpose, value);
3265 EVGL_FUNC_END();
3266} 2309}
3267 2310
3268void 2311void
3269_evgld_glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) 2312_evgld_glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3270{ 2313{
3271 if (!_gles3_api.glUniformMatrix4x2fv) 2314 EVGLD_FUNC_BEGIN();
3272 { 2315 evgl_gles3_glUniformMatrix4x2fv(location, count, transpose, value);
3273 ERR("Can not call glUniformMatrix4x2fv() in this context!"); 2316 EVGLD_FUNC_END();
3274 return;
3275 }
3276 EVGL_FUNC_BEGIN();
3277 _evgl_glUniformMatrix4x2fv(location, count, transpose, value);
3278 EVGL_FUNC_END();
3279} 2317}
3280 2318
3281void 2319void
3282_evgld_glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) 2320_evgld_glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3283{ 2321{
3284 if (!_gles3_api.glUniformMatrix3x4fv) 2322 EVGLD_FUNC_BEGIN();
3285 { 2323 evgl_gles3_glUniformMatrix3x4fv(location, count, transpose, value);
3286 ERR("Can not call glUniformMatrix3x4fv() in this context!"); 2324 EVGLD_FUNC_END();
3287 return;
3288 }
3289 EVGL_FUNC_BEGIN();
3290 _evgl_glUniformMatrix3x4fv(location, count, transpose, value);
3291 EVGL_FUNC_END();
3292} 2325}
3293 2326
3294void 2327void
3295_evgld_glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) 2328_evgld_glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3296{ 2329{
3297 if (!_gles3_api.glUniformMatrix4x3fv) 2330 EVGLD_FUNC_BEGIN();
3298 { 2331 evgl_gles3_glUniformMatrix4x3fv(location, count, transpose, value);
3299 ERR("Can not call glUniformMatrix4x3fv() in this context!"); 2332 EVGLD_FUNC_END();
3300 return;
3301 }
3302 EVGL_FUNC_BEGIN();
3303 _evgl_glUniformMatrix4x3fv(location, count, transpose, value);
3304 EVGL_FUNC_END();
3305} 2333}
3306 2334
3307void 2335void
3308_evgld_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) 2336_evgld_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
3309{ 2337{
3310 if (!_gles3_api.glBlitFramebuffer) 2338 EVGLD_FUNC_BEGIN();
3311 { 2339 evgl_gles3_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
3312 ERR("Can not call glBlitFramebuffer() in this context!"); 2340 EVGLD_FUNC_END();
3313 return;
3314 }
3315 EVGL_FUNC_BEGIN();
3316 _evgl_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
3317 EVGL_FUNC_END();
3318} 2341}
3319 2342
3320void 2343void
3321_evgld_glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) 2344_evgld_glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
3322{ 2345{
3323 if (!_gles3_api.glRenderbufferStorageMultisample) 2346 EVGLD_FUNC_BEGIN();
3324 { 2347 evgl_gles3_glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
3325 ERR("Can not call glRenderbufferStorageMultisample() in this context!"); 2348 EVGLD_FUNC_END();
3326 return;
3327 }
3328 EVGL_FUNC_BEGIN();
3329 _evgl_glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
3330 EVGL_FUNC_END();
3331} 2349}
3332 2350
3333void 2351void
3334_evgld_glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) 2352_evgld_glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
3335{ 2353{
3336 if (!_gles3_api.glFramebufferTextureLayer) 2354 EVGLD_FUNC_BEGIN();
3337 { 2355 evgl_gles3_glFramebufferTextureLayer(target, attachment, texture, level, layer);
3338 ERR("Can not call glFramebufferTextureLayer() in this context!"); 2356 EVGLD_FUNC_END();
3339 return;
3340 }
3341 EVGL_FUNC_BEGIN();
3342 _evgl_glFramebufferTextureLayer(target, attachment, texture, level, layer);
3343 EVGL_FUNC_END();
3344} 2357}
3345 2358
3346void* 2359void *
3347_evgld_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) 2360_evgld_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
3348{ 2361{
3349 if (!_gles3_api.glMapBufferRange)
3350 {
3351 ERR("Can not call glMapBufferRange() in this context!");
3352 return NULL;
3353 }
3354 void* ret; 2362 void* ret;
3355 EVGL_FUNC_BEGIN(); 2363 EVGLD_FUNC_BEGIN();
3356 ret = _evgl_glMapBufferRange(target, offset, length, access); 2364 ret = evgl_gles3_glMapBufferRange(target, offset, length, access);
3357 EVGL_FUNC_END(); 2365 EVGLD_FUNC_END();
3358 return ret; 2366 return ret;
3359} 2367}
3360 2368
3361GLsync 2369GLsync
3362_evgld_glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) 2370_evgld_glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
3363{ 2371{
3364 if (!_gles3_api.glFlushMappedBufferRange)
3365 {
3366 ERR("Can not call glFlushMappedBufferRange() in this context!");
3367 return 0;
3368 }
3369 GLsync ret; 2372 GLsync ret;
3370 EVGL_FUNC_BEGIN(); 2373 EVGLD_FUNC_BEGIN();
3371 ret = _evgl_glFlushMappedBufferRange(target, offset, length); 2374 ret = evgl_gles3_glFlushMappedBufferRange(target, offset, length);
3372 EVGL_FUNC_END(); 2375 EVGLD_FUNC_END();
3373 return ret; 2376 return ret;
3374} 2377}
3375 2378
3376void 2379void
3377_evgld_glBindVertexArray(GLuint array) 2380_evgld_glBindVertexArray(GLuint array)
3378{ 2381{
3379 if (!_gles3_api.glBindVertexArray) 2382 EVGLD_FUNC_BEGIN();
3380 { 2383 evgl_gles3_glBindVertexArray(array);
3381 ERR("Can not call glBindVertexArray() in this context!"); 2384 EVGLD_FUNC_END();
3382 return;
3383 }
3384 EVGL_FUNC_BEGIN();
3385 _evgl_glBindVertexArray(array);
3386 EVGL_FUNC_END();
3387} 2385}
3388 2386
3389void 2387void
3390_evgld_glDeleteVertexArrays(GLsizei n, const GLuint *arrays) 2388_evgld_glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
3391{ 2389{
3392 if (!_gles3_api.glDeleteVertexArrays) 2390 EVGLD_FUNC_BEGIN();
3393 { 2391 evgl_gles3_glDeleteVertexArrays(n, arrays);
3394 ERR("Can not call glDeleteVertexArrays() in this context!"); 2392 EVGLD_FUNC_END();
3395 return;
3396 }
3397 EVGL_FUNC_BEGIN();
3398 _evgl_glDeleteVertexArrays(n, arrays);
3399 EVGL_FUNC_END();
3400} 2393}
3401 2394
3402void 2395void
3403_evgld_glGenVertexArrays(GLsizei n, GLuint *arrays) 2396_evgld_glGenVertexArrays(GLsizei n, GLuint *arrays)
3404{ 2397{
3405 if (!_gles3_api.glGenVertexArrays) 2398 EVGLD_FUNC_BEGIN();
3406 { 2399 evgl_gles3_glGenVertexArrays(n, arrays);
3407 ERR("Can not call glGenVertexArrays() in this context!"); 2400 EVGLD_FUNC_END();
3408 return;
3409 }
3410 EVGL_FUNC_BEGIN();
3411 _evgl_glGenVertexArrays(n, arrays);
3412 EVGL_FUNC_END();
3413} 2401}
3414 2402
3415GLboolean 2403GLboolean
3416_evgld_glIsVertexArray(GLuint array) 2404_evgld_glIsVertexArray(GLuint array)
3417{ 2405{
3418 if (!_gles3_api.glIsVertexArray)
3419 {
3420 ERR("Can not call glIsVertexArray() in this context!");
3421 return EINA_FALSE;
3422 }
3423 GLboolean ret; 2406 GLboolean ret;
3424 EVGL_FUNC_BEGIN(); 2407 EVGLD_FUNC_BEGIN();
3425 ret = _evgl_glIsVertexArray(array); 2408 ret = evgl_gles3_glIsVertexArray(array);
3426 EVGL_FUNC_END(); 2409 EVGLD_FUNC_END();
3427 return ret; 2410 return ret;
3428} 2411}
3429 2412
3430void 2413void
3431_evgld_glGetIntegeri_v(GLenum target, GLuint index, GLint *data) 2414_evgld_glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
3432{ 2415{
3433 if (!_gles3_api.glGetIntegeri_v) 2416 EVGLD_FUNC_BEGIN();
3434 { 2417 evgl_gles3_glGetIntegeri_v(target, index, data);
3435 ERR("Can not call glGetIntegeri_v() in this context!"); 2418 EVGLD_FUNC_END();
3436 return;
3437 }
3438 EVGL_FUNC_BEGIN();
3439 _evgl_glGetIntegeri_v(target, index, data);
3440 EVGL_FUNC_END();
3441} 2419}
3442 2420
3443void 2421void
3444_evgld_glBeginTransformFeedback(GLenum primitiveMode) 2422_evgld_glBeginTransformFeedback(GLenum primitiveMode)
3445{ 2423{
3446 if (!_gles3_api.glBeginTransformFeedback) 2424 EVGLD_FUNC_BEGIN();
3447 { 2425 evgl_gles3_glBeginTransformFeedback(primitiveMode);
3448 ERR("Can not call glBeginTransformFeedback() in this context!"); 2426 EVGLD_FUNC_END();
3449 return;
3450 }
3451 EVGL_FUNC_BEGIN();
3452 _evgl_glBeginTransformFeedback(primitiveMode);
3453 EVGL_FUNC_END();
3454} 2427}
3455 2428
3456void 2429void
3457_evgld_glEndTransformFeedback(void) 2430_evgld_glEndTransformFeedback(void)
3458{ 2431{
3459 if (!_gles3_api.glEndTransformFeedback) 2432 EVGLD_FUNC_BEGIN();
3460 { 2433 evgl_gles3_glEndTransformFeedback();
3461 ERR("Can not call glEndTransformFeedback() in this context!"); 2434 EVGLD_FUNC_END();
3462 return;
3463 }
3464 EVGL_FUNC_BEGIN();
3465 _evgl_glEndTransformFeedback();
3466 EVGL_FUNC_END();
3467} 2435}
3468 2436
3469void 2437void
3470_evgld_glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) 2438_evgld_glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
3471{ 2439{
3472 if (!_gles3_api.glBindBufferRange) 2440 EVGLD_FUNC_BEGIN();
3473 { 2441 evgl_gles3_glBindBufferRange(target, index, buffer, offset, size);
3474 ERR("Can not call glBindBufferRange() in this context!"); 2442 EVGLD_FUNC_END();
3475 return;
3476 }
3477 EVGL_FUNC_BEGIN();
3478 _evgl_glBindBufferRange(target, index, buffer, offset, size);
3479 EVGL_FUNC_END();
3480} 2443}
3481 2444
3482void 2445void
3483_evgld_glBindBufferBase(GLenum target, GLuint index, GLuint buffer) 2446_evgld_glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
3484{ 2447{
3485 if (!_gles3_api.glBindBufferBase) 2448 EVGLD_FUNC_BEGIN();
3486 { 2449 evgl_gles3_glBindBufferBase(target, index, buffer);
3487 ERR("Can not call glBindBufferBase() in this context!"); 2450 EVGLD_FUNC_END();
3488 return;
3489 }
3490 EVGL_FUNC_BEGIN();
3491 _evgl_glBindBufferBase(target, index, buffer);
3492 EVGL_FUNC_END();
3493} 2451}
3494 2452
3495void 2453void
3496_evgld_glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode) 2454_evgld_glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode)
3497{ 2455{
3498 if (!_gles3_api.glTransformFeedbackVaryings) 2456 EVGLD_FUNC_BEGIN();
3499 { 2457 evgl_gles3_glTransformFeedbackVaryings(program, count, varyings, bufferMode);
3500 ERR("Can not call glTransformFeedbackVaryings() in this context!"); 2458 EVGLD_FUNC_END();
3501 return;
3502 }
3503 EVGL_FUNC_BEGIN();
3504 _evgl_glTransformFeedbackVaryings(program, count, varyings, bufferMode);
3505 EVGL_FUNC_END();
3506} 2459}
3507 2460
3508void 2461void
3509_evgld_glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) 2462_evgld_glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
3510{ 2463{
3511 if (!_gles3_api.glGetTransformFeedbackVarying) 2464 EVGLD_FUNC_BEGIN();
3512 { 2465 evgl_gles3_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
3513 ERR("Can not call glGetTransformFeedbackVarying() in this context!"); 2466 EVGLD_FUNC_END();
3514 return;
3515 }
3516 EVGL_FUNC_BEGIN();
3517 _evgl_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
3518 EVGL_FUNC_END();
3519} 2467}
3520 2468
3521void 2469void
3522_evgld_glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) 2470_evgld_glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
3523{ 2471{
3524 if (!_gles3_api.glVertexAttribIPointer) 2472 EVGLD_FUNC_BEGIN();
3525 { 2473 evgl_gles3_glVertexAttribIPointer(index, size, type, stride, pointer);
3526 ERR("Can not call glVertexAttribIPointer() in this context!"); 2474 EVGLD_FUNC_END();
3527 return;
3528 }
3529 EVGL_FUNC_BEGIN();
3530 _evgl_glVertexAttribIPointer(index, size, type, stride, pointer);
3531 EVGL_FUNC_END();
3532} 2475}
3533 2476
3534void 2477void
3535_evgld_glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params) 2478_evgld_glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
3536{ 2479{
3537 if (!_gles3_api.glGetVertexAttribIiv) 2480 EVGLD_FUNC_BEGIN();
3538 { 2481 evgl_gles3_glGetVertexAttribIiv(index, pname, params);
3539 ERR("Can not call glGetVertexAttribIiv() in this context!"); 2482 EVGLD_FUNC_END();
3540 return;
3541 }
3542 EVGL_FUNC_BEGIN();
3543 _evgl_glGetVertexAttribIiv(index, pname, params);
3544 EVGL_FUNC_END();
3545} 2483}
3546 2484
3547void 2485void
3548_evgld_glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params) 2486_evgld_glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
3549{ 2487{
3550 if (!_gles3_api.glGetVertexAttribIuiv) 2488 EVGLD_FUNC_BEGIN();
3551 { 2489 evgl_gles3_glGetVertexAttribIuiv(index, pname, params);
3552 ERR("Can not call glGetVertexAttribIuiv() in this context!"); 2490 EVGLD_FUNC_END();
3553 return;
3554 }
3555 EVGL_FUNC_BEGIN();
3556 _evgl_glGetVertexAttribIuiv(index, pname, params);
3557 EVGL_FUNC_END();
3558} 2491}
3559 2492
3560void 2493void
3561_evgld_glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) 2494_evgld_glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
3562{ 2495{
3563 if (!_gles3_api.glVertexAttribI4i) 2496 EVGLD_FUNC_BEGIN();
3564 { 2497 evgl_gles3_glVertexAttribI4i(index, x, y, z, w);
3565 ERR("Can not call glVertexAttribI4i() in this context!"); 2498 EVGLD_FUNC_END();
3566 return;
3567 }
3568 EVGL_FUNC_BEGIN();
3569 _evgl_glVertexAttribI4i(index, x, y, z, w);
3570 EVGL_FUNC_END();
3571} 2499}
3572 2500
3573void 2501void
3574_evgld_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) 2502_evgld_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
3575{ 2503{
3576 if (!_gles3_api.glVertexAttribI4ui) 2504 EVGLD_FUNC_BEGIN();
3577 { 2505 evgl_gles3_glVertexAttribI4ui(index, x, y, z, w);
3578 ERR("Can not call glVertexAttribI4ui() in this context!"); 2506 EVGLD_FUNC_END();
3579 return;
3580 }
3581 EVGL_FUNC_BEGIN();
3582 _evgl_glVertexAttribI4ui(index, x, y, z, w);
3583 EVGL_FUNC_END();
3584} 2507}
3585 2508
3586void 2509void
3587_evgld_glVertexAttribI4iv(GLuint index, const GLint *v) 2510_evgld_glVertexAttribI4iv(GLuint index, const GLint *v)
3588{ 2511{
3589 if (!_gles3_api.glVertexAttribI4iv) 2512 EVGLD_FUNC_BEGIN();
3590 { 2513 evgl_gles3_glVertexAttribI4iv(index, v);
3591 ERR("Can not call glVertexAttribI4iv() in this context!"); 2514 EVGLD_FUNC_END();
3592 return;
3593 }
3594 EVGL_FUNC_BEGIN();
3595 _evgl_glVertexAttribI4iv(index, v);
3596 EVGL_FUNC_END();
3597} 2515}
3598 2516
3599void 2517void
3600_evgld_glVertexAttribI4uiv(GLuint index, const GLuint *v) 2518_evgld_glVertexAttribI4uiv(GLuint index, const GLuint *v)
3601{ 2519{
3602 if (!_gles3_api.glVertexAttribI4uiv) 2520 EVGLD_FUNC_BEGIN();
3603 { 2521 evgl_gles3_glVertexAttribI4uiv(index, v);
3604 ERR("Can not call glVertexAttribI4uiv() in this context!"); 2522 EVGLD_FUNC_END();
3605 return;
3606 }
3607 EVGL_FUNC_BEGIN();
3608 _evgl_glVertexAttribI4uiv(index, v);
3609 EVGL_FUNC_END();
3610} 2523}
3611 2524
3612void 2525void
3613_evgld_glGetUniformuiv(GLuint program, GLint location, GLuint *params) 2526_evgld_glGetUniformuiv(GLuint program, GLint location, GLuint *params)
3614{ 2527{
3615 if (!_gles3_api.glGetUniformuiv) 2528 EVGLD_FUNC_BEGIN();
3616 { 2529 evgl_gles3_glGetUniformuiv(program, location, params);
3617 ERR("Can not call glGetUniformuiv() in this context!"); 2530 EVGLD_FUNC_END();
3618 return;
3619 }
3620 EVGL_FUNC_BEGIN();
3621 _evgl_glGetUniformuiv(program, location, params);
3622 EVGL_FUNC_END();
3623} 2531}
3624 2532
3625GLint 2533GLint
3626_evgld_glGetFragDataLocation(GLuint program, const GLchar *name) 2534_evgld_glGetFragDataLocation(GLuint program, const GLchar *name)
3627{ 2535{
3628 if (!_gles3_api.glGetFragDataLocation)
3629 {
3630 ERR("Can not call glGetFragDataLocation() in this context!");
3631 return EVAS_GL_NOT_INITIALIZED;
3632 }
3633