1 /*
2 * %CopyrightBegin%
3 *
4 * Copyright Ericsson AB 2008-2020. All Rights Reserved.
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 * %CopyrightEnd%
19 */
20 /***** This file is generated do not edit ****/
21
22 #include <stdio.h>
23 #include <string.h>
24 #include <vector>
25 extern "C" {
26 #include "../egl_impl.h"
27 #include "gl_fdefs.h"
28 }
29
ecb_init_opengl(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])30 void ecb_init_opengl(ErlNifEnv *env, ErlNifPid *self, ERL_NIF_TERM argv[])
31 {
32 egl_load_functions();
33 init_tess();
34 }
35
ecb_glClearIndex(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])36 void ecb_glClearIndex(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
37 {
38 GLfloat c;
39 if(!egl_get_float(env, argv[0], &c)) Badarg(5037,"c");
40 weglClearIndex(c);
41 }
42
ecb_glClearColor(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])43 void ecb_glClearColor(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
44 {
45 GLclampf red;
46 GLclampf green;
47 GLclampf blue;
48 GLclampf alpha;
49 if(!egl_get_float(env, argv[0], &red)) Badarg(5038,"red");
50 if(!egl_get_float(env, argv[1], &green)) Badarg(5038,"green");
51 if(!egl_get_float(env, argv[2], &blue)) Badarg(5038,"blue");
52 if(!egl_get_float(env, argv[3], &alpha)) Badarg(5038,"alpha");
53 weglClearColor(red,green,blue,alpha);
54 }
55
ecb_glClear(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])56 void ecb_glClear(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
57 {
58 GLbitfield mask;
59 if(!enif_get_uint(env, argv[0], &mask)) Badarg(5039,"mask");
60 weglClear(mask);
61 }
62
ecb_glIndexMask(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])63 void ecb_glIndexMask(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
64 {
65 GLuint mask;
66 if(!enif_get_uint(env, argv[0], &mask)) Badarg(5040,"mask");
67 weglIndexMask(mask);
68 }
69
ecb_glColorMask(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])70 void ecb_glColorMask(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
71 {
72 GLboolean red;
73 GLboolean green;
74 GLboolean blue;
75 GLboolean alpha;
76 if(!egl_get_ubyte(env, argv[0], &red)) Badarg(5041,"red");
77 if(!egl_get_ubyte(env, argv[1], &green)) Badarg(5041,"green");
78 if(!egl_get_ubyte(env, argv[2], &blue)) Badarg(5041,"blue");
79 if(!egl_get_ubyte(env, argv[3], &alpha)) Badarg(5041,"alpha");
80 weglColorMask(red,green,blue,alpha);
81 }
82
ecb_glAlphaFunc(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])83 void ecb_glAlphaFunc(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
84 {
85 GLenum func;
86 GLclampf ref;
87 if(!enif_get_uint(env, argv[0], &func)) Badarg(5042,"func");
88 if(!egl_get_float(env, argv[1], &ref)) Badarg(5042,"ref");
89 weglAlphaFunc(func,ref);
90 }
91
ecb_glBlendFunc(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])92 void ecb_glBlendFunc(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
93 {
94 GLenum sfactor;
95 GLenum dfactor;
96 if(!enif_get_uint(env, argv[0], &sfactor)) Badarg(5043,"sfactor");
97 if(!enif_get_uint(env, argv[1], &dfactor)) Badarg(5043,"dfactor");
98 weglBlendFunc(sfactor,dfactor);
99 }
100
ecb_glLogicOp(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])101 void ecb_glLogicOp(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
102 {
103 GLenum opcode;
104 if(!enif_get_uint(env, argv[0], &opcode)) Badarg(5044,"opcode");
105 weglLogicOp(opcode);
106 }
107
ecb_glCullFace(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])108 void ecb_glCullFace(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
109 {
110 GLenum mode;
111 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5045,"mode");
112 weglCullFace(mode);
113 }
114
ecb_glFrontFace(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])115 void ecb_glFrontFace(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
116 {
117 GLenum mode;
118 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5046,"mode");
119 weglFrontFace(mode);
120 }
121
ecb_glPointSize(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])122 void ecb_glPointSize(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
123 {
124 GLfloat size;
125 if(!egl_get_float(env, argv[0], &size)) Badarg(5047,"size");
126 weglPointSize(size);
127 }
128
ecb_glLineWidth(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])129 void ecb_glLineWidth(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
130 {
131 GLfloat width;
132 if(!egl_get_float(env, argv[0], &width)) Badarg(5048,"width");
133 weglLineWidth(width);
134 }
135
ecb_glLineStipple(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])136 void ecb_glLineStipple(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
137 {
138 GLint factor;
139 GLushort pattern;
140 if(!enif_get_int(env, argv[0], &factor)) Badarg(5049,"factor");
141 if(!egl_get_ushort(env, argv[1], &pattern)) Badarg(5049,"pattern");
142 weglLineStipple(factor,pattern);
143 }
144
ecb_glPolygonMode(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])145 void ecb_glPolygonMode(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
146 {
147 GLenum face;
148 GLenum mode;
149 if(!enif_get_uint(env, argv[0], &face)) Badarg(5050,"face");
150 if(!enif_get_uint(env, argv[1], &mode)) Badarg(5050,"mode");
151 weglPolygonMode(face,mode);
152 }
153
ecb_glPolygonOffset(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])154 void ecb_glPolygonOffset(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
155 {
156 GLfloat factor;
157 GLfloat units;
158 if(!egl_get_float(env, argv[0], &factor)) Badarg(5051,"factor");
159 if(!egl_get_float(env, argv[1], &units)) Badarg(5051,"units");
160 weglPolygonOffset(factor,units);
161 }
162
ecb_glPolygonStipple(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])163 void ecb_glPolygonStipple(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
164 {
165 ErlNifBinary mask;
166 if(!enif_inspect_binary(env, argv[0], &mask)) Badarg(5052,"mask");
167 weglPolygonStipple((GLubyte *) mask.data);
168 }
169
ecb_glGetPolygonStipple(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])170 void ecb_glGetPolygonStipple(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
171 {
172 ERL_NIF_TERM reply;
173 ErlNifBinary mask;
174 enif_alloc_binary((int) 128*sizeof(GLubyte), &mask);
175 weglGetPolygonStipple((GLubyte *) mask.data);
176 reply = enif_make_binary(env, &mask);
177 enif_send(NULL, self, env,
178 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
179 }
180
ecb_glEdgeFlag(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])181 void ecb_glEdgeFlag(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
182 {
183 GLboolean flag;
184 if(!egl_get_ubyte(env, argv[0], &flag)) Badarg(5054,"flag");
185 weglEdgeFlag(flag);
186 }
187
ecb_glScissor(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])188 void ecb_glScissor(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
189 {
190 GLint x;
191 GLint y;
192 GLsizei width;
193 GLsizei height;
194 if(!enif_get_int(env, argv[0], &x)) Badarg(5055,"x");
195 if(!enif_get_int(env, argv[1], &y)) Badarg(5055,"y");
196 if(!enif_get_int(env, argv[2], &width)) Badarg(5055,"width");
197 if(!enif_get_int(env, argv[3], &height)) Badarg(5055,"height");
198 weglScissor(x,y,width,height);
199 }
200
ecb_glClipPlane(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])201 void ecb_glClipPlane(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
202 {
203 GLenum plane;
204 GLdouble equation[4];
205 if(!enif_get_uint(env, argv[0], &plane)) Badarg(5056,"plane");
206 {
207 int equation_a;
208 const ERL_NIF_TERM *equation_t;
209 if(!enif_get_tuple(env, argv[1], &equation_a, &equation_t) || equation_a != 4) {
210 Badarg(5056,"equation");
211 } else {
212 int i1 = 0;
213 if(!enif_get_double(env, equation_t[i1++], &equation[0])) Badarg(5056,"equation");
214 if(!enif_get_double(env, equation_t[i1++], &equation[1])) Badarg(5056,"equation");
215 if(!enif_get_double(env, equation_t[i1++], &equation[2])) Badarg(5056,"equation");
216 if(!enif_get_double(env, equation_t[i1++], &equation[3])) Badarg(5056,"equation");
217 }};
218 weglClipPlane(plane,equation);
219 }
220
ecb_glGetClipPlane(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])221 void ecb_glGetClipPlane(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
222 {
223 ERL_NIF_TERM reply;
224 GLenum plane;
225 GLdouble equation[4];
226 if(!enif_get_uint(env, argv[0], &plane)) Badarg(5057,"plane");
227 weglGetClipPlane(plane,equation);
228 reply = enif_make_tuple4(env,
229 enif_make_double(env, equation[0]),
230 enif_make_double(env, equation[1]),
231 enif_make_double(env, equation[2]),
232 enif_make_double(env, equation[3]));
233 enif_send(NULL, self, env,
234 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
235 }
236
ecb_glDrawBuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])237 void ecb_glDrawBuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
238 {
239 GLenum mode;
240 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5058,"mode");
241 weglDrawBuffer(mode);
242 }
243
ecb_glReadBuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])244 void ecb_glReadBuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
245 {
246 GLenum mode;
247 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5059,"mode");
248 weglReadBuffer(mode);
249 }
250
ecb_glEnable(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])251 void ecb_glEnable(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
252 {
253 GLenum cap;
254 if(!enif_get_uint(env, argv[0], &cap)) Badarg(5060,"cap");
255 weglEnable(cap);
256 }
257
ecb_glDisable(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])258 void ecb_glDisable(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
259 {
260 GLenum cap;
261 if(!enif_get_uint(env, argv[0], &cap)) Badarg(5061,"cap");
262 weglDisable(cap);
263 }
264
ecb_glIsEnabled(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])265 void ecb_glIsEnabled(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
266 {
267 GLboolean result;
268 ERL_NIF_TERM reply;
269 GLenum cap;
270 if(!enif_get_uint(env, argv[0], &cap)) Badarg(5062,"cap");
271 result = weglIsEnabled(cap);
272 reply = enif_make_int(env, result);
273 enif_send(NULL, self, env,
274 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
275 }
276
ecb_glEnableClientState(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])277 void ecb_glEnableClientState(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
278 {
279 GLenum cap;
280 if(!enif_get_uint(env, argv[0], &cap)) Badarg(5063,"cap");
281 weglEnableClientState(cap);
282 }
283
ecb_glDisableClientState(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])284 void ecb_glDisableClientState(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
285 {
286 GLenum cap;
287 if(!enif_get_uint(env, argv[0], &cap)) Badarg(5064,"cap");
288 weglDisableClientState(cap);
289 }
290
ecb_glGetBooleanv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])291 void ecb_glGetBooleanv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
292 {
293 ERL_NIF_TERM reply;
294 GLenum pname;
295 GLboolean params[16];
296 ERL_NIF_TERM params_ts[16];
297 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5065,"pname");
298 weglGetBooleanv(pname,params);
299 for(int ri=0; ri < (int) 16; ri++)
300 params_ts[ri] = enif_make_int(env, params[ri]);
301 reply = enif_make_list_from_array(env, params_ts, 16);
302 enif_send(NULL, self, env,
303 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
304 }
305
ecb_glGetDoublev(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])306 void ecb_glGetDoublev(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
307 {
308 ERL_NIF_TERM reply;
309 GLenum pname;
310 GLdouble params[16];
311 ERL_NIF_TERM params_ts[16];
312 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5066,"pname");
313 weglGetDoublev(pname,params);
314 for(int ri=0; ri < (int) 16; ri++)
315 params_ts[ri] = enif_make_double(env, params[ri]);
316 reply = enif_make_list_from_array(env, params_ts, 16);
317 enif_send(NULL, self, env,
318 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
319 }
320
ecb_glGetFloatv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])321 void ecb_glGetFloatv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
322 {
323 ERL_NIF_TERM reply;
324 GLenum pname;
325 GLfloat params[16];
326 ERL_NIF_TERM params_ts[16];
327 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5067,"pname");
328 weglGetFloatv(pname,params);
329 for(int ri=0; ri < (int) 16; ri++)
330 params_ts[ri] = enif_make_double(env, (double) params[ri]);
331 reply = enif_make_list_from_array(env, params_ts, 16);
332 enif_send(NULL, self, env,
333 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
334 }
335
ecb_glGetIntegerv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])336 void ecb_glGetIntegerv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
337 {
338 ERL_NIF_TERM reply;
339 GLenum pname;
340 GLint params[16];
341 ERL_NIF_TERM params_ts[16];
342 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5068,"pname");
343 weglGetIntegerv(pname,params);
344 for(int ri=0; ri < (int) 16; ri++)
345 params_ts[ri] = enif_make_int(env, params[ri]);
346 reply = enif_make_list_from_array(env, params_ts, 16);
347 enif_send(NULL, self, env,
348 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
349 }
350
ecb_glPushAttrib(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])351 void ecb_glPushAttrib(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
352 {
353 GLbitfield mask;
354 if(!enif_get_uint(env, argv[0], &mask)) Badarg(5069,"mask");
355 weglPushAttrib(mask);
356 }
357
ecb_glPopAttrib(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])358 void ecb_glPopAttrib(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
359 {
360 weglPopAttrib();
361 }
362
ecb_glPushClientAttrib(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])363 void ecb_glPushClientAttrib(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
364 {
365 GLbitfield mask;
366 if(!enif_get_uint(env, argv[0], &mask)) Badarg(5071,"mask");
367 weglPushClientAttrib(mask);
368 }
369
ecb_glPopClientAttrib(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])370 void ecb_glPopClientAttrib(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
371 {
372 weglPopClientAttrib();
373 }
374
ecb_glRenderMode(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])375 void ecb_glRenderMode(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
376 {
377 GLint result;
378 ERL_NIF_TERM reply;
379 GLenum mode;
380 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5073,"mode");
381 result = weglRenderMode(mode);
382 reply = enif_make_int(env, result);
383 enif_send(NULL, self, env,
384 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
385 }
386
ecb_glGetError(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])387 void ecb_glGetError(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
388 {
389 GLenum result;
390 ERL_NIF_TERM reply;
391 result = weglGetError();
392 reply = enif_make_int(env, result);
393 enif_send(NULL, self, env,
394 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
395 }
396
ecb_glGetString(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])397 void ecb_glGetString(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
398 {
399 const GLubyte * result;
400 ERL_NIF_TERM reply;
401 GLenum name;
402 if(!enif_get_uint(env, argv[0], &name)) Badarg(5075,"name");
403 result = weglGetString(name);
404 reply = enif_make_string(env, (const char *) result, ERL_NIF_LATIN1);
405 enif_send(NULL, self, env,
406 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
407 }
408
ecb_glFinish(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])409 void ecb_glFinish(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
410 {
411 weglFinish();
412 }
413
ecb_glFlush(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])414 void ecb_glFlush(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
415 {
416 weglFlush();
417 }
418
ecb_glHint(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])419 void ecb_glHint(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
420 {
421 GLenum target;
422 GLenum mode;
423 if(!enif_get_uint(env, argv[0], &target)) Badarg(5078,"target");
424 if(!enif_get_uint(env, argv[1], &mode)) Badarg(5078,"mode");
425 weglHint(target,mode);
426 }
427
ecb_glClearDepth(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])428 void ecb_glClearDepth(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
429 {
430 GLclampd depth;
431 if(!enif_get_double(env, argv[0], &depth)) Badarg(5079,"depth");
432 weglClearDepth(depth);
433 }
434
ecb_glDepthFunc(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])435 void ecb_glDepthFunc(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
436 {
437 GLenum func;
438 if(!enif_get_uint(env, argv[0], &func)) Badarg(5080,"func");
439 weglDepthFunc(func);
440 }
441
ecb_glDepthMask(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])442 void ecb_glDepthMask(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
443 {
444 GLboolean flag;
445 if(!egl_get_ubyte(env, argv[0], &flag)) Badarg(5081,"flag");
446 weglDepthMask(flag);
447 }
448
ecb_glDepthRange(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])449 void ecb_glDepthRange(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
450 {
451 GLclampd near_val;
452 GLclampd far_val;
453 if(!enif_get_double(env, argv[0], &near_val)) Badarg(5082,"near_val");
454 if(!enif_get_double(env, argv[1], &far_val)) Badarg(5082,"far_val");
455 weglDepthRange(near_val,far_val);
456 }
457
ecb_glClearAccum(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])458 void ecb_glClearAccum(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
459 {
460 GLfloat red;
461 GLfloat green;
462 GLfloat blue;
463 GLfloat alpha;
464 if(!egl_get_float(env, argv[0], &red)) Badarg(5083,"red");
465 if(!egl_get_float(env, argv[1], &green)) Badarg(5083,"green");
466 if(!egl_get_float(env, argv[2], &blue)) Badarg(5083,"blue");
467 if(!egl_get_float(env, argv[3], &alpha)) Badarg(5083,"alpha");
468 weglClearAccum(red,green,blue,alpha);
469 }
470
ecb_glAccum(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])471 void ecb_glAccum(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
472 {
473 GLenum op;
474 GLfloat value;
475 if(!enif_get_uint(env, argv[0], &op)) Badarg(5084,"op");
476 if(!egl_get_float(env, argv[1], &value)) Badarg(5084,"value");
477 weglAccum(op,value);
478 }
479
ecb_glMatrixMode(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])480 void ecb_glMatrixMode(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
481 {
482 GLenum mode;
483 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5085,"mode");
484 weglMatrixMode(mode);
485 }
486
ecb_glOrtho(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])487 void ecb_glOrtho(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
488 {
489 GLdouble left;
490 GLdouble right;
491 GLdouble bottom;
492 GLdouble top;
493 GLdouble near_val;
494 GLdouble far_val;
495 if(!enif_get_double(env, argv[0], &left)) Badarg(5086,"left");
496 if(!enif_get_double(env, argv[1], &right)) Badarg(5086,"right");
497 if(!enif_get_double(env, argv[2], &bottom)) Badarg(5086,"bottom");
498 if(!enif_get_double(env, argv[3], &top)) Badarg(5086,"top");
499 if(!enif_get_double(env, argv[4], &near_val)) Badarg(5086,"near_val");
500 if(!enif_get_double(env, argv[5], &far_val)) Badarg(5086,"far_val");
501 weglOrtho(left,right,bottom,top,near_val,far_val);
502 }
503
ecb_glFrustum(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])504 void ecb_glFrustum(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
505 {
506 GLdouble left;
507 GLdouble right;
508 GLdouble bottom;
509 GLdouble top;
510 GLdouble near_val;
511 GLdouble far_val;
512 if(!enif_get_double(env, argv[0], &left)) Badarg(5087,"left");
513 if(!enif_get_double(env, argv[1], &right)) Badarg(5087,"right");
514 if(!enif_get_double(env, argv[2], &bottom)) Badarg(5087,"bottom");
515 if(!enif_get_double(env, argv[3], &top)) Badarg(5087,"top");
516 if(!enif_get_double(env, argv[4], &near_val)) Badarg(5087,"near_val");
517 if(!enif_get_double(env, argv[5], &far_val)) Badarg(5087,"far_val");
518 weglFrustum(left,right,bottom,top,near_val,far_val);
519 }
520
ecb_glViewport(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])521 void ecb_glViewport(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
522 {
523 GLint x;
524 GLint y;
525 GLsizei width;
526 GLsizei height;
527 if(!enif_get_int(env, argv[0], &x)) Badarg(5088,"x");
528 if(!enif_get_int(env, argv[1], &y)) Badarg(5088,"y");
529 if(!enif_get_int(env, argv[2], &width)) Badarg(5088,"width");
530 if(!enif_get_int(env, argv[3], &height)) Badarg(5088,"height");
531 weglViewport(x,y,width,height);
532 }
533
ecb_glPushMatrix(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])534 void ecb_glPushMatrix(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
535 {
536 weglPushMatrix();
537 }
538
ecb_glPopMatrix(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])539 void ecb_glPopMatrix(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
540 {
541 weglPopMatrix();
542 }
543
ecb_glLoadIdentity(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])544 void ecb_glLoadIdentity(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
545 {
546 weglLoadIdentity();
547 }
548
ecb_glLoadMatrixd(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])549 void ecb_glLoadMatrixd(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
550 {
551 GLdouble m[16];
552 {
553 int m_a;
554 const ERL_NIF_TERM *m_t;
555 if(!enif_get_tuple(env, argv[0], &m_a, &m_t)
556 || (m_a != 12 && m_a != 16)) {
557 Badarg(5092,"m");
558 } else {
559 int i1 = 0;
560 if(!enif_get_double(env, m_t[i1++], &m[0])) Badarg(5092,"m");
561 if(!enif_get_double(env, m_t[i1++], &m[1])) Badarg(5092,"m");
562 if(!enif_get_double(env, m_t[i1++], &m[2])) Badarg(5092,"m");
563 if(m_a == 16)
564 if(!enif_get_double(env, m_t[i1++], &m[3])) Badarg(5092,"m");
565 if(!enif_get_double(env, m_t[i1++], &m[4])) Badarg(5092,"m");
566 if(!enif_get_double(env, m_t[i1++], &m[5])) Badarg(5092,"m");
567 if(!enif_get_double(env, m_t[i1++], &m[6])) Badarg(5092,"m");
568 if(m_a == 16)
569 if(!enif_get_double(env, m_t[i1++], &m[7])) Badarg(5092,"m");
570 if(!enif_get_double(env, m_t[i1++], &m[8])) Badarg(5092,"m");
571 if(!enif_get_double(env, m_t[i1++], &m[9])) Badarg(5092,"m");
572 if(!enif_get_double(env, m_t[i1++], &m[10])) Badarg(5092,"m");
573 if(m_a == 16)
574 if(!enif_get_double(env, m_t[i1++], &m[11])) Badarg(5092,"m");
575 if(!enif_get_double(env, m_t[i1++], &m[12])) Badarg(5092,"m");
576 if(!enif_get_double(env, m_t[i1++], &m[13])) Badarg(5092,"m");
577 if(!enif_get_double(env, m_t[i1++], &m[14])) Badarg(5092,"m");
578 if(m_a == 16) {
579 if(!enif_get_double(env, m_t[i1++], &m[15])) Badarg(5092,"m");
580 } else {
581 m[3] = 0.0; m[7] = 0.0; m[11] = 0.0; m[15] = 1.0;
582 }
583 }};
584 weglLoadMatrixd(m);
585 }
586
ecb_glLoadMatrixf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])587 void ecb_glLoadMatrixf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
588 {
589 GLfloat m[16];
590 {
591 int m_a;
592 const ERL_NIF_TERM *m_t;
593 if(!enif_get_tuple(env, argv[0], &m_a, &m_t)
594 || (m_a != 12 && m_a != 16)) {
595 Badarg(5093,"m");
596 } else {
597 int i1 = 0;
598 if(!egl_get_float(env, m_t[i1++], &m[0])) Badarg(5093,"m");
599 if(!egl_get_float(env, m_t[i1++], &m[1])) Badarg(5093,"m");
600 if(!egl_get_float(env, m_t[i1++], &m[2])) Badarg(5093,"m");
601 if(m_a == 16)
602 if(!egl_get_float(env, m_t[i1++], &m[3])) Badarg(5093,"m");
603 if(!egl_get_float(env, m_t[i1++], &m[4])) Badarg(5093,"m");
604 if(!egl_get_float(env, m_t[i1++], &m[5])) Badarg(5093,"m");
605 if(!egl_get_float(env, m_t[i1++], &m[6])) Badarg(5093,"m");
606 if(m_a == 16)
607 if(!egl_get_float(env, m_t[i1++], &m[7])) Badarg(5093,"m");
608 if(!egl_get_float(env, m_t[i1++], &m[8])) Badarg(5093,"m");
609 if(!egl_get_float(env, m_t[i1++], &m[9])) Badarg(5093,"m");
610 if(!egl_get_float(env, m_t[i1++], &m[10])) Badarg(5093,"m");
611 if(m_a == 16)
612 if(!egl_get_float(env, m_t[i1++], &m[11])) Badarg(5093,"m");
613 if(!egl_get_float(env, m_t[i1++], &m[12])) Badarg(5093,"m");
614 if(!egl_get_float(env, m_t[i1++], &m[13])) Badarg(5093,"m");
615 if(!egl_get_float(env, m_t[i1++], &m[14])) Badarg(5093,"m");
616 if(m_a == 16) {
617 if(!egl_get_float(env, m_t[i1++], &m[15])) Badarg(5093,"m");
618 } else {
619 m[3] = 0.0; m[7] = 0.0; m[11] = 0.0; m[15] = 1.0;
620 }
621 }};
622 weglLoadMatrixf(m);
623 }
624
ecb_glMultMatrixd(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])625 void ecb_glMultMatrixd(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
626 {
627 GLdouble m[16];
628 {
629 int m_a;
630 const ERL_NIF_TERM *m_t;
631 if(!enif_get_tuple(env, argv[0], &m_a, &m_t)
632 || (m_a != 12 && m_a != 16)) {
633 Badarg(5094,"m");
634 } else {
635 int i1 = 0;
636 if(!enif_get_double(env, m_t[i1++], &m[0])) Badarg(5094,"m");
637 if(!enif_get_double(env, m_t[i1++], &m[1])) Badarg(5094,"m");
638 if(!enif_get_double(env, m_t[i1++], &m[2])) Badarg(5094,"m");
639 if(m_a == 16)
640 if(!enif_get_double(env, m_t[i1++], &m[3])) Badarg(5094,"m");
641 if(!enif_get_double(env, m_t[i1++], &m[4])) Badarg(5094,"m");
642 if(!enif_get_double(env, m_t[i1++], &m[5])) Badarg(5094,"m");
643 if(!enif_get_double(env, m_t[i1++], &m[6])) Badarg(5094,"m");
644 if(m_a == 16)
645 if(!enif_get_double(env, m_t[i1++], &m[7])) Badarg(5094,"m");
646 if(!enif_get_double(env, m_t[i1++], &m[8])) Badarg(5094,"m");
647 if(!enif_get_double(env, m_t[i1++], &m[9])) Badarg(5094,"m");
648 if(!enif_get_double(env, m_t[i1++], &m[10])) Badarg(5094,"m");
649 if(m_a == 16)
650 if(!enif_get_double(env, m_t[i1++], &m[11])) Badarg(5094,"m");
651 if(!enif_get_double(env, m_t[i1++], &m[12])) Badarg(5094,"m");
652 if(!enif_get_double(env, m_t[i1++], &m[13])) Badarg(5094,"m");
653 if(!enif_get_double(env, m_t[i1++], &m[14])) Badarg(5094,"m");
654 if(m_a == 16) {
655 if(!enif_get_double(env, m_t[i1++], &m[15])) Badarg(5094,"m");
656 } else {
657 m[3] = 0.0; m[7] = 0.0; m[11] = 0.0; m[15] = 1.0;
658 }
659 }};
660 weglMultMatrixd(m);
661 }
662
ecb_glMultMatrixf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])663 void ecb_glMultMatrixf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
664 {
665 GLfloat m[16];
666 {
667 int m_a;
668 const ERL_NIF_TERM *m_t;
669 if(!enif_get_tuple(env, argv[0], &m_a, &m_t)
670 || (m_a != 12 && m_a != 16)) {
671 Badarg(5095,"m");
672 } else {
673 int i1 = 0;
674 if(!egl_get_float(env, m_t[i1++], &m[0])) Badarg(5095,"m");
675 if(!egl_get_float(env, m_t[i1++], &m[1])) Badarg(5095,"m");
676 if(!egl_get_float(env, m_t[i1++], &m[2])) Badarg(5095,"m");
677 if(m_a == 16)
678 if(!egl_get_float(env, m_t[i1++], &m[3])) Badarg(5095,"m");
679 if(!egl_get_float(env, m_t[i1++], &m[4])) Badarg(5095,"m");
680 if(!egl_get_float(env, m_t[i1++], &m[5])) Badarg(5095,"m");
681 if(!egl_get_float(env, m_t[i1++], &m[6])) Badarg(5095,"m");
682 if(m_a == 16)
683 if(!egl_get_float(env, m_t[i1++], &m[7])) Badarg(5095,"m");
684 if(!egl_get_float(env, m_t[i1++], &m[8])) Badarg(5095,"m");
685 if(!egl_get_float(env, m_t[i1++], &m[9])) Badarg(5095,"m");
686 if(!egl_get_float(env, m_t[i1++], &m[10])) Badarg(5095,"m");
687 if(m_a == 16)
688 if(!egl_get_float(env, m_t[i1++], &m[11])) Badarg(5095,"m");
689 if(!egl_get_float(env, m_t[i1++], &m[12])) Badarg(5095,"m");
690 if(!egl_get_float(env, m_t[i1++], &m[13])) Badarg(5095,"m");
691 if(!egl_get_float(env, m_t[i1++], &m[14])) Badarg(5095,"m");
692 if(m_a == 16) {
693 if(!egl_get_float(env, m_t[i1++], &m[15])) Badarg(5095,"m");
694 } else {
695 m[3] = 0.0; m[7] = 0.0; m[11] = 0.0; m[15] = 1.0;
696 }
697 }};
698 weglMultMatrixf(m);
699 }
700
ecb_glRotated(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])701 void ecb_glRotated(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
702 {
703 GLdouble angle;
704 GLdouble x;
705 GLdouble y;
706 GLdouble z;
707 if(!enif_get_double(env, argv[0], &angle)) Badarg(5096,"angle");
708 if(!enif_get_double(env, argv[1], &x)) Badarg(5096,"x");
709 if(!enif_get_double(env, argv[2], &y)) Badarg(5096,"y");
710 if(!enif_get_double(env, argv[3], &z)) Badarg(5096,"z");
711 weglRotated(angle,x,y,z);
712 }
713
ecb_glRotatef(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])714 void ecb_glRotatef(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
715 {
716 GLfloat angle;
717 GLfloat x;
718 GLfloat y;
719 GLfloat z;
720 if(!egl_get_float(env, argv[0], &angle)) Badarg(5097,"angle");
721 if(!egl_get_float(env, argv[1], &x)) Badarg(5097,"x");
722 if(!egl_get_float(env, argv[2], &y)) Badarg(5097,"y");
723 if(!egl_get_float(env, argv[3], &z)) Badarg(5097,"z");
724 weglRotatef(angle,x,y,z);
725 }
726
ecb_glScaled(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])727 void ecb_glScaled(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
728 {
729 GLdouble x;
730 GLdouble y;
731 GLdouble z;
732 if(!enif_get_double(env, argv[0], &x)) Badarg(5098,"x");
733 if(!enif_get_double(env, argv[1], &y)) Badarg(5098,"y");
734 if(!enif_get_double(env, argv[2], &z)) Badarg(5098,"z");
735 weglScaled(x,y,z);
736 }
737
ecb_glScalef(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])738 void ecb_glScalef(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
739 {
740 GLfloat x;
741 GLfloat y;
742 GLfloat z;
743 if(!egl_get_float(env, argv[0], &x)) Badarg(5099,"x");
744 if(!egl_get_float(env, argv[1], &y)) Badarg(5099,"y");
745 if(!egl_get_float(env, argv[2], &z)) Badarg(5099,"z");
746 weglScalef(x,y,z);
747 }
748
ecb_glTranslated(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])749 void ecb_glTranslated(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
750 {
751 GLdouble x;
752 GLdouble y;
753 GLdouble z;
754 if(!enif_get_double(env, argv[0], &x)) Badarg(5100,"x");
755 if(!enif_get_double(env, argv[1], &y)) Badarg(5100,"y");
756 if(!enif_get_double(env, argv[2], &z)) Badarg(5100,"z");
757 weglTranslated(x,y,z);
758 }
759
ecb_glTranslatef(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])760 void ecb_glTranslatef(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
761 {
762 GLfloat x;
763 GLfloat y;
764 GLfloat z;
765 if(!egl_get_float(env, argv[0], &x)) Badarg(5101,"x");
766 if(!egl_get_float(env, argv[1], &y)) Badarg(5101,"y");
767 if(!egl_get_float(env, argv[2], &z)) Badarg(5101,"z");
768 weglTranslatef(x,y,z);
769 }
770
ecb_glIsList(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])771 void ecb_glIsList(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
772 {
773 GLboolean result;
774 ERL_NIF_TERM reply;
775 GLuint list;
776 if(!enif_get_uint(env, argv[0], &list)) Badarg(5102,"list");
777 result = weglIsList(list);
778 reply = enif_make_int(env, result);
779 enif_send(NULL, self, env,
780 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
781 }
782
ecb_glDeleteLists(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])783 void ecb_glDeleteLists(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
784 {
785 GLuint list;
786 GLsizei range;
787 if(!enif_get_uint(env, argv[0], &list)) Badarg(5103,"list");
788 if(!enif_get_int(env, argv[1], &range)) Badarg(5103,"range");
789 weglDeleteLists(list,range);
790 }
791
ecb_glGenLists(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])792 void ecb_glGenLists(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
793 {
794 GLuint result;
795 ERL_NIF_TERM reply;
796 GLsizei range;
797 if(!enif_get_int(env, argv[0], &range)) Badarg(5104,"range");
798 result = weglGenLists(range);
799 reply = enif_make_int(env, result);
800 enif_send(NULL, self, env,
801 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
802 }
803
ecb_glNewList(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])804 void ecb_glNewList(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
805 {
806 GLuint list;
807 GLenum mode;
808 if(!enif_get_uint(env, argv[0], &list)) Badarg(5105,"list");
809 if(!enif_get_uint(env, argv[1], &mode)) Badarg(5105,"mode");
810 weglNewList(list,mode);
811 }
812
ecb_glEndList(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])813 void ecb_glEndList(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
814 {
815 weglEndList();
816 }
817
ecb_glCallList(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])818 void ecb_glCallList(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
819 {
820 GLuint list;
821 if(!enif_get_uint(env, argv[0], &list)) Badarg(5107,"list");
822 weglCallList(list);
823 }
824
ecb_glCallLists(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])825 void ecb_glCallLists(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
826 {
827 GLsizei n;
828 GLuint *lists;
829 if(!enif_get_int(env, argv[0], &n)) Badarg(5108,"n");
830 if(!enif_is_list(env, argv[1])) Badarg(5108, "lists")
831 else {
832 ERL_NIF_TERM lists_l, lists_h, lists_t;
833 std::vector <GLuint> lists_vec;
834 GLuint lists_tmp;
835 lists_l = argv[1];
836 while(enif_get_list_cell(env, lists_l, &lists_h, &lists_t)) {
837 if(!enif_get_uint(env, lists_h, &lists_tmp)) Badarg(5108,"lists");
838 lists_vec.push_back(lists_tmp);
839 lists_l = lists_t;
840 };
841 lists = lists_vec.data();
842 }
843 weglCallLists(n,GL_UNSIGNED_INT,lists);
844 }
845
ecb_glListBase(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])846 void ecb_glListBase(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
847 {
848 GLuint base;
849 if(!enif_get_uint(env, argv[0], &base)) Badarg(5109,"base");
850 weglListBase(base);
851 }
852
ecb_glBegin(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])853 void ecb_glBegin(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
854 {
855 GLenum mode;
856 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5110,"mode");
857 weglBegin(mode);
858 }
859
ecb_glEnd(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])860 void ecb_glEnd(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
861 {
862 weglEnd();
863 }
864
ecb_glVertex2d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])865 void ecb_glVertex2d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
866 {
867 GLdouble x;
868 GLdouble y;
869 if(!enif_get_double(env, argv[0], &x)) Badarg(5112,"x");
870 if(!enif_get_double(env, argv[1], &y)) Badarg(5112,"y");
871 weglVertex2d(x,y);
872 }
873
ecb_glVertex2f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])874 void ecb_glVertex2f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
875 {
876 GLfloat x;
877 GLfloat y;
878 if(!egl_get_float(env, argv[0], &x)) Badarg(5113,"x");
879 if(!egl_get_float(env, argv[1], &y)) Badarg(5113,"y");
880 weglVertex2f(x,y);
881 }
882
ecb_glVertex2i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])883 void ecb_glVertex2i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
884 {
885 GLint x;
886 GLint y;
887 if(!enif_get_int(env, argv[0], &x)) Badarg(5114,"x");
888 if(!enif_get_int(env, argv[1], &y)) Badarg(5114,"y");
889 weglVertex2i(x,y);
890 }
891
ecb_glVertex2s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])892 void ecb_glVertex2s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
893 {
894 GLshort x;
895 GLshort y;
896 if(!egl_get_short(env, argv[0], &x)) Badarg(5115,"x");
897 if(!egl_get_short(env, argv[1], &y)) Badarg(5115,"y");
898 weglVertex2s(x,y);
899 }
900
ecb_glVertex3d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])901 void ecb_glVertex3d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
902 {
903 GLdouble x;
904 GLdouble y;
905 GLdouble z;
906 if(!enif_get_double(env, argv[0], &x)) Badarg(5116,"x");
907 if(!enif_get_double(env, argv[1], &y)) Badarg(5116,"y");
908 if(!enif_get_double(env, argv[2], &z)) Badarg(5116,"z");
909 weglVertex3d(x,y,z);
910 }
911
ecb_glVertex3f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])912 void ecb_glVertex3f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
913 {
914 GLfloat x;
915 GLfloat y;
916 GLfloat z;
917 if(!egl_get_float(env, argv[0], &x)) Badarg(5117,"x");
918 if(!egl_get_float(env, argv[1], &y)) Badarg(5117,"y");
919 if(!egl_get_float(env, argv[2], &z)) Badarg(5117,"z");
920 weglVertex3f(x,y,z);
921 }
922
ecb_glVertex3i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])923 void ecb_glVertex3i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
924 {
925 GLint x;
926 GLint y;
927 GLint z;
928 if(!enif_get_int(env, argv[0], &x)) Badarg(5118,"x");
929 if(!enif_get_int(env, argv[1], &y)) Badarg(5118,"y");
930 if(!enif_get_int(env, argv[2], &z)) Badarg(5118,"z");
931 weglVertex3i(x,y,z);
932 }
933
ecb_glVertex3s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])934 void ecb_glVertex3s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
935 {
936 GLshort x;
937 GLshort y;
938 GLshort z;
939 if(!egl_get_short(env, argv[0], &x)) Badarg(5119,"x");
940 if(!egl_get_short(env, argv[1], &y)) Badarg(5119,"y");
941 if(!egl_get_short(env, argv[2], &z)) Badarg(5119,"z");
942 weglVertex3s(x,y,z);
943 }
944
ecb_glVertex4d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])945 void ecb_glVertex4d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
946 {
947 GLdouble x;
948 GLdouble y;
949 GLdouble z;
950 GLdouble w;
951 if(!enif_get_double(env, argv[0], &x)) Badarg(5120,"x");
952 if(!enif_get_double(env, argv[1], &y)) Badarg(5120,"y");
953 if(!enif_get_double(env, argv[2], &z)) Badarg(5120,"z");
954 if(!enif_get_double(env, argv[3], &w)) Badarg(5120,"w");
955 weglVertex4d(x,y,z,w);
956 }
957
ecb_glVertex4f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])958 void ecb_glVertex4f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
959 {
960 GLfloat x;
961 GLfloat y;
962 GLfloat z;
963 GLfloat w;
964 if(!egl_get_float(env, argv[0], &x)) Badarg(5121,"x");
965 if(!egl_get_float(env, argv[1], &y)) Badarg(5121,"y");
966 if(!egl_get_float(env, argv[2], &z)) Badarg(5121,"z");
967 if(!egl_get_float(env, argv[3], &w)) Badarg(5121,"w");
968 weglVertex4f(x,y,z,w);
969 }
970
ecb_glVertex4i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])971 void ecb_glVertex4i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
972 {
973 GLint x;
974 GLint y;
975 GLint z;
976 GLint w;
977 if(!enif_get_int(env, argv[0], &x)) Badarg(5122,"x");
978 if(!enif_get_int(env, argv[1], &y)) Badarg(5122,"y");
979 if(!enif_get_int(env, argv[2], &z)) Badarg(5122,"z");
980 if(!enif_get_int(env, argv[3], &w)) Badarg(5122,"w");
981 weglVertex4i(x,y,z,w);
982 }
983
ecb_glVertex4s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])984 void ecb_glVertex4s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
985 {
986 GLshort x;
987 GLshort y;
988 GLshort z;
989 GLshort w;
990 if(!egl_get_short(env, argv[0], &x)) Badarg(5123,"x");
991 if(!egl_get_short(env, argv[1], &y)) Badarg(5123,"y");
992 if(!egl_get_short(env, argv[2], &z)) Badarg(5123,"z");
993 if(!egl_get_short(env, argv[3], &w)) Badarg(5123,"w");
994 weglVertex4s(x,y,z,w);
995 }
996
ecb_glNormal3b(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])997 void ecb_glNormal3b(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
998 {
999 GLbyte nx;
1000 GLbyte ny;
1001 GLbyte nz;
1002 if(!egl_get_byte(env, argv[0], &nx)) Badarg(5124,"nx");
1003 if(!egl_get_byte(env, argv[1], &ny)) Badarg(5124,"ny");
1004 if(!egl_get_byte(env, argv[2], &nz)) Badarg(5124,"nz");
1005 weglNormal3b(nx,ny,nz);
1006 }
1007
ecb_glNormal3d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1008 void ecb_glNormal3d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1009 {
1010 GLdouble nx;
1011 GLdouble ny;
1012 GLdouble nz;
1013 if(!enif_get_double(env, argv[0], &nx)) Badarg(5125,"nx");
1014 if(!enif_get_double(env, argv[1], &ny)) Badarg(5125,"ny");
1015 if(!enif_get_double(env, argv[2], &nz)) Badarg(5125,"nz");
1016 weglNormal3d(nx,ny,nz);
1017 }
1018
ecb_glNormal3f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1019 void ecb_glNormal3f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1020 {
1021 GLfloat nx;
1022 GLfloat ny;
1023 GLfloat nz;
1024 if(!egl_get_float(env, argv[0], &nx)) Badarg(5126,"nx");
1025 if(!egl_get_float(env, argv[1], &ny)) Badarg(5126,"ny");
1026 if(!egl_get_float(env, argv[2], &nz)) Badarg(5126,"nz");
1027 weglNormal3f(nx,ny,nz);
1028 }
1029
ecb_glNormal3i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1030 void ecb_glNormal3i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1031 {
1032 GLint nx;
1033 GLint ny;
1034 GLint nz;
1035 if(!enif_get_int(env, argv[0], &nx)) Badarg(5127,"nx");
1036 if(!enif_get_int(env, argv[1], &ny)) Badarg(5127,"ny");
1037 if(!enif_get_int(env, argv[2], &nz)) Badarg(5127,"nz");
1038 weglNormal3i(nx,ny,nz);
1039 }
1040
ecb_glNormal3s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1041 void ecb_glNormal3s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1042 {
1043 GLshort nx;
1044 GLshort ny;
1045 GLshort nz;
1046 if(!egl_get_short(env, argv[0], &nx)) Badarg(5128,"nx");
1047 if(!egl_get_short(env, argv[1], &ny)) Badarg(5128,"ny");
1048 if(!egl_get_short(env, argv[2], &nz)) Badarg(5128,"nz");
1049 weglNormal3s(nx,ny,nz);
1050 }
1051
ecb_glIndexd(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1052 void ecb_glIndexd(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1053 {
1054 GLdouble c;
1055 if(!enif_get_double(env, argv[0], &c)) Badarg(5129,"c");
1056 weglIndexd(c);
1057 }
1058
ecb_glIndexf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1059 void ecb_glIndexf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1060 {
1061 GLfloat c;
1062 if(!egl_get_float(env, argv[0], &c)) Badarg(5130,"c");
1063 weglIndexf(c);
1064 }
1065
ecb_glIndexi(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1066 void ecb_glIndexi(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1067 {
1068 GLint c;
1069 if(!enif_get_int(env, argv[0], &c)) Badarg(5131,"c");
1070 weglIndexi(c);
1071 }
1072
ecb_glIndexs(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1073 void ecb_glIndexs(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1074 {
1075 GLshort c;
1076 if(!egl_get_short(env, argv[0], &c)) Badarg(5132,"c");
1077 weglIndexs(c);
1078 }
1079
ecb_glIndexub(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1080 void ecb_glIndexub(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1081 {
1082 GLubyte c;
1083 if(!egl_get_ubyte(env, argv[0], &c)) Badarg(5133,"c");
1084 weglIndexub(c);
1085 }
1086
ecb_glColor3b(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1087 void ecb_glColor3b(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1088 {
1089 GLbyte red;
1090 GLbyte green;
1091 GLbyte blue;
1092 if(!egl_get_byte(env, argv[0], &red)) Badarg(5134,"red");
1093 if(!egl_get_byte(env, argv[1], &green)) Badarg(5134,"green");
1094 if(!egl_get_byte(env, argv[2], &blue)) Badarg(5134,"blue");
1095 weglColor3b(red,green,blue);
1096 }
1097
ecb_glColor3d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1098 void ecb_glColor3d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1099 {
1100 GLdouble red;
1101 GLdouble green;
1102 GLdouble blue;
1103 if(!enif_get_double(env, argv[0], &red)) Badarg(5135,"red");
1104 if(!enif_get_double(env, argv[1], &green)) Badarg(5135,"green");
1105 if(!enif_get_double(env, argv[2], &blue)) Badarg(5135,"blue");
1106 weglColor3d(red,green,blue);
1107 }
1108
ecb_glColor3f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1109 void ecb_glColor3f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1110 {
1111 GLfloat red;
1112 GLfloat green;
1113 GLfloat blue;
1114 if(!egl_get_float(env, argv[0], &red)) Badarg(5136,"red");
1115 if(!egl_get_float(env, argv[1], &green)) Badarg(5136,"green");
1116 if(!egl_get_float(env, argv[2], &blue)) Badarg(5136,"blue");
1117 weglColor3f(red,green,blue);
1118 }
1119
ecb_glColor3i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1120 void ecb_glColor3i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1121 {
1122 GLint red;
1123 GLint green;
1124 GLint blue;
1125 if(!enif_get_int(env, argv[0], &red)) Badarg(5137,"red");
1126 if(!enif_get_int(env, argv[1], &green)) Badarg(5137,"green");
1127 if(!enif_get_int(env, argv[2], &blue)) Badarg(5137,"blue");
1128 weglColor3i(red,green,blue);
1129 }
1130
ecb_glColor3s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1131 void ecb_glColor3s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1132 {
1133 GLshort red;
1134 GLshort green;
1135 GLshort blue;
1136 if(!egl_get_short(env, argv[0], &red)) Badarg(5138,"red");
1137 if(!egl_get_short(env, argv[1], &green)) Badarg(5138,"green");
1138 if(!egl_get_short(env, argv[2], &blue)) Badarg(5138,"blue");
1139 weglColor3s(red,green,blue);
1140 }
1141
ecb_glColor3ub(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1142 void ecb_glColor3ub(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1143 {
1144 GLubyte red;
1145 GLubyte green;
1146 GLubyte blue;
1147 if(!egl_get_ubyte(env, argv[0], &red)) Badarg(5139,"red");
1148 if(!egl_get_ubyte(env, argv[1], &green)) Badarg(5139,"green");
1149 if(!egl_get_ubyte(env, argv[2], &blue)) Badarg(5139,"blue");
1150 weglColor3ub(red,green,blue);
1151 }
1152
ecb_glColor3ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1153 void ecb_glColor3ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1154 {
1155 GLuint red;
1156 GLuint green;
1157 GLuint blue;
1158 if(!enif_get_uint(env, argv[0], &red)) Badarg(5140,"red");
1159 if(!enif_get_uint(env, argv[1], &green)) Badarg(5140,"green");
1160 if(!enif_get_uint(env, argv[2], &blue)) Badarg(5140,"blue");
1161 weglColor3ui(red,green,blue);
1162 }
1163
ecb_glColor3us(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1164 void ecb_glColor3us(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1165 {
1166 GLushort red;
1167 GLushort green;
1168 GLushort blue;
1169 if(!egl_get_ushort(env, argv[0], &red)) Badarg(5141,"red");
1170 if(!egl_get_ushort(env, argv[1], &green)) Badarg(5141,"green");
1171 if(!egl_get_ushort(env, argv[2], &blue)) Badarg(5141,"blue");
1172 weglColor3us(red,green,blue);
1173 }
1174
ecb_glColor4b(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1175 void ecb_glColor4b(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1176 {
1177 GLbyte red;
1178 GLbyte green;
1179 GLbyte blue;
1180 GLbyte alpha;
1181 if(!egl_get_byte(env, argv[0], &red)) Badarg(5142,"red");
1182 if(!egl_get_byte(env, argv[1], &green)) Badarg(5142,"green");
1183 if(!egl_get_byte(env, argv[2], &blue)) Badarg(5142,"blue");
1184 if(!egl_get_byte(env, argv[3], &alpha)) Badarg(5142,"alpha");
1185 weglColor4b(red,green,blue,alpha);
1186 }
1187
ecb_glColor4d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1188 void ecb_glColor4d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1189 {
1190 GLdouble red;
1191 GLdouble green;
1192 GLdouble blue;
1193 GLdouble alpha;
1194 if(!enif_get_double(env, argv[0], &red)) Badarg(5143,"red");
1195 if(!enif_get_double(env, argv[1], &green)) Badarg(5143,"green");
1196 if(!enif_get_double(env, argv[2], &blue)) Badarg(5143,"blue");
1197 if(!enif_get_double(env, argv[3], &alpha)) Badarg(5143,"alpha");
1198 weglColor4d(red,green,blue,alpha);
1199 }
1200
ecb_glColor4f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1201 void ecb_glColor4f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1202 {
1203 GLfloat red;
1204 GLfloat green;
1205 GLfloat blue;
1206 GLfloat alpha;
1207 if(!egl_get_float(env, argv[0], &red)) Badarg(5144,"red");
1208 if(!egl_get_float(env, argv[1], &green)) Badarg(5144,"green");
1209 if(!egl_get_float(env, argv[2], &blue)) Badarg(5144,"blue");
1210 if(!egl_get_float(env, argv[3], &alpha)) Badarg(5144,"alpha");
1211 weglColor4f(red,green,blue,alpha);
1212 }
1213
ecb_glColor4i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1214 void ecb_glColor4i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1215 {
1216 GLint red;
1217 GLint green;
1218 GLint blue;
1219 GLint alpha;
1220 if(!enif_get_int(env, argv[0], &red)) Badarg(5145,"red");
1221 if(!enif_get_int(env, argv[1], &green)) Badarg(5145,"green");
1222 if(!enif_get_int(env, argv[2], &blue)) Badarg(5145,"blue");
1223 if(!enif_get_int(env, argv[3], &alpha)) Badarg(5145,"alpha");
1224 weglColor4i(red,green,blue,alpha);
1225 }
1226
ecb_glColor4s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1227 void ecb_glColor4s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1228 {
1229 GLshort red;
1230 GLshort green;
1231 GLshort blue;
1232 GLshort alpha;
1233 if(!egl_get_short(env, argv[0], &red)) Badarg(5146,"red");
1234 if(!egl_get_short(env, argv[1], &green)) Badarg(5146,"green");
1235 if(!egl_get_short(env, argv[2], &blue)) Badarg(5146,"blue");
1236 if(!egl_get_short(env, argv[3], &alpha)) Badarg(5146,"alpha");
1237 weglColor4s(red,green,blue,alpha);
1238 }
1239
ecb_glColor4ub(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1240 void ecb_glColor4ub(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1241 {
1242 GLubyte red;
1243 GLubyte green;
1244 GLubyte blue;
1245 GLubyte alpha;
1246 if(!egl_get_ubyte(env, argv[0], &red)) Badarg(5147,"red");
1247 if(!egl_get_ubyte(env, argv[1], &green)) Badarg(5147,"green");
1248 if(!egl_get_ubyte(env, argv[2], &blue)) Badarg(5147,"blue");
1249 if(!egl_get_ubyte(env, argv[3], &alpha)) Badarg(5147,"alpha");
1250 weglColor4ub(red,green,blue,alpha);
1251 }
1252
ecb_glColor4ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1253 void ecb_glColor4ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1254 {
1255 GLuint red;
1256 GLuint green;
1257 GLuint blue;
1258 GLuint alpha;
1259 if(!enif_get_uint(env, argv[0], &red)) Badarg(5148,"red");
1260 if(!enif_get_uint(env, argv[1], &green)) Badarg(5148,"green");
1261 if(!enif_get_uint(env, argv[2], &blue)) Badarg(5148,"blue");
1262 if(!enif_get_uint(env, argv[3], &alpha)) Badarg(5148,"alpha");
1263 weglColor4ui(red,green,blue,alpha);
1264 }
1265
ecb_glColor4us(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1266 void ecb_glColor4us(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1267 {
1268 GLushort red;
1269 GLushort green;
1270 GLushort blue;
1271 GLushort alpha;
1272 if(!egl_get_ushort(env, argv[0], &red)) Badarg(5149,"red");
1273 if(!egl_get_ushort(env, argv[1], &green)) Badarg(5149,"green");
1274 if(!egl_get_ushort(env, argv[2], &blue)) Badarg(5149,"blue");
1275 if(!egl_get_ushort(env, argv[3], &alpha)) Badarg(5149,"alpha");
1276 weglColor4us(red,green,blue,alpha);
1277 }
1278
ecb_glTexCoord1d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1279 void ecb_glTexCoord1d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1280 {
1281 GLdouble s;
1282 if(!enif_get_double(env, argv[0], &s)) Badarg(5150,"s");
1283 weglTexCoord1d(s);
1284 }
1285
ecb_glTexCoord1f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1286 void ecb_glTexCoord1f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1287 {
1288 GLfloat s;
1289 if(!egl_get_float(env, argv[0], &s)) Badarg(5151,"s");
1290 weglTexCoord1f(s);
1291 }
1292
ecb_glTexCoord1i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1293 void ecb_glTexCoord1i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1294 {
1295 GLint s;
1296 if(!enif_get_int(env, argv[0], &s)) Badarg(5152,"s");
1297 weglTexCoord1i(s);
1298 }
1299
ecb_glTexCoord1s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1300 void ecb_glTexCoord1s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1301 {
1302 GLshort s;
1303 if(!egl_get_short(env, argv[0], &s)) Badarg(5153,"s");
1304 weglTexCoord1s(s);
1305 }
1306
ecb_glTexCoord2d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1307 void ecb_glTexCoord2d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1308 {
1309 GLdouble s;
1310 GLdouble t;
1311 if(!enif_get_double(env, argv[0], &s)) Badarg(5154,"s");
1312 if(!enif_get_double(env, argv[1], &t)) Badarg(5154,"t");
1313 weglTexCoord2d(s,t);
1314 }
1315
ecb_glTexCoord2f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1316 void ecb_glTexCoord2f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1317 {
1318 GLfloat s;
1319 GLfloat t;
1320 if(!egl_get_float(env, argv[0], &s)) Badarg(5155,"s");
1321 if(!egl_get_float(env, argv[1], &t)) Badarg(5155,"t");
1322 weglTexCoord2f(s,t);
1323 }
1324
ecb_glTexCoord2i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1325 void ecb_glTexCoord2i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1326 {
1327 GLint s;
1328 GLint t;
1329 if(!enif_get_int(env, argv[0], &s)) Badarg(5156,"s");
1330 if(!enif_get_int(env, argv[1], &t)) Badarg(5156,"t");
1331 weglTexCoord2i(s,t);
1332 }
1333
ecb_glTexCoord2s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1334 void ecb_glTexCoord2s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1335 {
1336 GLshort s;
1337 GLshort t;
1338 if(!egl_get_short(env, argv[0], &s)) Badarg(5157,"s");
1339 if(!egl_get_short(env, argv[1], &t)) Badarg(5157,"t");
1340 weglTexCoord2s(s,t);
1341 }
1342
ecb_glTexCoord3d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1343 void ecb_glTexCoord3d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1344 {
1345 GLdouble s;
1346 GLdouble t;
1347 GLdouble r;
1348 if(!enif_get_double(env, argv[0], &s)) Badarg(5158,"s");
1349 if(!enif_get_double(env, argv[1], &t)) Badarg(5158,"t");
1350 if(!enif_get_double(env, argv[2], &r)) Badarg(5158,"r");
1351 weglTexCoord3d(s,t,r);
1352 }
1353
ecb_glTexCoord3f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1354 void ecb_glTexCoord3f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1355 {
1356 GLfloat s;
1357 GLfloat t;
1358 GLfloat r;
1359 if(!egl_get_float(env, argv[0], &s)) Badarg(5159,"s");
1360 if(!egl_get_float(env, argv[1], &t)) Badarg(5159,"t");
1361 if(!egl_get_float(env, argv[2], &r)) Badarg(5159,"r");
1362 weglTexCoord3f(s,t,r);
1363 }
1364
ecb_glTexCoord3i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1365 void ecb_glTexCoord3i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1366 {
1367 GLint s;
1368 GLint t;
1369 GLint r;
1370 if(!enif_get_int(env, argv[0], &s)) Badarg(5160,"s");
1371 if(!enif_get_int(env, argv[1], &t)) Badarg(5160,"t");
1372 if(!enif_get_int(env, argv[2], &r)) Badarg(5160,"r");
1373 weglTexCoord3i(s,t,r);
1374 }
1375
ecb_glTexCoord3s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1376 void ecb_glTexCoord3s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1377 {
1378 GLshort s;
1379 GLshort t;
1380 GLshort r;
1381 if(!egl_get_short(env, argv[0], &s)) Badarg(5161,"s");
1382 if(!egl_get_short(env, argv[1], &t)) Badarg(5161,"t");
1383 if(!egl_get_short(env, argv[2], &r)) Badarg(5161,"r");
1384 weglTexCoord3s(s,t,r);
1385 }
1386
ecb_glTexCoord4d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1387 void ecb_glTexCoord4d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1388 {
1389 GLdouble s;
1390 GLdouble t;
1391 GLdouble r;
1392 GLdouble q;
1393 if(!enif_get_double(env, argv[0], &s)) Badarg(5162,"s");
1394 if(!enif_get_double(env, argv[1], &t)) Badarg(5162,"t");
1395 if(!enif_get_double(env, argv[2], &r)) Badarg(5162,"r");
1396 if(!enif_get_double(env, argv[3], &q)) Badarg(5162,"q");
1397 weglTexCoord4d(s,t,r,q);
1398 }
1399
ecb_glTexCoord4f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1400 void ecb_glTexCoord4f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1401 {
1402 GLfloat s;
1403 GLfloat t;
1404 GLfloat r;
1405 GLfloat q;
1406 if(!egl_get_float(env, argv[0], &s)) Badarg(5163,"s");
1407 if(!egl_get_float(env, argv[1], &t)) Badarg(5163,"t");
1408 if(!egl_get_float(env, argv[2], &r)) Badarg(5163,"r");
1409 if(!egl_get_float(env, argv[3], &q)) Badarg(5163,"q");
1410 weglTexCoord4f(s,t,r,q);
1411 }
1412
ecb_glTexCoord4i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1413 void ecb_glTexCoord4i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1414 {
1415 GLint s;
1416 GLint t;
1417 GLint r;
1418 GLint q;
1419 if(!enif_get_int(env, argv[0], &s)) Badarg(5164,"s");
1420 if(!enif_get_int(env, argv[1], &t)) Badarg(5164,"t");
1421 if(!enif_get_int(env, argv[2], &r)) Badarg(5164,"r");
1422 if(!enif_get_int(env, argv[3], &q)) Badarg(5164,"q");
1423 weglTexCoord4i(s,t,r,q);
1424 }
1425
ecb_glTexCoord4s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1426 void ecb_glTexCoord4s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1427 {
1428 GLshort s;
1429 GLshort t;
1430 GLshort r;
1431 GLshort q;
1432 if(!egl_get_short(env, argv[0], &s)) Badarg(5165,"s");
1433 if(!egl_get_short(env, argv[1], &t)) Badarg(5165,"t");
1434 if(!egl_get_short(env, argv[2], &r)) Badarg(5165,"r");
1435 if(!egl_get_short(env, argv[3], &q)) Badarg(5165,"q");
1436 weglTexCoord4s(s,t,r,q);
1437 }
1438
ecb_glRasterPos2d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1439 void ecb_glRasterPos2d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1440 {
1441 GLdouble x;
1442 GLdouble y;
1443 if(!enif_get_double(env, argv[0], &x)) Badarg(5166,"x");
1444 if(!enif_get_double(env, argv[1], &y)) Badarg(5166,"y");
1445 weglRasterPos2d(x,y);
1446 }
1447
ecb_glRasterPos2f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1448 void ecb_glRasterPos2f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1449 {
1450 GLfloat x;
1451 GLfloat y;
1452 if(!egl_get_float(env, argv[0], &x)) Badarg(5167,"x");
1453 if(!egl_get_float(env, argv[1], &y)) Badarg(5167,"y");
1454 weglRasterPos2f(x,y);
1455 }
1456
ecb_glRasterPos2i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1457 void ecb_glRasterPos2i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1458 {
1459 GLint x;
1460 GLint y;
1461 if(!enif_get_int(env, argv[0], &x)) Badarg(5168,"x");
1462 if(!enif_get_int(env, argv[1], &y)) Badarg(5168,"y");
1463 weglRasterPos2i(x,y);
1464 }
1465
ecb_glRasterPos2s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1466 void ecb_glRasterPos2s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1467 {
1468 GLshort x;
1469 GLshort y;
1470 if(!egl_get_short(env, argv[0], &x)) Badarg(5169,"x");
1471 if(!egl_get_short(env, argv[1], &y)) Badarg(5169,"y");
1472 weglRasterPos2s(x,y);
1473 }
1474
ecb_glRasterPos3d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1475 void ecb_glRasterPos3d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1476 {
1477 GLdouble x;
1478 GLdouble y;
1479 GLdouble z;
1480 if(!enif_get_double(env, argv[0], &x)) Badarg(5170,"x");
1481 if(!enif_get_double(env, argv[1], &y)) Badarg(5170,"y");
1482 if(!enif_get_double(env, argv[2], &z)) Badarg(5170,"z");
1483 weglRasterPos3d(x,y,z);
1484 }
1485
ecb_glRasterPos3f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1486 void ecb_glRasterPos3f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1487 {
1488 GLfloat x;
1489 GLfloat y;
1490 GLfloat z;
1491 if(!egl_get_float(env, argv[0], &x)) Badarg(5171,"x");
1492 if(!egl_get_float(env, argv[1], &y)) Badarg(5171,"y");
1493 if(!egl_get_float(env, argv[2], &z)) Badarg(5171,"z");
1494 weglRasterPos3f(x,y,z);
1495 }
1496
ecb_glRasterPos3i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1497 void ecb_glRasterPos3i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1498 {
1499 GLint x;
1500 GLint y;
1501 GLint z;
1502 if(!enif_get_int(env, argv[0], &x)) Badarg(5172,"x");
1503 if(!enif_get_int(env, argv[1], &y)) Badarg(5172,"y");
1504 if(!enif_get_int(env, argv[2], &z)) Badarg(5172,"z");
1505 weglRasterPos3i(x,y,z);
1506 }
1507
ecb_glRasterPos3s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1508 void ecb_glRasterPos3s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1509 {
1510 GLshort x;
1511 GLshort y;
1512 GLshort z;
1513 if(!egl_get_short(env, argv[0], &x)) Badarg(5173,"x");
1514 if(!egl_get_short(env, argv[1], &y)) Badarg(5173,"y");
1515 if(!egl_get_short(env, argv[2], &z)) Badarg(5173,"z");
1516 weglRasterPos3s(x,y,z);
1517 }
1518
ecb_glRasterPos4d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1519 void ecb_glRasterPos4d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1520 {
1521 GLdouble x;
1522 GLdouble y;
1523 GLdouble z;
1524 GLdouble w;
1525 if(!enif_get_double(env, argv[0], &x)) Badarg(5174,"x");
1526 if(!enif_get_double(env, argv[1], &y)) Badarg(5174,"y");
1527 if(!enif_get_double(env, argv[2], &z)) Badarg(5174,"z");
1528 if(!enif_get_double(env, argv[3], &w)) Badarg(5174,"w");
1529 weglRasterPos4d(x,y,z,w);
1530 }
1531
ecb_glRasterPos4f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1532 void ecb_glRasterPos4f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1533 {
1534 GLfloat x;
1535 GLfloat y;
1536 GLfloat z;
1537 GLfloat w;
1538 if(!egl_get_float(env, argv[0], &x)) Badarg(5175,"x");
1539 if(!egl_get_float(env, argv[1], &y)) Badarg(5175,"y");
1540 if(!egl_get_float(env, argv[2], &z)) Badarg(5175,"z");
1541 if(!egl_get_float(env, argv[3], &w)) Badarg(5175,"w");
1542 weglRasterPos4f(x,y,z,w);
1543 }
1544
ecb_glRasterPos4i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1545 void ecb_glRasterPos4i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1546 {
1547 GLint x;
1548 GLint y;
1549 GLint z;
1550 GLint w;
1551 if(!enif_get_int(env, argv[0], &x)) Badarg(5176,"x");
1552 if(!enif_get_int(env, argv[1], &y)) Badarg(5176,"y");
1553 if(!enif_get_int(env, argv[2], &z)) Badarg(5176,"z");
1554 if(!enif_get_int(env, argv[3], &w)) Badarg(5176,"w");
1555 weglRasterPos4i(x,y,z,w);
1556 }
1557
ecb_glRasterPos4s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1558 void ecb_glRasterPos4s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1559 {
1560 GLshort x;
1561 GLshort y;
1562 GLshort z;
1563 GLshort w;
1564 if(!egl_get_short(env, argv[0], &x)) Badarg(5177,"x");
1565 if(!egl_get_short(env, argv[1], &y)) Badarg(5177,"y");
1566 if(!egl_get_short(env, argv[2], &z)) Badarg(5177,"z");
1567 if(!egl_get_short(env, argv[3], &w)) Badarg(5177,"w");
1568 weglRasterPos4s(x,y,z,w);
1569 }
1570
ecb_glRectd(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1571 void ecb_glRectd(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1572 {
1573 GLdouble x1;
1574 GLdouble y1;
1575 GLdouble x2;
1576 GLdouble y2;
1577 if(!enif_get_double(env, argv[0], &x1)) Badarg(5178,"x1");
1578 if(!enif_get_double(env, argv[1], &y1)) Badarg(5178,"y1");
1579 if(!enif_get_double(env, argv[2], &x2)) Badarg(5178,"x2");
1580 if(!enif_get_double(env, argv[3], &y2)) Badarg(5178,"y2");
1581 weglRectd(x1,y1,x2,y2);
1582 }
1583
ecb_glRectf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1584 void ecb_glRectf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1585 {
1586 GLfloat x1;
1587 GLfloat y1;
1588 GLfloat x2;
1589 GLfloat y2;
1590 if(!egl_get_float(env, argv[0], &x1)) Badarg(5179,"x1");
1591 if(!egl_get_float(env, argv[1], &y1)) Badarg(5179,"y1");
1592 if(!egl_get_float(env, argv[2], &x2)) Badarg(5179,"x2");
1593 if(!egl_get_float(env, argv[3], &y2)) Badarg(5179,"y2");
1594 weglRectf(x1,y1,x2,y2);
1595 }
1596
ecb_glRecti(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1597 void ecb_glRecti(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1598 {
1599 GLint x1;
1600 GLint y1;
1601 GLint x2;
1602 GLint y2;
1603 if(!enif_get_int(env, argv[0], &x1)) Badarg(5180,"x1");
1604 if(!enif_get_int(env, argv[1], &y1)) Badarg(5180,"y1");
1605 if(!enif_get_int(env, argv[2], &x2)) Badarg(5180,"x2");
1606 if(!enif_get_int(env, argv[3], &y2)) Badarg(5180,"y2");
1607 weglRecti(x1,y1,x2,y2);
1608 }
1609
ecb_glRects(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1610 void ecb_glRects(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1611 {
1612 GLshort x1;
1613 GLshort y1;
1614 GLshort x2;
1615 GLshort y2;
1616 if(!egl_get_short(env, argv[0], &x1)) Badarg(5181,"x1");
1617 if(!egl_get_short(env, argv[1], &y1)) Badarg(5181,"y1");
1618 if(!egl_get_short(env, argv[2], &x2)) Badarg(5181,"x2");
1619 if(!egl_get_short(env, argv[3], &y2)) Badarg(5181,"y2");
1620 weglRects(x1,y1,x2,y2);
1621 }
1622
ecb_glRectdv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1623 void ecb_glRectdv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1624 {
1625 GLdouble v1[2];
1626 GLdouble v2[2];
1627 {
1628 int v1_a;
1629 const ERL_NIF_TERM *v1_t;
1630 if(!enif_get_tuple(env, argv[0], &v1_a, &v1_t) || v1_a != 2) {
1631 Badarg(5182,"v1");
1632 } else {
1633 int i1 = 0;
1634 if(!enif_get_double(env, v1_t[i1++], &v1[0])) Badarg(5182,"v1");
1635 if(!enif_get_double(env, v1_t[i1++], &v1[1])) Badarg(5182,"v1");
1636 }};
1637 {
1638 int v2_a;
1639 const ERL_NIF_TERM *v2_t;
1640 if(!enif_get_tuple(env, argv[1], &v2_a, &v2_t) || v2_a != 2) {
1641 Badarg(5182,"v2");
1642 } else {
1643 int i1 = 0;
1644 if(!enif_get_double(env, v2_t[i1++], &v2[0])) Badarg(5182,"v2");
1645 if(!enif_get_double(env, v2_t[i1++], &v2[1])) Badarg(5182,"v2");
1646 }};
1647 weglRectdv(v1,v2);
1648 }
1649
ecb_glRectfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1650 void ecb_glRectfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1651 {
1652 GLfloat v1[2];
1653 GLfloat v2[2];
1654 {
1655 int v1_a;
1656 const ERL_NIF_TERM *v1_t;
1657 if(!enif_get_tuple(env, argv[0], &v1_a, &v1_t) || v1_a != 2) {
1658 Badarg(5183,"v1");
1659 } else {
1660 int i1 = 0;
1661 if(!egl_get_float(env, v1_t[i1++], &v1[0])) Badarg(5183,"v1");
1662 if(!egl_get_float(env, v1_t[i1++], &v1[1])) Badarg(5183,"v1");
1663 }};
1664 {
1665 int v2_a;
1666 const ERL_NIF_TERM *v2_t;
1667 if(!enif_get_tuple(env, argv[1], &v2_a, &v2_t) || v2_a != 2) {
1668 Badarg(5183,"v2");
1669 } else {
1670 int i1 = 0;
1671 if(!egl_get_float(env, v2_t[i1++], &v2[0])) Badarg(5183,"v2");
1672 if(!egl_get_float(env, v2_t[i1++], &v2[1])) Badarg(5183,"v2");
1673 }};
1674 weglRectfv(v1,v2);
1675 }
1676
ecb_glRectiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1677 void ecb_glRectiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1678 {
1679 GLint v1[2];
1680 GLint v2[2];
1681 {
1682 int v1_a;
1683 const ERL_NIF_TERM *v1_t;
1684 if(!enif_get_tuple(env, argv[0], &v1_a, &v1_t) || v1_a != 2) {
1685 Badarg(5184,"v1");
1686 } else {
1687 int i1 = 0;
1688 if(!enif_get_int(env, v1_t[i1++], &v1[0])) Badarg(5184,"v1");
1689 if(!enif_get_int(env, v1_t[i1++], &v1[1])) Badarg(5184,"v1");
1690 }};
1691 {
1692 int v2_a;
1693 const ERL_NIF_TERM *v2_t;
1694 if(!enif_get_tuple(env, argv[1], &v2_a, &v2_t) || v2_a != 2) {
1695 Badarg(5184,"v2");
1696 } else {
1697 int i1 = 0;
1698 if(!enif_get_int(env, v2_t[i1++], &v2[0])) Badarg(5184,"v2");
1699 if(!enif_get_int(env, v2_t[i1++], &v2[1])) Badarg(5184,"v2");
1700 }};
1701 weglRectiv(v1,v2);
1702 }
1703
ecb_glRectsv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1704 void ecb_glRectsv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1705 {
1706 GLshort v1[2];
1707 GLshort v2[2];
1708 {
1709 int v1_a;
1710 const ERL_NIF_TERM *v1_t;
1711 if(!enif_get_tuple(env, argv[0], &v1_a, &v1_t) || v1_a != 2) {
1712 Badarg(5185,"v1");
1713 } else {
1714 int i1 = 0;
1715 if(!egl_get_short(env, v1_t[i1++], &v1[0])) Badarg(5185,"v1");
1716 if(!egl_get_short(env, v1_t[i1++], &v1[1])) Badarg(5185,"v1");
1717 }};
1718 {
1719 int v2_a;
1720 const ERL_NIF_TERM *v2_t;
1721 if(!enif_get_tuple(env, argv[1], &v2_a, &v2_t) || v2_a != 2) {
1722 Badarg(5185,"v2");
1723 } else {
1724 int i1 = 0;
1725 if(!egl_get_short(env, v2_t[i1++], &v2[0])) Badarg(5185,"v2");
1726 if(!egl_get_short(env, v2_t[i1++], &v2[1])) Badarg(5185,"v2");
1727 }};
1728 weglRectsv(v1,v2);
1729 }
1730
ecb_glVertexPointer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1731 void ecb_glVertexPointer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1732 {
1733 GLint size;
1734 GLenum type;
1735 GLsizei stride;
1736 ErlNifBinary ptr;
1737 GLvoid *ptr_idx;
1738 if(!enif_get_int(env, argv[0], &size)) Badarg(5186,"size");
1739 if(!enif_get_uint(env, argv[1], &type)) Badarg(5186,"type");
1740 if(!enif_get_int(env, argv[2], &stride)) Badarg(5186,"stride");
1741 if(!egl_get_ptr(env, argv[3], (void **) &ptr_idx)) {
1742 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[3], &ptr))
1743 ptr_idx = (GLvoid *) ptr.data;
1744 else Badarg(5186,"ptr");
1745 }
1746 weglVertexPointer(size,type,stride,ptr_idx);
1747 }
1748
ecb_glNormalPointer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1749 void ecb_glNormalPointer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1750 {
1751 GLenum type;
1752 GLsizei stride;
1753 ErlNifBinary ptr;
1754 GLvoid *ptr_idx;
1755 if(!enif_get_uint(env, argv[0], &type)) Badarg(5188,"type");
1756 if(!enif_get_int(env, argv[1], &stride)) Badarg(5188,"stride");
1757 if(!egl_get_ptr(env, argv[2], (void **) &ptr_idx)) {
1758 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[2], &ptr))
1759 ptr_idx = (GLvoid *) ptr.data;
1760 else Badarg(5188,"ptr");
1761 }
1762 weglNormalPointer(type,stride,ptr_idx);
1763 }
1764
ecb_glColorPointer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1765 void ecb_glColorPointer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1766 {
1767 GLint size;
1768 GLenum type;
1769 GLsizei stride;
1770 ErlNifBinary ptr;
1771 GLvoid *ptr_idx;
1772 if(!enif_get_int(env, argv[0], &size)) Badarg(5190,"size");
1773 if(!enif_get_uint(env, argv[1], &type)) Badarg(5190,"type");
1774 if(!enif_get_int(env, argv[2], &stride)) Badarg(5190,"stride");
1775 if(!egl_get_ptr(env, argv[3], (void **) &ptr_idx)) {
1776 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[3], &ptr))
1777 ptr_idx = (GLvoid *) ptr.data;
1778 else Badarg(5190,"ptr");
1779 }
1780 weglColorPointer(size,type,stride,ptr_idx);
1781 }
1782
ecb_glIndexPointer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1783 void ecb_glIndexPointer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1784 {
1785 GLenum type;
1786 GLsizei stride;
1787 ErlNifBinary ptr;
1788 GLvoid *ptr_idx;
1789 if(!enif_get_uint(env, argv[0], &type)) Badarg(5192,"type");
1790 if(!enif_get_int(env, argv[1], &stride)) Badarg(5192,"stride");
1791 if(!egl_get_ptr(env, argv[2], (void **) &ptr_idx)) {
1792 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[2], &ptr))
1793 ptr_idx = (GLvoid *) ptr.data;
1794 else Badarg(5192,"ptr");
1795 }
1796 weglIndexPointer(type,stride,ptr_idx);
1797 }
1798
ecb_glTexCoordPointer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1799 void ecb_glTexCoordPointer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1800 {
1801 GLint size;
1802 GLenum type;
1803 GLsizei stride;
1804 ErlNifBinary ptr;
1805 GLvoid *ptr_idx;
1806 if(!enif_get_int(env, argv[0], &size)) Badarg(5194,"size");
1807 if(!enif_get_uint(env, argv[1], &type)) Badarg(5194,"type");
1808 if(!enif_get_int(env, argv[2], &stride)) Badarg(5194,"stride");
1809 if(!egl_get_ptr(env, argv[3], (void **) &ptr_idx)) {
1810 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[3], &ptr))
1811 ptr_idx = (GLvoid *) ptr.data;
1812 else Badarg(5194,"ptr");
1813 }
1814 weglTexCoordPointer(size,type,stride,ptr_idx);
1815 }
1816
ecb_glEdgeFlagPointer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1817 void ecb_glEdgeFlagPointer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1818 {
1819 GLsizei stride;
1820 ErlNifBinary ptr;
1821 GLvoid *ptr_idx;
1822 if(!enif_get_int(env, argv[0], &stride)) Badarg(5196,"stride");
1823 if(!egl_get_ptr(env, argv[1], (void **) &ptr_idx)) {
1824 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[1], &ptr))
1825 ptr_idx = (GLvoid *) ptr.data;
1826 else Badarg(5196,"ptr");
1827 }
1828 weglEdgeFlagPointer(stride,ptr_idx);
1829 }
1830
ecb_glArrayElement(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1831 void ecb_glArrayElement(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1832 {
1833 GLint i;
1834 if(!enif_get_int(env, argv[0], &i)) Badarg(5198,"i");
1835 weglArrayElement(i);
1836 }
1837
ecb_glDrawArrays(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1838 void ecb_glDrawArrays(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1839 {
1840 GLenum mode;
1841 GLint first;
1842 GLsizei count;
1843 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5199,"mode");
1844 if(!enif_get_int(env, argv[1], &first)) Badarg(5199,"first");
1845 if(!enif_get_int(env, argv[2], &count)) Badarg(5199,"count");
1846 weglDrawArrays(mode,first,count);
1847 }
1848
ecb_glDrawElements(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1849 void ecb_glDrawElements(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1850 {
1851 GLenum mode;
1852 GLsizei count;
1853 GLenum type;
1854 ErlNifBinary indices;
1855 GLvoid *indices_idx;
1856 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5200,"mode");
1857 if(!enif_get_int(env, argv[1], &count)) Badarg(5200,"count");
1858 if(!enif_get_uint(env, argv[2], &type)) Badarg(5200,"type");
1859 if(!egl_get_ptr(env, argv[3], (void **) &indices_idx)) {
1860 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[3], &indices))
1861 indices_idx = (GLvoid *) indices.data;
1862 else Badarg(5200,"indices");
1863 }
1864 weglDrawElements(mode,count,type,indices_idx);
1865 }
1866
ecb_glInterleavedArrays(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1867 void ecb_glInterleavedArrays(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1868 {
1869 GLenum format;
1870 GLsizei stride;
1871 ErlNifBinary pointer;
1872 GLvoid *pointer_idx;
1873 if(!enif_get_uint(env, argv[0], &format)) Badarg(5202,"format");
1874 if(!enif_get_int(env, argv[1], &stride)) Badarg(5202,"stride");
1875 if(!egl_get_ptr(env, argv[2], (void **) &pointer_idx)) {
1876 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[2], &pointer))
1877 pointer_idx = (GLvoid *) pointer.data;
1878 else Badarg(5202,"pointer");
1879 }
1880 weglInterleavedArrays(format,stride,pointer_idx);
1881 }
1882
ecb_glShadeModel(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1883 void ecb_glShadeModel(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1884 {
1885 GLenum mode;
1886 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5204,"mode");
1887 weglShadeModel(mode);
1888 }
1889
ecb_glLightf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1890 void ecb_glLightf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1891 {
1892 GLenum light;
1893 GLenum pname;
1894 GLfloat param;
1895 if(!enif_get_uint(env, argv[0], &light)) Badarg(5205,"light");
1896 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5205,"pname");
1897 if(!egl_get_float(env, argv[2], ¶m)) Badarg(5205,"param");
1898 weglLightf(light,pname,param);
1899 }
1900
ecb_glLighti(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1901 void ecb_glLighti(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1902 {
1903 GLenum light;
1904 GLenum pname;
1905 GLint param;
1906 if(!enif_get_uint(env, argv[0], &light)) Badarg(5206,"light");
1907 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5206,"pname");
1908 if(!enif_get_int(env, argv[2], ¶m)) Badarg(5206,"param");
1909 weglLighti(light,pname,param);
1910 }
1911
ecb_glLightfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1912 void ecb_glLightfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1913 {
1914 GLenum light;
1915 GLenum pname;
1916 GLfloat params[4];
1917 if(!enif_get_uint(env, argv[0], &light)) Badarg(5207,"light");
1918 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5207,"pname");
1919 {
1920 int params_a;
1921 const ERL_NIF_TERM *params_t;
1922 int i;
1923 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
1924 Badarg(5207,"params");
1925 } else {
1926 for(i = 0; i < params_a; i++)
1927 if(!egl_get_float(env, params_t[i], ¶ms[i])) Badarg(5207,"params");
1928 }};
1929 weglLightfv(light,pname,params);
1930 }
1931
ecb_glLightiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1932 void ecb_glLightiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1933 {
1934 GLenum light;
1935 GLenum pname;
1936 GLint params[4];
1937 if(!enif_get_uint(env, argv[0], &light)) Badarg(5208,"light");
1938 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5208,"pname");
1939 {
1940 int params_a;
1941 const ERL_NIF_TERM *params_t;
1942 int i;
1943 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
1944 Badarg(5208,"params");
1945 } else {
1946 for(i = 0; i < params_a; i++)
1947 if(!enif_get_int(env, params_t[i], ¶ms[i])) Badarg(5208,"params");
1948 }};
1949 weglLightiv(light,pname,params);
1950 }
1951
ecb_glGetLightfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1952 void ecb_glGetLightfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1953 {
1954 ERL_NIF_TERM reply;
1955 GLenum light;
1956 GLenum pname;
1957 GLfloat params[4];
1958 if(!enif_get_uint(env, argv[0], &light)) Badarg(5209,"light");
1959 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5209,"pname");
1960 weglGetLightfv(light,pname,params);
1961 reply = enif_make_tuple4(env,
1962 enif_make_double(env, (double) params[0]),
1963 enif_make_double(env, (double) params[1]),
1964 enif_make_double(env, (double) params[2]),
1965 enif_make_double(env, (double) params[3]));
1966 enif_send(NULL, self, env,
1967 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
1968 }
1969
ecb_glGetLightiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1970 void ecb_glGetLightiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1971 {
1972 ERL_NIF_TERM reply;
1973 GLenum light;
1974 GLenum pname;
1975 GLint params[4];
1976 if(!enif_get_uint(env, argv[0], &light)) Badarg(5210,"light");
1977 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5210,"pname");
1978 weglGetLightiv(light,pname,params);
1979 reply = enif_make_tuple4(env,
1980 enif_make_int(env, params[0]),
1981 enif_make_int(env, params[1]),
1982 enif_make_int(env, params[2]),
1983 enif_make_int(env, params[3]));
1984 enif_send(NULL, self, env,
1985 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
1986 }
1987
ecb_glLightModelf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1988 void ecb_glLightModelf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1989 {
1990 GLenum pname;
1991 GLfloat param;
1992 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5211,"pname");
1993 if(!egl_get_float(env, argv[1], ¶m)) Badarg(5211,"param");
1994 weglLightModelf(pname,param);
1995 }
1996
ecb_glLightModeli(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])1997 void ecb_glLightModeli(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
1998 {
1999 GLenum pname;
2000 GLint param;
2001 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5212,"pname");
2002 if(!enif_get_int(env, argv[1], ¶m)) Badarg(5212,"param");
2003 weglLightModeli(pname,param);
2004 }
2005
ecb_glLightModelfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2006 void ecb_glLightModelfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2007 {
2008 GLenum pname;
2009 GLfloat params[4];
2010 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5213,"pname");
2011 {
2012 int params_a;
2013 const ERL_NIF_TERM *params_t;
2014 int i;
2015 if(!enif_get_tuple(env, argv[1], ¶ms_a, ¶ms_t)) {
2016 Badarg(5213,"params");
2017 } else {
2018 for(i = 0; i < params_a; i++)
2019 if(!egl_get_float(env, params_t[i], ¶ms[i])) Badarg(5213,"params");
2020 }};
2021 weglLightModelfv(pname,params);
2022 }
2023
ecb_glLightModeliv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2024 void ecb_glLightModeliv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2025 {
2026 GLenum pname;
2027 GLint params[4];
2028 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5214,"pname");
2029 {
2030 int params_a;
2031 const ERL_NIF_TERM *params_t;
2032 int i;
2033 if(!enif_get_tuple(env, argv[1], ¶ms_a, ¶ms_t)) {
2034 Badarg(5214,"params");
2035 } else {
2036 for(i = 0; i < params_a; i++)
2037 if(!enif_get_int(env, params_t[i], ¶ms[i])) Badarg(5214,"params");
2038 }};
2039 weglLightModeliv(pname,params);
2040 }
2041
ecb_glMaterialf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2042 void ecb_glMaterialf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2043 {
2044 GLenum face;
2045 GLenum pname;
2046 GLfloat param;
2047 if(!enif_get_uint(env, argv[0], &face)) Badarg(5215,"face");
2048 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5215,"pname");
2049 if(!egl_get_float(env, argv[2], ¶m)) Badarg(5215,"param");
2050 weglMaterialf(face,pname,param);
2051 }
2052
ecb_glMateriali(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2053 void ecb_glMateriali(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2054 {
2055 GLenum face;
2056 GLenum pname;
2057 GLint param;
2058 if(!enif_get_uint(env, argv[0], &face)) Badarg(5216,"face");
2059 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5216,"pname");
2060 if(!enif_get_int(env, argv[2], ¶m)) Badarg(5216,"param");
2061 weglMateriali(face,pname,param);
2062 }
2063
ecb_glMaterialfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2064 void ecb_glMaterialfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2065 {
2066 GLenum face;
2067 GLenum pname;
2068 GLfloat params[4];
2069 if(!enif_get_uint(env, argv[0], &face)) Badarg(5217,"face");
2070 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5217,"pname");
2071 {
2072 int params_a;
2073 const ERL_NIF_TERM *params_t;
2074 int i;
2075 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
2076 Badarg(5217,"params");
2077 } else {
2078 for(i = 0; i < params_a; i++)
2079 if(!egl_get_float(env, params_t[i], ¶ms[i])) Badarg(5217,"params");
2080 }};
2081 weglMaterialfv(face,pname,params);
2082 }
2083
ecb_glMaterialiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2084 void ecb_glMaterialiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2085 {
2086 GLenum face;
2087 GLenum pname;
2088 GLint params[4];
2089 if(!enif_get_uint(env, argv[0], &face)) Badarg(5218,"face");
2090 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5218,"pname");
2091 {
2092 int params_a;
2093 const ERL_NIF_TERM *params_t;
2094 int i;
2095 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
2096 Badarg(5218,"params");
2097 } else {
2098 for(i = 0; i < params_a; i++)
2099 if(!enif_get_int(env, params_t[i], ¶ms[i])) Badarg(5218,"params");
2100 }};
2101 weglMaterialiv(face,pname,params);
2102 }
2103
ecb_glGetMaterialfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2104 void ecb_glGetMaterialfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2105 {
2106 ERL_NIF_TERM reply;
2107 GLenum face;
2108 GLenum pname;
2109 GLfloat params[4];
2110 if(!enif_get_uint(env, argv[0], &face)) Badarg(5219,"face");
2111 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5219,"pname");
2112 weglGetMaterialfv(face,pname,params);
2113 reply = enif_make_tuple4(env,
2114 enif_make_double(env, (double) params[0]),
2115 enif_make_double(env, (double) params[1]),
2116 enif_make_double(env, (double) params[2]),
2117 enif_make_double(env, (double) params[3]));
2118 enif_send(NULL, self, env,
2119 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
2120 }
2121
ecb_glGetMaterialiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2122 void ecb_glGetMaterialiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2123 {
2124 ERL_NIF_TERM reply;
2125 GLenum face;
2126 GLenum pname;
2127 GLint params[4];
2128 if(!enif_get_uint(env, argv[0], &face)) Badarg(5220,"face");
2129 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5220,"pname");
2130 weglGetMaterialiv(face,pname,params);
2131 reply = enif_make_tuple4(env,
2132 enif_make_int(env, params[0]),
2133 enif_make_int(env, params[1]),
2134 enif_make_int(env, params[2]),
2135 enif_make_int(env, params[3]));
2136 enif_send(NULL, self, env,
2137 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
2138 }
2139
ecb_glColorMaterial(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2140 void ecb_glColorMaterial(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2141 {
2142 GLenum face;
2143 GLenum mode;
2144 if(!enif_get_uint(env, argv[0], &face)) Badarg(5221,"face");
2145 if(!enif_get_uint(env, argv[1], &mode)) Badarg(5221,"mode");
2146 weglColorMaterial(face,mode);
2147 }
2148
ecb_glPixelZoom(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2149 void ecb_glPixelZoom(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2150 {
2151 GLfloat xfactor;
2152 GLfloat yfactor;
2153 if(!egl_get_float(env, argv[0], &xfactor)) Badarg(5222,"xfactor");
2154 if(!egl_get_float(env, argv[1], &yfactor)) Badarg(5222,"yfactor");
2155 weglPixelZoom(xfactor,yfactor);
2156 }
2157
ecb_glPixelStoref(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2158 void ecb_glPixelStoref(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2159 {
2160 GLenum pname;
2161 GLfloat param;
2162 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5223,"pname");
2163 if(!egl_get_float(env, argv[1], ¶m)) Badarg(5223,"param");
2164 weglPixelStoref(pname,param);
2165 }
2166
ecb_glPixelStorei(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2167 void ecb_glPixelStorei(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2168 {
2169 GLenum pname;
2170 GLint param;
2171 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5224,"pname");
2172 if(!enif_get_int(env, argv[1], ¶m)) Badarg(5224,"param");
2173 weglPixelStorei(pname,param);
2174 }
2175
ecb_glPixelTransferf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2176 void ecb_glPixelTransferf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2177 {
2178 GLenum pname;
2179 GLfloat param;
2180 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5225,"pname");
2181 if(!egl_get_float(env, argv[1], ¶m)) Badarg(5225,"param");
2182 weglPixelTransferf(pname,param);
2183 }
2184
ecb_glPixelTransferi(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2185 void ecb_glPixelTransferi(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2186 {
2187 GLenum pname;
2188 GLint param;
2189 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5226,"pname");
2190 if(!enif_get_int(env, argv[1], ¶m)) Badarg(5226,"param");
2191 weglPixelTransferi(pname,param);
2192 }
2193
ecb_glPixelMapfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2194 void ecb_glPixelMapfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2195 {
2196 GLenum map;
2197 GLsizei mapsize;
2198 ErlNifBinary values;
2199 if(!enif_get_uint(env, argv[0], &map)) Badarg(5227,"map");
2200 if(!enif_get_int(env, argv[1], &mapsize)) Badarg(5227,"mapsize");
2201 if(!enif_inspect_binary(env, argv[2], &values)) Badarg(5227,"values");
2202 weglPixelMapfv(map,mapsize,(GLfloat *) values.data);
2203 }
2204
ecb_glPixelMapuiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2205 void ecb_glPixelMapuiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2206 {
2207 GLenum map;
2208 GLsizei mapsize;
2209 ErlNifBinary values;
2210 if(!enif_get_uint(env, argv[0], &map)) Badarg(5228,"map");
2211 if(!enif_get_int(env, argv[1], &mapsize)) Badarg(5228,"mapsize");
2212 if(!enif_inspect_binary(env, argv[2], &values)) Badarg(5228,"values");
2213 weglPixelMapuiv(map,mapsize,(GLuint *) values.data);
2214 }
2215
ecb_glPixelMapusv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2216 void ecb_glPixelMapusv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2217 {
2218 GLenum map;
2219 GLsizei mapsize;
2220 ErlNifBinary values;
2221 if(!enif_get_uint(env, argv[0], &map)) Badarg(5229,"map");
2222 if(!enif_get_int(env, argv[1], &mapsize)) Badarg(5229,"mapsize");
2223 if(!enif_inspect_binary(env, argv[2], &values)) Badarg(5229,"values");
2224 weglPixelMapusv(map,mapsize,(GLushort *) values.data);
2225 }
2226
ecb_glGetPixelMapfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2227 void ecb_glGetPixelMapfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2228 {
2229 GLenum map;
2230 ErlNifBinary values;
2231 if(!enif_get_uint(env, argv[0], &map)) Badarg(5230,"map");
2232 if(enif_is_binary(env, argv[1]))
2233 enif_inspect_binary(env, argv[1], &values);
2234 else if(enif_is_tuple(env, argv[1])) {
2235 int values_a;
2236 const ERL_NIF_TERM *values_t;
2237 if(enif_get_tuple(env, argv[1], &values_a, &values_t) &&
2238 enif_is_binary(env, values_t[1]))
2239 enif_inspect_binary(env, values_t[1], &values);
2240 else Badarg(5230, "values");
2241 } else Badarg(5230, "values");
2242 weglGetPixelMapfv(map,(GLfloat *) values.data);
2243 enif_send(NULL, self, env,
2244 enif_make_tuple2(env,EGL_ATOM_REPLY,
2245 EGL_ATOM_OK));
2246 }
2247
ecb_glGetPixelMapuiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2248 void ecb_glGetPixelMapuiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2249 {
2250 GLenum map;
2251 ErlNifBinary values;
2252 if(!enif_get_uint(env, argv[0], &map)) Badarg(5231,"map");
2253 if(enif_is_binary(env, argv[1]))
2254 enif_inspect_binary(env, argv[1], &values);
2255 else if(enif_is_tuple(env, argv[1])) {
2256 int values_a;
2257 const ERL_NIF_TERM *values_t;
2258 if(enif_get_tuple(env, argv[1], &values_a, &values_t) &&
2259 enif_is_binary(env, values_t[1]))
2260 enif_inspect_binary(env, values_t[1], &values);
2261 else Badarg(5231, "values");
2262 } else Badarg(5231, "values");
2263 weglGetPixelMapuiv(map,(GLuint *) values.data);
2264 enif_send(NULL, self, env,
2265 enif_make_tuple2(env,EGL_ATOM_REPLY,
2266 EGL_ATOM_OK));
2267 }
2268
ecb_glGetPixelMapusv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2269 void ecb_glGetPixelMapusv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2270 {
2271 GLenum map;
2272 ErlNifBinary values;
2273 if(!enif_get_uint(env, argv[0], &map)) Badarg(5232,"map");
2274 if(enif_is_binary(env, argv[1]))
2275 enif_inspect_binary(env, argv[1], &values);
2276 else if(enif_is_tuple(env, argv[1])) {
2277 int values_a;
2278 const ERL_NIF_TERM *values_t;
2279 if(enif_get_tuple(env, argv[1], &values_a, &values_t) &&
2280 enif_is_binary(env, values_t[1]))
2281 enif_inspect_binary(env, values_t[1], &values);
2282 else Badarg(5232, "values");
2283 } else Badarg(5232, "values");
2284 weglGetPixelMapusv(map,(GLushort *) values.data);
2285 enif_send(NULL, self, env,
2286 enif_make_tuple2(env,EGL_ATOM_REPLY,
2287 EGL_ATOM_OK));
2288 }
2289
ecb_glBitmap(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2290 void ecb_glBitmap(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2291 {
2292 GLsizei width;
2293 GLsizei height;
2294 GLfloat xorig;
2295 GLfloat yorig;
2296 GLfloat xmove;
2297 GLfloat ymove;
2298 ErlNifBinary bitmap;
2299 GLubyte *bitmap_idx;
2300 if(!enif_get_int(env, argv[0], &width)) Badarg(5233,"width");
2301 if(!enif_get_int(env, argv[1], &height)) Badarg(5233,"height");
2302 if(!egl_get_float(env, argv[2], &xorig)) Badarg(5233,"xorig");
2303 if(!egl_get_float(env, argv[3], &yorig)) Badarg(5233,"yorig");
2304 if(!egl_get_float(env, argv[4], &xmove)) Badarg(5233,"xmove");
2305 if(!egl_get_float(env, argv[5], &ymove)) Badarg(5233,"ymove");
2306 if(!egl_get_ptr(env, argv[6], (void **) &bitmap_idx)) {
2307 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[6], &bitmap))
2308 bitmap_idx = (GLubyte *) bitmap.data;
2309 else Badarg(5233,"bitmap");
2310 }
2311 weglBitmap(width,height,xorig,yorig,xmove,ymove,bitmap_idx);
2312 }
2313
ecb_glReadPixels(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2314 void ecb_glReadPixels(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2315 {
2316 GLint x;
2317 GLint y;
2318 GLsizei width;
2319 GLsizei height;
2320 GLenum format;
2321 GLenum type;
2322 ErlNifBinary pixels;
2323 if(!enif_get_int(env, argv[0], &x)) Badarg(5235,"x");
2324 if(!enif_get_int(env, argv[1], &y)) Badarg(5235,"y");
2325 if(!enif_get_int(env, argv[2], &width)) Badarg(5235,"width");
2326 if(!enif_get_int(env, argv[3], &height)) Badarg(5235,"height");
2327 if(!enif_get_uint(env, argv[4], &format)) Badarg(5235,"format");
2328 if(!enif_get_uint(env, argv[5], &type)) Badarg(5235,"type");
2329 if(enif_is_binary(env, argv[6]))
2330 enif_inspect_binary(env, argv[6], &pixels);
2331 else if(enif_is_tuple(env, argv[6])) {
2332 int pixels_a;
2333 const ERL_NIF_TERM *pixels_t;
2334 if(enif_get_tuple(env, argv[6], &pixels_a, &pixels_t) &&
2335 enif_is_binary(env, pixels_t[1]))
2336 enif_inspect_binary(env, pixels_t[1], &pixels);
2337 else Badarg(5235, "pixels");
2338 } else Badarg(5235, "pixels");
2339 weglReadPixels(x,y,width,height,format,type,(GLvoid *) pixels.data);
2340 enif_send(NULL, self, env,
2341 enif_make_tuple2(env,EGL_ATOM_REPLY,
2342 EGL_ATOM_OK));
2343 }
2344
ecb_glDrawPixels(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2345 void ecb_glDrawPixels(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2346 {
2347 GLsizei width;
2348 GLsizei height;
2349 GLenum format;
2350 GLenum type;
2351 ErlNifBinary pixels;
2352 GLvoid *pixels_idx;
2353 if(!enif_get_int(env, argv[0], &width)) Badarg(5236,"width");
2354 if(!enif_get_int(env, argv[1], &height)) Badarg(5236,"height");
2355 if(!enif_get_uint(env, argv[2], &format)) Badarg(5236,"format");
2356 if(!enif_get_uint(env, argv[3], &type)) Badarg(5236,"type");
2357 if(!egl_get_ptr(env, argv[4], (void **) &pixels_idx)) {
2358 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[4], &pixels))
2359 pixels_idx = (GLvoid *) pixels.data;
2360 else Badarg(5236,"pixels");
2361 }
2362 weglDrawPixels(width,height,format,type,pixels_idx);
2363 }
2364
ecb_glCopyPixels(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2365 void ecb_glCopyPixels(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2366 {
2367 GLint x;
2368 GLint y;
2369 GLsizei width;
2370 GLsizei height;
2371 GLenum type;
2372 if(!enif_get_int(env, argv[0], &x)) Badarg(5238,"x");
2373 if(!enif_get_int(env, argv[1], &y)) Badarg(5238,"y");
2374 if(!enif_get_int(env, argv[2], &width)) Badarg(5238,"width");
2375 if(!enif_get_int(env, argv[3], &height)) Badarg(5238,"height");
2376 if(!enif_get_uint(env, argv[4], &type)) Badarg(5238,"type");
2377 weglCopyPixels(x,y,width,height,type);
2378 }
2379
ecb_glStencilFunc(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2380 void ecb_glStencilFunc(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2381 {
2382 GLenum func;
2383 GLint ref;
2384 GLuint mask;
2385 if(!enif_get_uint(env, argv[0], &func)) Badarg(5239,"func");
2386 if(!enif_get_int(env, argv[1], &ref)) Badarg(5239,"ref");
2387 if(!enif_get_uint(env, argv[2], &mask)) Badarg(5239,"mask");
2388 weglStencilFunc(func,ref,mask);
2389 }
2390
ecb_glStencilMask(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2391 void ecb_glStencilMask(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2392 {
2393 GLuint mask;
2394 if(!enif_get_uint(env, argv[0], &mask)) Badarg(5240,"mask");
2395 weglStencilMask(mask);
2396 }
2397
ecb_glStencilOp(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2398 void ecb_glStencilOp(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2399 {
2400 GLenum fail;
2401 GLenum zfail;
2402 GLenum zpass;
2403 if(!enif_get_uint(env, argv[0], &fail)) Badarg(5241,"fail");
2404 if(!enif_get_uint(env, argv[1], &zfail)) Badarg(5241,"zfail");
2405 if(!enif_get_uint(env, argv[2], &zpass)) Badarg(5241,"zpass");
2406 weglStencilOp(fail,zfail,zpass);
2407 }
2408
ecb_glClearStencil(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2409 void ecb_glClearStencil(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2410 {
2411 GLint s;
2412 if(!enif_get_int(env, argv[0], &s)) Badarg(5242,"s");
2413 weglClearStencil(s);
2414 }
2415
ecb_glTexGend(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2416 void ecb_glTexGend(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2417 {
2418 GLenum coord;
2419 GLenum pname;
2420 GLdouble param;
2421 if(!enif_get_uint(env, argv[0], &coord)) Badarg(5243,"coord");
2422 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5243,"pname");
2423 if(!enif_get_double(env, argv[2], ¶m)) Badarg(5243,"param");
2424 weglTexGend(coord,pname,param);
2425 }
2426
ecb_glTexGenf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2427 void ecb_glTexGenf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2428 {
2429 GLenum coord;
2430 GLenum pname;
2431 GLfloat param;
2432 if(!enif_get_uint(env, argv[0], &coord)) Badarg(5244,"coord");
2433 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5244,"pname");
2434 if(!egl_get_float(env, argv[2], ¶m)) Badarg(5244,"param");
2435 weglTexGenf(coord,pname,param);
2436 }
2437
ecb_glTexGeni(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2438 void ecb_glTexGeni(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2439 {
2440 GLenum coord;
2441 GLenum pname;
2442 GLint param;
2443 if(!enif_get_uint(env, argv[0], &coord)) Badarg(5245,"coord");
2444 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5245,"pname");
2445 if(!enif_get_int(env, argv[2], ¶m)) Badarg(5245,"param");
2446 weglTexGeni(coord,pname,param);
2447 }
2448
ecb_glTexGendv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2449 void ecb_glTexGendv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2450 {
2451 GLenum coord;
2452 GLenum pname;
2453 GLdouble params[4];
2454 if(!enif_get_uint(env, argv[0], &coord)) Badarg(5246,"coord");
2455 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5246,"pname");
2456 {
2457 int params_a;
2458 const ERL_NIF_TERM *params_t;
2459 int i;
2460 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
2461 Badarg(5246,"params");
2462 } else {
2463 for(i = 0; i < params_a; i++)
2464 if(!enif_get_double(env, params_t[i], ¶ms[i])) Badarg(5246,"params");
2465 }};
2466 weglTexGendv(coord,pname,params);
2467 }
2468
ecb_glTexGenfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2469 void ecb_glTexGenfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2470 {
2471 GLenum coord;
2472 GLenum pname;
2473 GLfloat params[4];
2474 if(!enif_get_uint(env, argv[0], &coord)) Badarg(5247,"coord");
2475 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5247,"pname");
2476 {
2477 int params_a;
2478 const ERL_NIF_TERM *params_t;
2479 int i;
2480 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
2481 Badarg(5247,"params");
2482 } else {
2483 for(i = 0; i < params_a; i++)
2484 if(!egl_get_float(env, params_t[i], ¶ms[i])) Badarg(5247,"params");
2485 }};
2486 weglTexGenfv(coord,pname,params);
2487 }
2488
ecb_glTexGeniv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2489 void ecb_glTexGeniv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2490 {
2491 GLenum coord;
2492 GLenum pname;
2493 GLint params[4];
2494 if(!enif_get_uint(env, argv[0], &coord)) Badarg(5248,"coord");
2495 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5248,"pname");
2496 {
2497 int params_a;
2498 const ERL_NIF_TERM *params_t;
2499 int i;
2500 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
2501 Badarg(5248,"params");
2502 } else {
2503 for(i = 0; i < params_a; i++)
2504 if(!enif_get_int(env, params_t[i], ¶ms[i])) Badarg(5248,"params");
2505 }};
2506 weglTexGeniv(coord,pname,params);
2507 }
2508
ecb_glGetTexGendv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2509 void ecb_glGetTexGendv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2510 {
2511 ERL_NIF_TERM reply;
2512 GLenum coord;
2513 GLenum pname;
2514 GLdouble params[4];
2515 if(!enif_get_uint(env, argv[0], &coord)) Badarg(5249,"coord");
2516 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5249,"pname");
2517 weglGetTexGendv(coord,pname,params);
2518 reply = enif_make_tuple4(env,
2519 enif_make_double(env, params[0]),
2520 enif_make_double(env, params[1]),
2521 enif_make_double(env, params[2]),
2522 enif_make_double(env, params[3]));
2523 enif_send(NULL, self, env,
2524 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
2525 }
2526
ecb_glGetTexGenfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2527 void ecb_glGetTexGenfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2528 {
2529 ERL_NIF_TERM reply;
2530 GLenum coord;
2531 GLenum pname;
2532 GLfloat params[4];
2533 if(!enif_get_uint(env, argv[0], &coord)) Badarg(5250,"coord");
2534 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5250,"pname");
2535 weglGetTexGenfv(coord,pname,params);
2536 reply = enif_make_tuple4(env,
2537 enif_make_double(env, (double) params[0]),
2538 enif_make_double(env, (double) params[1]),
2539 enif_make_double(env, (double) params[2]),
2540 enif_make_double(env, (double) params[3]));
2541 enif_send(NULL, self, env,
2542 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
2543 }
2544
ecb_glGetTexGeniv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2545 void ecb_glGetTexGeniv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2546 {
2547 ERL_NIF_TERM reply;
2548 GLenum coord;
2549 GLenum pname;
2550 GLint params[4];
2551 if(!enif_get_uint(env, argv[0], &coord)) Badarg(5251,"coord");
2552 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5251,"pname");
2553 weglGetTexGeniv(coord,pname,params);
2554 reply = enif_make_tuple4(env,
2555 enif_make_int(env, params[0]),
2556 enif_make_int(env, params[1]),
2557 enif_make_int(env, params[2]),
2558 enif_make_int(env, params[3]));
2559 enif_send(NULL, self, env,
2560 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
2561 }
2562
ecb_glTexEnvf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2563 void ecb_glTexEnvf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2564 {
2565 GLenum target;
2566 GLenum pname;
2567 GLfloat param;
2568 if(!enif_get_uint(env, argv[0], &target)) Badarg(5252,"target");
2569 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5252,"pname");
2570 if(!egl_get_float(env, argv[2], ¶m)) Badarg(5252,"param");
2571 weglTexEnvf(target,pname,param);
2572 }
2573
ecb_glTexEnvi(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2574 void ecb_glTexEnvi(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2575 {
2576 GLenum target;
2577 GLenum pname;
2578 GLint param;
2579 if(!enif_get_uint(env, argv[0], &target)) Badarg(5253,"target");
2580 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5253,"pname");
2581 if(!enif_get_int(env, argv[2], ¶m)) Badarg(5253,"param");
2582 weglTexEnvi(target,pname,param);
2583 }
2584
ecb_glTexEnvfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2585 void ecb_glTexEnvfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2586 {
2587 GLenum target;
2588 GLenum pname;
2589 GLfloat params[4];
2590 if(!enif_get_uint(env, argv[0], &target)) Badarg(5254,"target");
2591 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5254,"pname");
2592 {
2593 int params_a;
2594 const ERL_NIF_TERM *params_t;
2595 int i;
2596 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
2597 Badarg(5254,"params");
2598 } else {
2599 for(i = 0; i < params_a; i++)
2600 if(!egl_get_float(env, params_t[i], ¶ms[i])) Badarg(5254,"params");
2601 }};
2602 weglTexEnvfv(target,pname,params);
2603 }
2604
ecb_glTexEnviv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2605 void ecb_glTexEnviv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2606 {
2607 GLenum target;
2608 GLenum pname;
2609 GLint params[4];
2610 if(!enif_get_uint(env, argv[0], &target)) Badarg(5255,"target");
2611 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5255,"pname");
2612 {
2613 int params_a;
2614 const ERL_NIF_TERM *params_t;
2615 int i;
2616 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
2617 Badarg(5255,"params");
2618 } else {
2619 for(i = 0; i < params_a; i++)
2620 if(!enif_get_int(env, params_t[i], ¶ms[i])) Badarg(5255,"params");
2621 }};
2622 weglTexEnviv(target,pname,params);
2623 }
2624
ecb_glGetTexEnvfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2625 void ecb_glGetTexEnvfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2626 {
2627 ERL_NIF_TERM reply;
2628 GLenum target;
2629 GLenum pname;
2630 GLfloat params[4];
2631 if(!enif_get_uint(env, argv[0], &target)) Badarg(5256,"target");
2632 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5256,"pname");
2633 weglGetTexEnvfv(target,pname,params);
2634 reply = enif_make_tuple4(env,
2635 enif_make_double(env, (double) params[0]),
2636 enif_make_double(env, (double) params[1]),
2637 enif_make_double(env, (double) params[2]),
2638 enif_make_double(env, (double) params[3]));
2639 enif_send(NULL, self, env,
2640 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
2641 }
2642
ecb_glGetTexEnviv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2643 void ecb_glGetTexEnviv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2644 {
2645 ERL_NIF_TERM reply;
2646 GLenum target;
2647 GLenum pname;
2648 GLint params[4];
2649 if(!enif_get_uint(env, argv[0], &target)) Badarg(5257,"target");
2650 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5257,"pname");
2651 weglGetTexEnviv(target,pname,params);
2652 reply = enif_make_tuple4(env,
2653 enif_make_int(env, params[0]),
2654 enif_make_int(env, params[1]),
2655 enif_make_int(env, params[2]),
2656 enif_make_int(env, params[3]));
2657 enif_send(NULL, self, env,
2658 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
2659 }
2660
ecb_glTexParameterf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2661 void ecb_glTexParameterf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2662 {
2663 GLenum target;
2664 GLenum pname;
2665 GLfloat param;
2666 if(!enif_get_uint(env, argv[0], &target)) Badarg(5258,"target");
2667 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5258,"pname");
2668 if(!egl_get_float(env, argv[2], ¶m)) Badarg(5258,"param");
2669 weglTexParameterf(target,pname,param);
2670 }
2671
ecb_glTexParameteri(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2672 void ecb_glTexParameteri(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2673 {
2674 GLenum target;
2675 GLenum pname;
2676 GLint param;
2677 if(!enif_get_uint(env, argv[0], &target)) Badarg(5259,"target");
2678 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5259,"pname");
2679 if(!enif_get_int(env, argv[2], ¶m)) Badarg(5259,"param");
2680 weglTexParameteri(target,pname,param);
2681 }
2682
ecb_glTexParameterfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2683 void ecb_glTexParameterfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2684 {
2685 GLenum target;
2686 GLenum pname;
2687 GLfloat params[4];
2688 if(!enif_get_uint(env, argv[0], &target)) Badarg(5260,"target");
2689 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5260,"pname");
2690 {
2691 int params_a;
2692 const ERL_NIF_TERM *params_t;
2693 int i;
2694 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
2695 Badarg(5260,"params");
2696 } else {
2697 for(i = 0; i < params_a; i++)
2698 if(!egl_get_float(env, params_t[i], ¶ms[i])) Badarg(5260,"params");
2699 }};
2700 weglTexParameterfv(target,pname,params);
2701 }
2702
ecb_glTexParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2703 void ecb_glTexParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2704 {
2705 GLenum target;
2706 GLenum pname;
2707 GLint params[4];
2708 if(!enif_get_uint(env, argv[0], &target)) Badarg(5261,"target");
2709 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5261,"pname");
2710 {
2711 int params_a;
2712 const ERL_NIF_TERM *params_t;
2713 int i;
2714 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
2715 Badarg(5261,"params");
2716 } else {
2717 for(i = 0; i < params_a; i++)
2718 if(!enif_get_int(env, params_t[i], ¶ms[i])) Badarg(5261,"params");
2719 }};
2720 weglTexParameteriv(target,pname,params);
2721 }
2722
ecb_glGetTexParameterfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2723 void ecb_glGetTexParameterfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2724 {
2725 ERL_NIF_TERM reply;
2726 GLenum target;
2727 GLenum pname;
2728 GLfloat params[4];
2729 if(!enif_get_uint(env, argv[0], &target)) Badarg(5262,"target");
2730 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5262,"pname");
2731 weglGetTexParameterfv(target,pname,params);
2732 reply = enif_make_tuple4(env,
2733 enif_make_double(env, (double) params[0]),
2734 enif_make_double(env, (double) params[1]),
2735 enif_make_double(env, (double) params[2]),
2736 enif_make_double(env, (double) params[3]));
2737 enif_send(NULL, self, env,
2738 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
2739 }
2740
ecb_glGetTexParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2741 void ecb_glGetTexParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2742 {
2743 ERL_NIF_TERM reply;
2744 GLenum target;
2745 GLenum pname;
2746 GLint params[4];
2747 if(!enif_get_uint(env, argv[0], &target)) Badarg(5263,"target");
2748 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5263,"pname");
2749 weglGetTexParameteriv(target,pname,params);
2750 reply = enif_make_tuple4(env,
2751 enif_make_int(env, params[0]),
2752 enif_make_int(env, params[1]),
2753 enif_make_int(env, params[2]),
2754 enif_make_int(env, params[3]));
2755 enif_send(NULL, self, env,
2756 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
2757 }
2758
ecb_glGetTexLevelParameterfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2759 void ecb_glGetTexLevelParameterfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2760 {
2761 ERL_NIF_TERM reply;
2762 GLenum target;
2763 GLint level;
2764 GLenum pname;
2765 GLfloat params[1];
2766 if(!enif_get_uint(env, argv[0], &target)) Badarg(5264,"target");
2767 if(!enif_get_int(env, argv[1], &level)) Badarg(5264,"level");
2768 if(!enif_get_uint(env, argv[2], &pname)) Badarg(5264,"pname");
2769 weglGetTexLevelParameterfv(target,level,pname,params);
2770 reply = enif_make_tuple1(env,
2771 enif_make_double(env, (double) params[0]));
2772 enif_send(NULL, self, env,
2773 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
2774 }
2775
ecb_glGetTexLevelParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2776 void ecb_glGetTexLevelParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2777 {
2778 ERL_NIF_TERM reply;
2779 GLenum target;
2780 GLint level;
2781 GLenum pname;
2782 GLint params[1];
2783 if(!enif_get_uint(env, argv[0], &target)) Badarg(5265,"target");
2784 if(!enif_get_int(env, argv[1], &level)) Badarg(5265,"level");
2785 if(!enif_get_uint(env, argv[2], &pname)) Badarg(5265,"pname");
2786 weglGetTexLevelParameteriv(target,level,pname,params);
2787 reply = enif_make_tuple1(env,
2788 enif_make_int(env, params[0]));
2789 enif_send(NULL, self, env,
2790 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
2791 }
2792
ecb_glTexImage1D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2793 void ecb_glTexImage1D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2794 {
2795 GLenum target;
2796 GLint level;
2797 GLint internalFormat;
2798 GLsizei width;
2799 GLint border;
2800 GLenum format;
2801 GLenum type;
2802 ErlNifBinary pixels;
2803 GLvoid *pixels_idx;
2804 if(!enif_get_uint(env, argv[0], &target)) Badarg(5266,"target");
2805 if(!enif_get_int(env, argv[1], &level)) Badarg(5266,"level");
2806 if(!enif_get_int(env, argv[2], &internalFormat)) Badarg(5266,"internalFormat");
2807 if(!enif_get_int(env, argv[3], &width)) Badarg(5266,"width");
2808 if(!enif_get_int(env, argv[4], &border)) Badarg(5266,"border");
2809 if(!enif_get_uint(env, argv[5], &format)) Badarg(5266,"format");
2810 if(!enif_get_uint(env, argv[6], &type)) Badarg(5266,"type");
2811 if(!egl_get_ptr(env, argv[7], (void **) &pixels_idx)) {
2812 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[7], &pixels))
2813 pixels_idx = (GLvoid *) pixels.data;
2814 else Badarg(5266,"pixels");
2815 }
2816 weglTexImage1D(target,level,internalFormat,width,border,format,type,pixels_idx);
2817 }
2818
ecb_glTexImage2D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2819 void ecb_glTexImage2D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2820 {
2821 GLenum target;
2822 GLint level;
2823 GLint internalFormat;
2824 GLsizei width;
2825 GLsizei height;
2826 GLint border;
2827 GLenum format;
2828 GLenum type;
2829 ErlNifBinary pixels;
2830 GLvoid *pixels_idx;
2831 if(!enif_get_uint(env, argv[0], &target)) Badarg(5268,"target");
2832 if(!enif_get_int(env, argv[1], &level)) Badarg(5268,"level");
2833 if(!enif_get_int(env, argv[2], &internalFormat)) Badarg(5268,"internalFormat");
2834 if(!enif_get_int(env, argv[3], &width)) Badarg(5268,"width");
2835 if(!enif_get_int(env, argv[4], &height)) Badarg(5268,"height");
2836 if(!enif_get_int(env, argv[5], &border)) Badarg(5268,"border");
2837 if(!enif_get_uint(env, argv[6], &format)) Badarg(5268,"format");
2838 if(!enif_get_uint(env, argv[7], &type)) Badarg(5268,"type");
2839 if(!egl_get_ptr(env, argv[8], (void **) &pixels_idx)) {
2840 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[8], &pixels))
2841 pixels_idx = (GLvoid *) pixels.data;
2842 else Badarg(5268,"pixels");
2843 }
2844 weglTexImage2D(target,level,internalFormat,width,height,border,format,type,pixels_idx);
2845 }
2846
ecb_glGetTexImage(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2847 void ecb_glGetTexImage(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2848 {
2849 GLenum target;
2850 GLint level;
2851 GLenum format;
2852 GLenum type;
2853 ErlNifBinary pixels;
2854 if(!enif_get_uint(env, argv[0], &target)) Badarg(5270,"target");
2855 if(!enif_get_int(env, argv[1], &level)) Badarg(5270,"level");
2856 if(!enif_get_uint(env, argv[2], &format)) Badarg(5270,"format");
2857 if(!enif_get_uint(env, argv[3], &type)) Badarg(5270,"type");
2858 if(enif_is_binary(env, argv[4]))
2859 enif_inspect_binary(env, argv[4], &pixels);
2860 else if(enif_is_tuple(env, argv[4])) {
2861 int pixels_a;
2862 const ERL_NIF_TERM *pixels_t;
2863 if(enif_get_tuple(env, argv[4], &pixels_a, &pixels_t) &&
2864 enif_is_binary(env, pixels_t[1]))
2865 enif_inspect_binary(env, pixels_t[1], &pixels);
2866 else Badarg(5270, "pixels");
2867 } else Badarg(5270, "pixels");
2868 weglGetTexImage(target,level,format,type,(GLvoid *) pixels.data);
2869 enif_send(NULL, self, env,
2870 enif_make_tuple2(env,EGL_ATOM_REPLY,
2871 EGL_ATOM_OK));
2872 }
2873
ecb_glGenTextures(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2874 void ecb_glGenTextures(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2875 {
2876 ERL_NIF_TERM reply;
2877 GLsizei n;
2878 if(!enif_get_int(env, argv[0], &n)) Badarg(5271,"n");
2879 std::vector <GLuint> textures (n);
2880 std::vector <ERL_NIF_TERM> textures_ts (n);
2881 weglGenTextures(n,textures.data());
2882 for(int ri=0; ri < (int) n; ri++)
2883 textures_ts[ri] = enif_make_int(env, textures[ri]);
2884 reply = enif_make_list_from_array(env, textures_ts.data(), n);
2885 enif_send(NULL, self, env,
2886 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
2887 }
2888
ecb_glDeleteTextures(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2889 void ecb_glDeleteTextures(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2890 {
2891 GLsizei n;
2892 GLuint *textures;
2893 if(!enif_get_int(env, argv[0], &n)) Badarg(5272,"n");
2894 if(!enif_is_list(env, argv[1])) Badarg(5272, "textures")
2895 else {
2896 ERL_NIF_TERM textures_l, textures_h, textures_t;
2897 std::vector <GLuint> textures_vec;
2898 GLuint textures_tmp;
2899 textures_l = argv[1];
2900 while(enif_get_list_cell(env, textures_l, &textures_h, &textures_t)) {
2901 if(!enif_get_uint(env, textures_h, &textures_tmp)) Badarg(5272,"textures");
2902 textures_vec.push_back(textures_tmp);
2903 textures_l = textures_t;
2904 };
2905 textures = textures_vec.data();
2906 }
2907 weglDeleteTextures(n,textures);
2908 }
2909
ecb_glBindTexture(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2910 void ecb_glBindTexture(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2911 {
2912 GLenum target;
2913 GLuint texture;
2914 if(!enif_get_uint(env, argv[0], &target)) Badarg(5273,"target");
2915 if(!enif_get_uint(env, argv[1], &texture)) Badarg(5273,"texture");
2916 weglBindTexture(target,texture);
2917 }
2918
ecb_glPrioritizeTextures(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2919 void ecb_glPrioritizeTextures(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2920 {
2921 GLsizei n;
2922 GLuint *textures;
2923 GLclampf *priorities;
2924 if(!enif_get_int(env, argv[0], &n)) Badarg(5274,"n");
2925 if(!enif_is_list(env, argv[1])) Badarg(5274, "textures")
2926 else {
2927 ERL_NIF_TERM textures_l, textures_h, textures_t;
2928 std::vector <GLuint> textures_vec;
2929 GLuint textures_tmp;
2930 textures_l = argv[1];
2931 while(enif_get_list_cell(env, textures_l, &textures_h, &textures_t)) {
2932 if(!enif_get_uint(env, textures_h, &textures_tmp)) Badarg(5274,"textures");
2933 textures_vec.push_back(textures_tmp);
2934 textures_l = textures_t;
2935 };
2936 textures = textures_vec.data();
2937 }
2938 if(!enif_is_list(env, argv[2])) Badarg(5274, "priorities")
2939 else {
2940 ERL_NIF_TERM priorities_l, priorities_h, priorities_t;
2941 std::vector <GLclampf> priorities_vec;
2942 GLclampf priorities_tmp;
2943 priorities_l = argv[2];
2944 while(enif_get_list_cell(env, priorities_l, &priorities_h, &priorities_t)) {
2945 if(!egl_get_float(env, priorities_h, &priorities_tmp)) Badarg(5274,"priorities");
2946 priorities_vec.push_back(priorities_tmp);
2947 priorities_l = priorities_t;
2948 };
2949 priorities = priorities_vec.data();
2950 }
2951 weglPrioritizeTextures(n,textures,priorities);
2952 }
2953
ecb_glAreTexturesResident(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2954 void ecb_glAreTexturesResident(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2955 {
2956 GLboolean result;
2957 ERL_NIF_TERM reply;
2958 GLsizei n;
2959 GLuint *textures;
2960 if(!enif_get_int(env, argv[0], &n)) Badarg(5275,"n");
2961 if(!enif_is_list(env, argv[1])) Badarg(5275, "textures")
2962 else {
2963 ERL_NIF_TERM textures_l, textures_h, textures_t;
2964 std::vector <GLuint> textures_vec;
2965 GLuint textures_tmp;
2966 textures_l = argv[1];
2967 while(enif_get_list_cell(env, textures_l, &textures_h, &textures_t)) {
2968 if(!enif_get_uint(env, textures_h, &textures_tmp)) Badarg(5275,"textures");
2969 textures_vec.push_back(textures_tmp);
2970 textures_l = textures_t;
2971 };
2972 textures = textures_vec.data();
2973 }
2974 std::vector <GLboolean> residences (n);
2975 std::vector <ERL_NIF_TERM> residences_ts (n);
2976 result = weglAreTexturesResident(n,textures,residences.data());
2977 for(int ri=0; ri < (int) n; ri++)
2978 residences_ts[ri] = enif_make_int(env, residences[ri]);
2979 reply = enif_make_tuple2(env,
2980 enif_make_int(env, result),
2981 enif_make_list_from_array(env, residences_ts.data(), n) );
2982 enif_send(NULL, self, env,
2983 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
2984 }
2985
ecb_glIsTexture(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2986 void ecb_glIsTexture(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2987 {
2988 GLboolean result;
2989 ERL_NIF_TERM reply;
2990 GLuint texture;
2991 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5276,"texture");
2992 result = weglIsTexture(texture);
2993 reply = enif_make_int(env, result);
2994 enif_send(NULL, self, env,
2995 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
2996 }
2997
ecb_glTexSubImage1D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])2998 void ecb_glTexSubImage1D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
2999 {
3000 GLenum target;
3001 GLint level;
3002 GLint xoffset;
3003 GLsizei width;
3004 GLenum format;
3005 GLenum type;
3006 ErlNifBinary pixels;
3007 GLvoid *pixels_idx;
3008 if(!enif_get_uint(env, argv[0], &target)) Badarg(5277,"target");
3009 if(!enif_get_int(env, argv[1], &level)) Badarg(5277,"level");
3010 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5277,"xoffset");
3011 if(!enif_get_int(env, argv[3], &width)) Badarg(5277,"width");
3012 if(!enif_get_uint(env, argv[4], &format)) Badarg(5277,"format");
3013 if(!enif_get_uint(env, argv[5], &type)) Badarg(5277,"type");
3014 if(!egl_get_ptr(env, argv[6], (void **) &pixels_idx)) {
3015 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[6], &pixels))
3016 pixels_idx = (GLvoid *) pixels.data;
3017 else Badarg(5277,"pixels");
3018 }
3019 weglTexSubImage1D(target,level,xoffset,width,format,type,pixels_idx);
3020 }
3021
ecb_glTexSubImage2D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3022 void ecb_glTexSubImage2D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3023 {
3024 GLenum target;
3025 GLint level;
3026 GLint xoffset;
3027 GLint yoffset;
3028 GLsizei width;
3029 GLsizei height;
3030 GLenum format;
3031 GLenum type;
3032 ErlNifBinary pixels;
3033 GLvoid *pixels_idx;
3034 if(!enif_get_uint(env, argv[0], &target)) Badarg(5279,"target");
3035 if(!enif_get_int(env, argv[1], &level)) Badarg(5279,"level");
3036 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5279,"xoffset");
3037 if(!enif_get_int(env, argv[3], &yoffset)) Badarg(5279,"yoffset");
3038 if(!enif_get_int(env, argv[4], &width)) Badarg(5279,"width");
3039 if(!enif_get_int(env, argv[5], &height)) Badarg(5279,"height");
3040 if(!enif_get_uint(env, argv[6], &format)) Badarg(5279,"format");
3041 if(!enif_get_uint(env, argv[7], &type)) Badarg(5279,"type");
3042 if(!egl_get_ptr(env, argv[8], (void **) &pixels_idx)) {
3043 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[8], &pixels))
3044 pixels_idx = (GLvoid *) pixels.data;
3045 else Badarg(5279,"pixels");
3046 }
3047 weglTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels_idx);
3048 }
3049
ecb_glCopyTexImage1D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3050 void ecb_glCopyTexImage1D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3051 {
3052 GLenum target;
3053 GLint level;
3054 GLenum internalformat;
3055 GLint x;
3056 GLint y;
3057 GLsizei width;
3058 GLint border;
3059 if(!enif_get_uint(env, argv[0], &target)) Badarg(5281,"target");
3060 if(!enif_get_int(env, argv[1], &level)) Badarg(5281,"level");
3061 if(!enif_get_uint(env, argv[2], &internalformat)) Badarg(5281,"internalformat");
3062 if(!enif_get_int(env, argv[3], &x)) Badarg(5281,"x");
3063 if(!enif_get_int(env, argv[4], &y)) Badarg(5281,"y");
3064 if(!enif_get_int(env, argv[5], &width)) Badarg(5281,"width");
3065 if(!enif_get_int(env, argv[6], &border)) Badarg(5281,"border");
3066 weglCopyTexImage1D(target,level,internalformat,x,y,width,border);
3067 }
3068
ecb_glCopyTexImage2D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3069 void ecb_glCopyTexImage2D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3070 {
3071 GLenum target;
3072 GLint level;
3073 GLenum internalformat;
3074 GLint x;
3075 GLint y;
3076 GLsizei width;
3077 GLsizei height;
3078 GLint border;
3079 if(!enif_get_uint(env, argv[0], &target)) Badarg(5282,"target");
3080 if(!enif_get_int(env, argv[1], &level)) Badarg(5282,"level");
3081 if(!enif_get_uint(env, argv[2], &internalformat)) Badarg(5282,"internalformat");
3082 if(!enif_get_int(env, argv[3], &x)) Badarg(5282,"x");
3083 if(!enif_get_int(env, argv[4], &y)) Badarg(5282,"y");
3084 if(!enif_get_int(env, argv[5], &width)) Badarg(5282,"width");
3085 if(!enif_get_int(env, argv[6], &height)) Badarg(5282,"height");
3086 if(!enif_get_int(env, argv[7], &border)) Badarg(5282,"border");
3087 weglCopyTexImage2D(target,level,internalformat,x,y,width,height,border);
3088 }
3089
ecb_glCopyTexSubImage1D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3090 void ecb_glCopyTexSubImage1D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3091 {
3092 GLenum target;
3093 GLint level;
3094 GLint xoffset;
3095 GLint x;
3096 GLint y;
3097 GLsizei width;
3098 if(!enif_get_uint(env, argv[0], &target)) Badarg(5283,"target");
3099 if(!enif_get_int(env, argv[1], &level)) Badarg(5283,"level");
3100 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5283,"xoffset");
3101 if(!enif_get_int(env, argv[3], &x)) Badarg(5283,"x");
3102 if(!enif_get_int(env, argv[4], &y)) Badarg(5283,"y");
3103 if(!enif_get_int(env, argv[5], &width)) Badarg(5283,"width");
3104 weglCopyTexSubImage1D(target,level,xoffset,x,y,width);
3105 }
3106
ecb_glCopyTexSubImage2D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3107 void ecb_glCopyTexSubImage2D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3108 {
3109 GLenum target;
3110 GLint level;
3111 GLint xoffset;
3112 GLint yoffset;
3113 GLint x;
3114 GLint y;
3115 GLsizei width;
3116 GLsizei height;
3117 if(!enif_get_uint(env, argv[0], &target)) Badarg(5284,"target");
3118 if(!enif_get_int(env, argv[1], &level)) Badarg(5284,"level");
3119 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5284,"xoffset");
3120 if(!enif_get_int(env, argv[3], &yoffset)) Badarg(5284,"yoffset");
3121 if(!enif_get_int(env, argv[4], &x)) Badarg(5284,"x");
3122 if(!enif_get_int(env, argv[5], &y)) Badarg(5284,"y");
3123 if(!enif_get_int(env, argv[6], &width)) Badarg(5284,"width");
3124 if(!enif_get_int(env, argv[7], &height)) Badarg(5284,"height");
3125 weglCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
3126 }
3127
ecb_glMap1d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3128 void ecb_glMap1d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3129 {
3130 GLenum target;
3131 GLdouble u1;
3132 GLdouble u2;
3133 GLint stride;
3134 GLint order;
3135 ErlNifBinary points;
3136 if(!enif_get_uint(env, argv[0], &target)) Badarg(5285,"target");
3137 if(!enif_get_double(env, argv[1], &u1)) Badarg(5285,"u1");
3138 if(!enif_get_double(env, argv[2], &u2)) Badarg(5285,"u2");
3139 if(!enif_get_int(env, argv[3], &stride)) Badarg(5285,"stride");
3140 if(!enif_get_int(env, argv[4], &order)) Badarg(5285,"order");
3141 if(!enif_inspect_binary(env, argv[5], &points)) Badarg(5285,"points");
3142 weglMap1d(target,u1,u2,stride,order,(GLdouble *) points.data);
3143 }
3144
ecb_glMap1f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3145 void ecb_glMap1f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3146 {
3147 GLenum target;
3148 GLfloat u1;
3149 GLfloat u2;
3150 GLint stride;
3151 GLint order;
3152 ErlNifBinary points;
3153 if(!enif_get_uint(env, argv[0], &target)) Badarg(5286,"target");
3154 if(!egl_get_float(env, argv[1], &u1)) Badarg(5286,"u1");
3155 if(!egl_get_float(env, argv[2], &u2)) Badarg(5286,"u2");
3156 if(!enif_get_int(env, argv[3], &stride)) Badarg(5286,"stride");
3157 if(!enif_get_int(env, argv[4], &order)) Badarg(5286,"order");
3158 if(!enif_inspect_binary(env, argv[5], &points)) Badarg(5286,"points");
3159 weglMap1f(target,u1,u2,stride,order,(GLfloat *) points.data);
3160 }
3161
ecb_glMap2d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3162 void ecb_glMap2d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3163 {
3164 GLenum target;
3165 GLdouble u1;
3166 GLdouble u2;
3167 GLint ustride;
3168 GLint uorder;
3169 GLdouble v1;
3170 GLdouble v2;
3171 GLint vstride;
3172 GLint vorder;
3173 ErlNifBinary points;
3174 if(!enif_get_uint(env, argv[0], &target)) Badarg(5287,"target");
3175 if(!enif_get_double(env, argv[1], &u1)) Badarg(5287,"u1");
3176 if(!enif_get_double(env, argv[2], &u2)) Badarg(5287,"u2");
3177 if(!enif_get_int(env, argv[3], &ustride)) Badarg(5287,"ustride");
3178 if(!enif_get_int(env, argv[4], &uorder)) Badarg(5287,"uorder");
3179 if(!enif_get_double(env, argv[5], &v1)) Badarg(5287,"v1");
3180 if(!enif_get_double(env, argv[6], &v2)) Badarg(5287,"v2");
3181 if(!enif_get_int(env, argv[7], &vstride)) Badarg(5287,"vstride");
3182 if(!enif_get_int(env, argv[8], &vorder)) Badarg(5287,"vorder");
3183 if(!enif_inspect_binary(env, argv[9], &points)) Badarg(5287,"points");
3184 weglMap2d(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,(GLdouble *) points.data);
3185 }
3186
ecb_glMap2f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3187 void ecb_glMap2f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3188 {
3189 GLenum target;
3190 GLfloat u1;
3191 GLfloat u2;
3192 GLint ustride;
3193 GLint uorder;
3194 GLfloat v1;
3195 GLfloat v2;
3196 GLint vstride;
3197 GLint vorder;
3198 ErlNifBinary points;
3199 if(!enif_get_uint(env, argv[0], &target)) Badarg(5288,"target");
3200 if(!egl_get_float(env, argv[1], &u1)) Badarg(5288,"u1");
3201 if(!egl_get_float(env, argv[2], &u2)) Badarg(5288,"u2");
3202 if(!enif_get_int(env, argv[3], &ustride)) Badarg(5288,"ustride");
3203 if(!enif_get_int(env, argv[4], &uorder)) Badarg(5288,"uorder");
3204 if(!egl_get_float(env, argv[5], &v1)) Badarg(5288,"v1");
3205 if(!egl_get_float(env, argv[6], &v2)) Badarg(5288,"v2");
3206 if(!enif_get_int(env, argv[7], &vstride)) Badarg(5288,"vstride");
3207 if(!enif_get_int(env, argv[8], &vorder)) Badarg(5288,"vorder");
3208 if(!enif_inspect_binary(env, argv[9], &points)) Badarg(5288,"points");
3209 weglMap2f(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,(GLfloat *) points.data);
3210 }
3211
ecb_glGetMapdv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3212 void ecb_glGetMapdv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3213 {
3214 GLenum target;
3215 GLenum query;
3216 ErlNifBinary v;
3217 if(!enif_get_uint(env, argv[0], &target)) Badarg(5289,"target");
3218 if(!enif_get_uint(env, argv[1], &query)) Badarg(5289,"query");
3219 if(enif_is_binary(env, argv[2]))
3220 enif_inspect_binary(env, argv[2], &v);
3221 else if(enif_is_tuple(env, argv[2])) {
3222 int v_a;
3223 const ERL_NIF_TERM *v_t;
3224 if(enif_get_tuple(env, argv[2], &v_a, &v_t) &&
3225 enif_is_binary(env, v_t[1]))
3226 enif_inspect_binary(env, v_t[1], &v);
3227 else Badarg(5289, "v");
3228 } else Badarg(5289, "v");
3229 weglGetMapdv(target,query,(GLdouble *) v.data);
3230 enif_send(NULL, self, env,
3231 enif_make_tuple2(env,EGL_ATOM_REPLY,
3232 EGL_ATOM_OK));
3233 }
3234
ecb_glGetMapfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3235 void ecb_glGetMapfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3236 {
3237 GLenum target;
3238 GLenum query;
3239 ErlNifBinary v;
3240 if(!enif_get_uint(env, argv[0], &target)) Badarg(5290,"target");
3241 if(!enif_get_uint(env, argv[1], &query)) Badarg(5290,"query");
3242 if(enif_is_binary(env, argv[2]))
3243 enif_inspect_binary(env, argv[2], &v);
3244 else if(enif_is_tuple(env, argv[2])) {
3245 int v_a;
3246 const ERL_NIF_TERM *v_t;
3247 if(enif_get_tuple(env, argv[2], &v_a, &v_t) &&
3248 enif_is_binary(env, v_t[1]))
3249 enif_inspect_binary(env, v_t[1], &v);
3250 else Badarg(5290, "v");
3251 } else Badarg(5290, "v");
3252 weglGetMapfv(target,query,(GLfloat *) v.data);
3253 enif_send(NULL, self, env,
3254 enif_make_tuple2(env,EGL_ATOM_REPLY,
3255 EGL_ATOM_OK));
3256 }
3257
ecb_glGetMapiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3258 void ecb_glGetMapiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3259 {
3260 GLenum target;
3261 GLenum query;
3262 ErlNifBinary v;
3263 if(!enif_get_uint(env, argv[0], &target)) Badarg(5291,"target");
3264 if(!enif_get_uint(env, argv[1], &query)) Badarg(5291,"query");
3265 if(enif_is_binary(env, argv[2]))
3266 enif_inspect_binary(env, argv[2], &v);
3267 else if(enif_is_tuple(env, argv[2])) {
3268 int v_a;
3269 const ERL_NIF_TERM *v_t;
3270 if(enif_get_tuple(env, argv[2], &v_a, &v_t) &&
3271 enif_is_binary(env, v_t[1]))
3272 enif_inspect_binary(env, v_t[1], &v);
3273 else Badarg(5291, "v");
3274 } else Badarg(5291, "v");
3275 weglGetMapiv(target,query,(GLint *) v.data);
3276 enif_send(NULL, self, env,
3277 enif_make_tuple2(env,EGL_ATOM_REPLY,
3278 EGL_ATOM_OK));
3279 }
3280
ecb_glEvalCoord1d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3281 void ecb_glEvalCoord1d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3282 {
3283 GLdouble u;
3284 if(!enif_get_double(env, argv[0], &u)) Badarg(5292,"u");
3285 weglEvalCoord1d(u);
3286 }
3287
ecb_glEvalCoord1f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3288 void ecb_glEvalCoord1f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3289 {
3290 GLfloat u;
3291 if(!egl_get_float(env, argv[0], &u)) Badarg(5293,"u");
3292 weglEvalCoord1f(u);
3293 }
3294
ecb_glEvalCoord2d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3295 void ecb_glEvalCoord2d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3296 {
3297 GLdouble u;
3298 GLdouble v;
3299 if(!enif_get_double(env, argv[0], &u)) Badarg(5294,"u");
3300 if(!enif_get_double(env, argv[1], &v)) Badarg(5294,"v");
3301 weglEvalCoord2d(u,v);
3302 }
3303
ecb_glEvalCoord2f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3304 void ecb_glEvalCoord2f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3305 {
3306 GLfloat u;
3307 GLfloat v;
3308 if(!egl_get_float(env, argv[0], &u)) Badarg(5295,"u");
3309 if(!egl_get_float(env, argv[1], &v)) Badarg(5295,"v");
3310 weglEvalCoord2f(u,v);
3311 }
3312
ecb_glMapGrid1d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3313 void ecb_glMapGrid1d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3314 {
3315 GLint un;
3316 GLdouble u1;
3317 GLdouble u2;
3318 if(!enif_get_int(env, argv[0], &un)) Badarg(5296,"un");
3319 if(!enif_get_double(env, argv[1], &u1)) Badarg(5296,"u1");
3320 if(!enif_get_double(env, argv[2], &u2)) Badarg(5296,"u2");
3321 weglMapGrid1d(un,u1,u2);
3322 }
3323
ecb_glMapGrid1f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3324 void ecb_glMapGrid1f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3325 {
3326 GLint un;
3327 GLfloat u1;
3328 GLfloat u2;
3329 if(!enif_get_int(env, argv[0], &un)) Badarg(5297,"un");
3330 if(!egl_get_float(env, argv[1], &u1)) Badarg(5297,"u1");
3331 if(!egl_get_float(env, argv[2], &u2)) Badarg(5297,"u2");
3332 weglMapGrid1f(un,u1,u2);
3333 }
3334
ecb_glMapGrid2d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3335 void ecb_glMapGrid2d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3336 {
3337 GLint un;
3338 GLdouble u1;
3339 GLdouble u2;
3340 GLint vn;
3341 GLdouble v1;
3342 GLdouble v2;
3343 if(!enif_get_int(env, argv[0], &un)) Badarg(5298,"un");
3344 if(!enif_get_double(env, argv[1], &u1)) Badarg(5298,"u1");
3345 if(!enif_get_double(env, argv[2], &u2)) Badarg(5298,"u2");
3346 if(!enif_get_int(env, argv[3], &vn)) Badarg(5298,"vn");
3347 if(!enif_get_double(env, argv[4], &v1)) Badarg(5298,"v1");
3348 if(!enif_get_double(env, argv[5], &v2)) Badarg(5298,"v2");
3349 weglMapGrid2d(un,u1,u2,vn,v1,v2);
3350 }
3351
ecb_glMapGrid2f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3352 void ecb_glMapGrid2f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3353 {
3354 GLint un;
3355 GLfloat u1;
3356 GLfloat u2;
3357 GLint vn;
3358 GLfloat v1;
3359 GLfloat v2;
3360 if(!enif_get_int(env, argv[0], &un)) Badarg(5299,"un");
3361 if(!egl_get_float(env, argv[1], &u1)) Badarg(5299,"u1");
3362 if(!egl_get_float(env, argv[2], &u2)) Badarg(5299,"u2");
3363 if(!enif_get_int(env, argv[3], &vn)) Badarg(5299,"vn");
3364 if(!egl_get_float(env, argv[4], &v1)) Badarg(5299,"v1");
3365 if(!egl_get_float(env, argv[5], &v2)) Badarg(5299,"v2");
3366 weglMapGrid2f(un,u1,u2,vn,v1,v2);
3367 }
3368
ecb_glEvalPoint1(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3369 void ecb_glEvalPoint1(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3370 {
3371 GLint i;
3372 if(!enif_get_int(env, argv[0], &i)) Badarg(5300,"i");
3373 weglEvalPoint1(i);
3374 }
3375
ecb_glEvalPoint2(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3376 void ecb_glEvalPoint2(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3377 {
3378 GLint i;
3379 GLint j;
3380 if(!enif_get_int(env, argv[0], &i)) Badarg(5301,"i");
3381 if(!enif_get_int(env, argv[1], &j)) Badarg(5301,"j");
3382 weglEvalPoint2(i,j);
3383 }
3384
ecb_glEvalMesh1(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3385 void ecb_glEvalMesh1(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3386 {
3387 GLenum mode;
3388 GLint i1;
3389 GLint i2;
3390 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5302,"mode");
3391 if(!enif_get_int(env, argv[1], &i1)) Badarg(5302,"i1");
3392 if(!enif_get_int(env, argv[2], &i2)) Badarg(5302,"i2");
3393 weglEvalMesh1(mode,i1,i2);
3394 }
3395
ecb_glEvalMesh2(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3396 void ecb_glEvalMesh2(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3397 {
3398 GLenum mode;
3399 GLint i1;
3400 GLint i2;
3401 GLint j1;
3402 GLint j2;
3403 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5303,"mode");
3404 if(!enif_get_int(env, argv[1], &i1)) Badarg(5303,"i1");
3405 if(!enif_get_int(env, argv[2], &i2)) Badarg(5303,"i2");
3406 if(!enif_get_int(env, argv[3], &j1)) Badarg(5303,"j1");
3407 if(!enif_get_int(env, argv[4], &j2)) Badarg(5303,"j2");
3408 weglEvalMesh2(mode,i1,i2,j1,j2);
3409 }
3410
ecb_glFogf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3411 void ecb_glFogf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3412 {
3413 GLenum pname;
3414 GLfloat param;
3415 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5304,"pname");
3416 if(!egl_get_float(env, argv[1], ¶m)) Badarg(5304,"param");
3417 weglFogf(pname,param);
3418 }
3419
ecb_glFogi(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3420 void ecb_glFogi(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3421 {
3422 GLenum pname;
3423 GLint param;
3424 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5305,"pname");
3425 if(!enif_get_int(env, argv[1], ¶m)) Badarg(5305,"param");
3426 weglFogi(pname,param);
3427 }
3428
ecb_glFogfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3429 void ecb_glFogfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3430 {
3431 GLenum pname;
3432 GLfloat params[4];
3433 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5306,"pname");
3434 {
3435 int params_a;
3436 const ERL_NIF_TERM *params_t;
3437 int i;
3438 if(!enif_get_tuple(env, argv[1], ¶ms_a, ¶ms_t)) {
3439 Badarg(5306,"params");
3440 } else {
3441 for(i = 0; i < params_a; i++)
3442 if(!egl_get_float(env, params_t[i], ¶ms[i])) Badarg(5306,"params");
3443 }};
3444 weglFogfv(pname,params);
3445 }
3446
ecb_glFogiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3447 void ecb_glFogiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3448 {
3449 GLenum pname;
3450 GLint params[4];
3451 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5307,"pname");
3452 {
3453 int params_a;
3454 const ERL_NIF_TERM *params_t;
3455 int i;
3456 if(!enif_get_tuple(env, argv[1], ¶ms_a, ¶ms_t)) {
3457 Badarg(5307,"params");
3458 } else {
3459 for(i = 0; i < params_a; i++)
3460 if(!enif_get_int(env, params_t[i], ¶ms[i])) Badarg(5307,"params");
3461 }};
3462 weglFogiv(pname,params);
3463 }
3464
ecb_glFeedbackBuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3465 void ecb_glFeedbackBuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3466 {
3467 GLsizei size;
3468 GLenum type;
3469 ErlNifBinary buffer;
3470 if(!enif_get_int(env, argv[0], &size)) Badarg(5308,"size");
3471 if(!enif_get_uint(env, argv[1], &type)) Badarg(5308,"type");
3472 if(enif_is_binary(env, argv[2]))
3473 enif_inspect_binary(env, argv[2], &buffer);
3474 else if(enif_is_tuple(env, argv[2])) {
3475 int buffer_a;
3476 const ERL_NIF_TERM *buffer_t;
3477 if(enif_get_tuple(env, argv[2], &buffer_a, &buffer_t) &&
3478 enif_is_binary(env, buffer_t[1]))
3479 enif_inspect_binary(env, buffer_t[1], &buffer);
3480 else Badarg(5308, "buffer");
3481 } else Badarg(5308, "buffer");
3482 weglFeedbackBuffer(size,type,(GLfloat *) buffer.data);
3483 enif_send(NULL, self, env,
3484 enif_make_tuple2(env,EGL_ATOM_REPLY,
3485 EGL_ATOM_OK));
3486 }
3487
ecb_glPassThrough(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3488 void ecb_glPassThrough(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3489 {
3490 GLfloat token;
3491 if(!egl_get_float(env, argv[0], &token)) Badarg(5309,"token");
3492 weglPassThrough(token);
3493 }
3494
ecb_glSelectBuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3495 void ecb_glSelectBuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3496 {
3497 GLsizei size;
3498 ErlNifBinary buffer;
3499 if(!enif_get_int(env, argv[0], &size)) Badarg(5310,"size");
3500 if(enif_is_binary(env, argv[1]))
3501 enif_inspect_binary(env, argv[1], &buffer);
3502 else if(enif_is_tuple(env, argv[1])) {
3503 int buffer_a;
3504 const ERL_NIF_TERM *buffer_t;
3505 if(enif_get_tuple(env, argv[1], &buffer_a, &buffer_t) &&
3506 enif_is_binary(env, buffer_t[1]))
3507 enif_inspect_binary(env, buffer_t[1], &buffer);
3508 else Badarg(5310, "buffer");
3509 } else Badarg(5310, "buffer");
3510 weglSelectBuffer(size,(GLuint *) buffer.data);
3511 enif_send(NULL, self, env,
3512 enif_make_tuple2(env,EGL_ATOM_REPLY,
3513 EGL_ATOM_OK));
3514 }
3515
ecb_glInitNames(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3516 void ecb_glInitNames(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3517 {
3518 weglInitNames();
3519 }
3520
ecb_glLoadName(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3521 void ecb_glLoadName(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3522 {
3523 GLuint name;
3524 if(!enif_get_uint(env, argv[0], &name)) Badarg(5312,"name");
3525 weglLoadName(name);
3526 }
3527
ecb_glPushName(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3528 void ecb_glPushName(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3529 {
3530 GLuint name;
3531 if(!enif_get_uint(env, argv[0], &name)) Badarg(5313,"name");
3532 weglPushName(name);
3533 }
3534
ecb_glPopName(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3535 void ecb_glPopName(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3536 {
3537 weglPopName();
3538 }
3539
ecb_glDrawRangeElements(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3540 void ecb_glDrawRangeElements(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3541 {
3542 GLenum mode;
3543 GLuint start;
3544 GLuint end;
3545 GLsizei count;
3546 GLenum type;
3547 ErlNifBinary indices;
3548 GLvoid *indices_idx;
3549 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5315,"mode");
3550 if(!enif_get_uint(env, argv[1], &start)) Badarg(5315,"start");
3551 if(!enif_get_uint(env, argv[2], &end)) Badarg(5315,"end");
3552 if(!enif_get_int(env, argv[3], &count)) Badarg(5315,"count");
3553 if(!enif_get_uint(env, argv[4], &type)) Badarg(5315,"type");
3554 if(!egl_get_ptr(env, argv[5], (void **) &indices_idx)) {
3555 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[5], &indices))
3556 indices_idx = (GLvoid *) indices.data;
3557 else Badarg(5315,"indices");
3558 }
3559 weglDrawRangeElements(mode,start,end,count,type,indices_idx);
3560 }
3561
ecb_glTexImage3D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3562 void ecb_glTexImage3D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3563 {
3564 GLenum target;
3565 GLint level;
3566 GLint internalFormat;
3567 GLsizei width;
3568 GLsizei height;
3569 GLsizei depth;
3570 GLint border;
3571 GLenum format;
3572 GLenum type;
3573 ErlNifBinary pixels;
3574 GLvoid *pixels_idx;
3575 if(!enif_get_uint(env, argv[0], &target)) Badarg(5317,"target");
3576 if(!enif_get_int(env, argv[1], &level)) Badarg(5317,"level");
3577 if(!enif_get_int(env, argv[2], &internalFormat)) Badarg(5317,"internalFormat");
3578 if(!enif_get_int(env, argv[3], &width)) Badarg(5317,"width");
3579 if(!enif_get_int(env, argv[4], &height)) Badarg(5317,"height");
3580 if(!enif_get_int(env, argv[5], &depth)) Badarg(5317,"depth");
3581 if(!enif_get_int(env, argv[6], &border)) Badarg(5317,"border");
3582 if(!enif_get_uint(env, argv[7], &format)) Badarg(5317,"format");
3583 if(!enif_get_uint(env, argv[8], &type)) Badarg(5317,"type");
3584 if(!egl_get_ptr(env, argv[9], (void **) &pixels_idx)) {
3585 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[9], &pixels))
3586 pixels_idx = (GLvoid *) pixels.data;
3587 else Badarg(5317,"pixels");
3588 }
3589 weglTexImage3D(target,level,internalFormat,width,height,depth,border,format,type,pixels_idx);
3590 }
3591
ecb_glTexSubImage3D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3592 void ecb_glTexSubImage3D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3593 {
3594 GLenum target;
3595 GLint level;
3596 GLint xoffset;
3597 GLint yoffset;
3598 GLint zoffset;
3599 GLsizei width;
3600 GLsizei height;
3601 GLsizei depth;
3602 GLenum format;
3603 GLenum type;
3604 ErlNifBinary pixels;
3605 GLvoid *pixels_idx;
3606 if(!enif_get_uint(env, argv[0], &target)) Badarg(5319,"target");
3607 if(!enif_get_int(env, argv[1], &level)) Badarg(5319,"level");
3608 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5319,"xoffset");
3609 if(!enif_get_int(env, argv[3], &yoffset)) Badarg(5319,"yoffset");
3610 if(!enif_get_int(env, argv[4], &zoffset)) Badarg(5319,"zoffset");
3611 if(!enif_get_int(env, argv[5], &width)) Badarg(5319,"width");
3612 if(!enif_get_int(env, argv[6], &height)) Badarg(5319,"height");
3613 if(!enif_get_int(env, argv[7], &depth)) Badarg(5319,"depth");
3614 if(!enif_get_uint(env, argv[8], &format)) Badarg(5319,"format");
3615 if(!enif_get_uint(env, argv[9], &type)) Badarg(5319,"type");
3616 if(!egl_get_ptr(env, argv[10], (void **) &pixels_idx)) {
3617 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[10], &pixels))
3618 pixels_idx = (GLvoid *) pixels.data;
3619 else Badarg(5319,"pixels");
3620 }
3621 weglTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels_idx);
3622 }
3623
ecb_glCopyTexSubImage3D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3624 void ecb_glCopyTexSubImage3D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3625 {
3626 GLenum target;
3627 GLint level;
3628 GLint xoffset;
3629 GLint yoffset;
3630 GLint zoffset;
3631 GLint x;
3632 GLint y;
3633 GLsizei width;
3634 GLsizei height;
3635 if(!enif_get_uint(env, argv[0], &target)) Badarg(5321,"target");
3636 if(!enif_get_int(env, argv[1], &level)) Badarg(5321,"level");
3637 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5321,"xoffset");
3638 if(!enif_get_int(env, argv[3], &yoffset)) Badarg(5321,"yoffset");
3639 if(!enif_get_int(env, argv[4], &zoffset)) Badarg(5321,"zoffset");
3640 if(!enif_get_int(env, argv[5], &x)) Badarg(5321,"x");
3641 if(!enif_get_int(env, argv[6], &y)) Badarg(5321,"y");
3642 if(!enif_get_int(env, argv[7], &width)) Badarg(5321,"width");
3643 if(!enif_get_int(env, argv[8], &height)) Badarg(5321,"height");
3644 weglCopyTexSubImage3D(target,level,xoffset,yoffset,zoffset,x,y,width,height);
3645 }
3646
ecb_glActiveTexture(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3647 void ecb_glActiveTexture(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3648 {
3649 GLenum texture;
3650 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5322,"texture");
3651 weglActiveTexture(texture);
3652 }
3653
ecb_glSampleCoverage(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3654 void ecb_glSampleCoverage(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3655 {
3656 GLclampf value;
3657 GLboolean invert;
3658 if(!egl_get_float(env, argv[0], &value)) Badarg(5323,"value");
3659 if(!egl_get_ubyte(env, argv[1], &invert)) Badarg(5323,"invert");
3660 weglSampleCoverage(value,invert);
3661 }
3662
ecb_glCompressedTexImage3D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3663 void ecb_glCompressedTexImage3D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3664 {
3665 GLenum target;
3666 GLint level;
3667 GLenum internalformat;
3668 GLsizei width;
3669 GLsizei height;
3670 GLsizei depth;
3671 GLint border;
3672 GLsizei imageSize;
3673 ErlNifBinary data;
3674 GLvoid *data_idx;
3675 if(!enif_get_uint(env, argv[0], &target)) Badarg(5324,"target");
3676 if(!enif_get_int(env, argv[1], &level)) Badarg(5324,"level");
3677 if(!enif_get_uint(env, argv[2], &internalformat)) Badarg(5324,"internalformat");
3678 if(!enif_get_int(env, argv[3], &width)) Badarg(5324,"width");
3679 if(!enif_get_int(env, argv[4], &height)) Badarg(5324,"height");
3680 if(!enif_get_int(env, argv[5], &depth)) Badarg(5324,"depth");
3681 if(!enif_get_int(env, argv[6], &border)) Badarg(5324,"border");
3682 if(!enif_get_int(env, argv[7], &imageSize)) Badarg(5324,"imageSize");
3683 if(!egl_get_ptr(env, argv[8], (void **) &data_idx)) {
3684 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[8], &data))
3685 data_idx = (GLvoid *) data.data;
3686 else Badarg(5324,"data");
3687 }
3688 weglCompressedTexImage3D(target,level,internalformat,width,height,depth,border,imageSize,data_idx);
3689 }
3690
ecb_glCompressedTexImage2D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3691 void ecb_glCompressedTexImage2D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3692 {
3693 GLenum target;
3694 GLint level;
3695 GLenum internalformat;
3696 GLsizei width;
3697 GLsizei height;
3698 GLint border;
3699 GLsizei imageSize;
3700 ErlNifBinary data;
3701 GLvoid *data_idx;
3702 if(!enif_get_uint(env, argv[0], &target)) Badarg(5326,"target");
3703 if(!enif_get_int(env, argv[1], &level)) Badarg(5326,"level");
3704 if(!enif_get_uint(env, argv[2], &internalformat)) Badarg(5326,"internalformat");
3705 if(!enif_get_int(env, argv[3], &width)) Badarg(5326,"width");
3706 if(!enif_get_int(env, argv[4], &height)) Badarg(5326,"height");
3707 if(!enif_get_int(env, argv[5], &border)) Badarg(5326,"border");
3708 if(!enif_get_int(env, argv[6], &imageSize)) Badarg(5326,"imageSize");
3709 if(!egl_get_ptr(env, argv[7], (void **) &data_idx)) {
3710 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[7], &data))
3711 data_idx = (GLvoid *) data.data;
3712 else Badarg(5326,"data");
3713 }
3714 weglCompressedTexImage2D(target,level,internalformat,width,height,border,imageSize,data_idx);
3715 }
3716
ecb_glCompressedTexImage1D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3717 void ecb_glCompressedTexImage1D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3718 {
3719 GLenum target;
3720 GLint level;
3721 GLenum internalformat;
3722 GLsizei width;
3723 GLint border;
3724 GLsizei imageSize;
3725 ErlNifBinary data;
3726 GLvoid *data_idx;
3727 if(!enif_get_uint(env, argv[0], &target)) Badarg(5328,"target");
3728 if(!enif_get_int(env, argv[1], &level)) Badarg(5328,"level");
3729 if(!enif_get_uint(env, argv[2], &internalformat)) Badarg(5328,"internalformat");
3730 if(!enif_get_int(env, argv[3], &width)) Badarg(5328,"width");
3731 if(!enif_get_int(env, argv[4], &border)) Badarg(5328,"border");
3732 if(!enif_get_int(env, argv[5], &imageSize)) Badarg(5328,"imageSize");
3733 if(!egl_get_ptr(env, argv[6], (void **) &data_idx)) {
3734 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[6], &data))
3735 data_idx = (GLvoid *) data.data;
3736 else Badarg(5328,"data");
3737 }
3738 weglCompressedTexImage1D(target,level,internalformat,width,border,imageSize,data_idx);
3739 }
3740
ecb_glCompressedTexSubImage3D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3741 void ecb_glCompressedTexSubImage3D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3742 {
3743 GLenum target;
3744 GLint level;
3745 GLint xoffset;
3746 GLint yoffset;
3747 GLint zoffset;
3748 GLsizei width;
3749 GLsizei height;
3750 GLsizei depth;
3751 GLenum format;
3752 GLsizei imageSize;
3753 ErlNifBinary data;
3754 GLvoid *data_idx;
3755 if(!enif_get_uint(env, argv[0], &target)) Badarg(5330,"target");
3756 if(!enif_get_int(env, argv[1], &level)) Badarg(5330,"level");
3757 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5330,"xoffset");
3758 if(!enif_get_int(env, argv[3], &yoffset)) Badarg(5330,"yoffset");
3759 if(!enif_get_int(env, argv[4], &zoffset)) Badarg(5330,"zoffset");
3760 if(!enif_get_int(env, argv[5], &width)) Badarg(5330,"width");
3761 if(!enif_get_int(env, argv[6], &height)) Badarg(5330,"height");
3762 if(!enif_get_int(env, argv[7], &depth)) Badarg(5330,"depth");
3763 if(!enif_get_uint(env, argv[8], &format)) Badarg(5330,"format");
3764 if(!enif_get_int(env, argv[9], &imageSize)) Badarg(5330,"imageSize");
3765 if(!egl_get_ptr(env, argv[10], (void **) &data_idx)) {
3766 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[10], &data))
3767 data_idx = (GLvoid *) data.data;
3768 else Badarg(5330,"data");
3769 }
3770 weglCompressedTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data_idx);
3771 }
3772
ecb_glCompressedTexSubImage2D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3773 void ecb_glCompressedTexSubImage2D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3774 {
3775 GLenum target;
3776 GLint level;
3777 GLint xoffset;
3778 GLint yoffset;
3779 GLsizei width;
3780 GLsizei height;
3781 GLenum format;
3782 GLsizei imageSize;
3783 ErlNifBinary data;
3784 GLvoid *data_idx;
3785 if(!enif_get_uint(env, argv[0], &target)) Badarg(5332,"target");
3786 if(!enif_get_int(env, argv[1], &level)) Badarg(5332,"level");
3787 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5332,"xoffset");
3788 if(!enif_get_int(env, argv[3], &yoffset)) Badarg(5332,"yoffset");
3789 if(!enif_get_int(env, argv[4], &width)) Badarg(5332,"width");
3790 if(!enif_get_int(env, argv[5], &height)) Badarg(5332,"height");
3791 if(!enif_get_uint(env, argv[6], &format)) Badarg(5332,"format");
3792 if(!enif_get_int(env, argv[7], &imageSize)) Badarg(5332,"imageSize");
3793 if(!egl_get_ptr(env, argv[8], (void **) &data_idx)) {
3794 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[8], &data))
3795 data_idx = (GLvoid *) data.data;
3796 else Badarg(5332,"data");
3797 }
3798 weglCompressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,imageSize,data_idx);
3799 }
3800
ecb_glCompressedTexSubImage1D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3801 void ecb_glCompressedTexSubImage1D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3802 {
3803 GLenum target;
3804 GLint level;
3805 GLint xoffset;
3806 GLsizei width;
3807 GLenum format;
3808 GLsizei imageSize;
3809 ErlNifBinary data;
3810 GLvoid *data_idx;
3811 if(!enif_get_uint(env, argv[0], &target)) Badarg(5334,"target");
3812 if(!enif_get_int(env, argv[1], &level)) Badarg(5334,"level");
3813 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5334,"xoffset");
3814 if(!enif_get_int(env, argv[3], &width)) Badarg(5334,"width");
3815 if(!enif_get_uint(env, argv[4], &format)) Badarg(5334,"format");
3816 if(!enif_get_int(env, argv[5], &imageSize)) Badarg(5334,"imageSize");
3817 if(!egl_get_ptr(env, argv[6], (void **) &data_idx)) {
3818 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[6], &data))
3819 data_idx = (GLvoid *) data.data;
3820 else Badarg(5334,"data");
3821 }
3822 weglCompressedTexSubImage1D(target,level,xoffset,width,format,imageSize,data_idx);
3823 }
3824
ecb_glGetCompressedTexImage(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3825 void ecb_glGetCompressedTexImage(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3826 {
3827 GLenum target;
3828 GLint lod;
3829 ErlNifBinary img;
3830 if(!enif_get_uint(env, argv[0], &target)) Badarg(5336,"target");
3831 if(!enif_get_int(env, argv[1], &lod)) Badarg(5336,"lod");
3832 if(enif_is_binary(env, argv[2]))
3833 enif_inspect_binary(env, argv[2], &img);
3834 else if(enif_is_tuple(env, argv[2])) {
3835 int img_a;
3836 const ERL_NIF_TERM *img_t;
3837 if(enif_get_tuple(env, argv[2], &img_a, &img_t) &&
3838 enif_is_binary(env, img_t[1]))
3839 enif_inspect_binary(env, img_t[1], &img);
3840 else Badarg(5336, "img");
3841 } else Badarg(5336, "img");
3842 weglGetCompressedTexImage(target,lod,(GLvoid *) img.data);
3843 enif_send(NULL, self, env,
3844 enif_make_tuple2(env,EGL_ATOM_REPLY,
3845 EGL_ATOM_OK));
3846 }
3847
ecb_glClientActiveTexture(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3848 void ecb_glClientActiveTexture(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3849 {
3850 GLenum texture;
3851 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5337,"texture");
3852 weglClientActiveTexture(texture);
3853 }
3854
ecb_glMultiTexCoord1d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3855 void ecb_glMultiTexCoord1d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3856 {
3857 GLenum target;
3858 GLdouble s;
3859 if(!enif_get_uint(env, argv[0], &target)) Badarg(5338,"target");
3860 if(!enif_get_double(env, argv[1], &s)) Badarg(5338,"s");
3861 weglMultiTexCoord1d(target,s);
3862 }
3863
ecb_glMultiTexCoord1f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3864 void ecb_glMultiTexCoord1f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3865 {
3866 GLenum target;
3867 GLfloat s;
3868 if(!enif_get_uint(env, argv[0], &target)) Badarg(5339,"target");
3869 if(!egl_get_float(env, argv[1], &s)) Badarg(5339,"s");
3870 weglMultiTexCoord1f(target,s);
3871 }
3872
ecb_glMultiTexCoord1i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3873 void ecb_glMultiTexCoord1i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3874 {
3875 GLenum target;
3876 GLint s;
3877 if(!enif_get_uint(env, argv[0], &target)) Badarg(5340,"target");
3878 if(!enif_get_int(env, argv[1], &s)) Badarg(5340,"s");
3879 weglMultiTexCoord1i(target,s);
3880 }
3881
ecb_glMultiTexCoord1s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3882 void ecb_glMultiTexCoord1s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3883 {
3884 GLenum target;
3885 GLshort s;
3886 if(!enif_get_uint(env, argv[0], &target)) Badarg(5341,"target");
3887 if(!egl_get_short(env, argv[1], &s)) Badarg(5341,"s");
3888 weglMultiTexCoord1s(target,s);
3889 }
3890
ecb_glMultiTexCoord2d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3891 void ecb_glMultiTexCoord2d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3892 {
3893 GLenum target;
3894 GLdouble s;
3895 GLdouble t;
3896 if(!enif_get_uint(env, argv[0], &target)) Badarg(5342,"target");
3897 if(!enif_get_double(env, argv[1], &s)) Badarg(5342,"s");
3898 if(!enif_get_double(env, argv[2], &t)) Badarg(5342,"t");
3899 weglMultiTexCoord2d(target,s,t);
3900 }
3901
ecb_glMultiTexCoord2f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3902 void ecb_glMultiTexCoord2f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3903 {
3904 GLenum target;
3905 GLfloat s;
3906 GLfloat t;
3907 if(!enif_get_uint(env, argv[0], &target)) Badarg(5343,"target");
3908 if(!egl_get_float(env, argv[1], &s)) Badarg(5343,"s");
3909 if(!egl_get_float(env, argv[2], &t)) Badarg(5343,"t");
3910 weglMultiTexCoord2f(target,s,t);
3911 }
3912
ecb_glMultiTexCoord2i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3913 void ecb_glMultiTexCoord2i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3914 {
3915 GLenum target;
3916 GLint s;
3917 GLint t;
3918 if(!enif_get_uint(env, argv[0], &target)) Badarg(5344,"target");
3919 if(!enif_get_int(env, argv[1], &s)) Badarg(5344,"s");
3920 if(!enif_get_int(env, argv[2], &t)) Badarg(5344,"t");
3921 weglMultiTexCoord2i(target,s,t);
3922 }
3923
ecb_glMultiTexCoord2s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3924 void ecb_glMultiTexCoord2s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3925 {
3926 GLenum target;
3927 GLshort s;
3928 GLshort t;
3929 if(!enif_get_uint(env, argv[0], &target)) Badarg(5345,"target");
3930 if(!egl_get_short(env, argv[1], &s)) Badarg(5345,"s");
3931 if(!egl_get_short(env, argv[2], &t)) Badarg(5345,"t");
3932 weglMultiTexCoord2s(target,s,t);
3933 }
3934
ecb_glMultiTexCoord3d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3935 void ecb_glMultiTexCoord3d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3936 {
3937 GLenum target;
3938 GLdouble s;
3939 GLdouble t;
3940 GLdouble r;
3941 if(!enif_get_uint(env, argv[0], &target)) Badarg(5346,"target");
3942 if(!enif_get_double(env, argv[1], &s)) Badarg(5346,"s");
3943 if(!enif_get_double(env, argv[2], &t)) Badarg(5346,"t");
3944 if(!enif_get_double(env, argv[3], &r)) Badarg(5346,"r");
3945 weglMultiTexCoord3d(target,s,t,r);
3946 }
3947
ecb_glMultiTexCoord3f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3948 void ecb_glMultiTexCoord3f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3949 {
3950 GLenum target;
3951 GLfloat s;
3952 GLfloat t;
3953 GLfloat r;
3954 if(!enif_get_uint(env, argv[0], &target)) Badarg(5347,"target");
3955 if(!egl_get_float(env, argv[1], &s)) Badarg(5347,"s");
3956 if(!egl_get_float(env, argv[2], &t)) Badarg(5347,"t");
3957 if(!egl_get_float(env, argv[3], &r)) Badarg(5347,"r");
3958 weglMultiTexCoord3f(target,s,t,r);
3959 }
3960
ecb_glMultiTexCoord3i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3961 void ecb_glMultiTexCoord3i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3962 {
3963 GLenum target;
3964 GLint s;
3965 GLint t;
3966 GLint r;
3967 if(!enif_get_uint(env, argv[0], &target)) Badarg(5348,"target");
3968 if(!enif_get_int(env, argv[1], &s)) Badarg(5348,"s");
3969 if(!enif_get_int(env, argv[2], &t)) Badarg(5348,"t");
3970 if(!enif_get_int(env, argv[3], &r)) Badarg(5348,"r");
3971 weglMultiTexCoord3i(target,s,t,r);
3972 }
3973
ecb_glMultiTexCoord3s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3974 void ecb_glMultiTexCoord3s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3975 {
3976 GLenum target;
3977 GLshort s;
3978 GLshort t;
3979 GLshort r;
3980 if(!enif_get_uint(env, argv[0], &target)) Badarg(5349,"target");
3981 if(!egl_get_short(env, argv[1], &s)) Badarg(5349,"s");
3982 if(!egl_get_short(env, argv[2], &t)) Badarg(5349,"t");
3983 if(!egl_get_short(env, argv[3], &r)) Badarg(5349,"r");
3984 weglMultiTexCoord3s(target,s,t,r);
3985 }
3986
ecb_glMultiTexCoord4d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])3987 void ecb_glMultiTexCoord4d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
3988 {
3989 GLenum target;
3990 GLdouble s;
3991 GLdouble t;
3992 GLdouble r;
3993 GLdouble q;
3994 if(!enif_get_uint(env, argv[0], &target)) Badarg(5350,"target");
3995 if(!enif_get_double(env, argv[1], &s)) Badarg(5350,"s");
3996 if(!enif_get_double(env, argv[2], &t)) Badarg(5350,"t");
3997 if(!enif_get_double(env, argv[3], &r)) Badarg(5350,"r");
3998 if(!enif_get_double(env, argv[4], &q)) Badarg(5350,"q");
3999 weglMultiTexCoord4d(target,s,t,r,q);
4000 }
4001
ecb_glMultiTexCoord4f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4002 void ecb_glMultiTexCoord4f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4003 {
4004 GLenum target;
4005 GLfloat s;
4006 GLfloat t;
4007 GLfloat r;
4008 GLfloat q;
4009 if(!enif_get_uint(env, argv[0], &target)) Badarg(5351,"target");
4010 if(!egl_get_float(env, argv[1], &s)) Badarg(5351,"s");
4011 if(!egl_get_float(env, argv[2], &t)) Badarg(5351,"t");
4012 if(!egl_get_float(env, argv[3], &r)) Badarg(5351,"r");
4013 if(!egl_get_float(env, argv[4], &q)) Badarg(5351,"q");
4014 weglMultiTexCoord4f(target,s,t,r,q);
4015 }
4016
ecb_glMultiTexCoord4i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4017 void ecb_glMultiTexCoord4i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4018 {
4019 GLenum target;
4020 GLint s;
4021 GLint t;
4022 GLint r;
4023 GLint q;
4024 if(!enif_get_uint(env, argv[0], &target)) Badarg(5352,"target");
4025 if(!enif_get_int(env, argv[1], &s)) Badarg(5352,"s");
4026 if(!enif_get_int(env, argv[2], &t)) Badarg(5352,"t");
4027 if(!enif_get_int(env, argv[3], &r)) Badarg(5352,"r");
4028 if(!enif_get_int(env, argv[4], &q)) Badarg(5352,"q");
4029 weglMultiTexCoord4i(target,s,t,r,q);
4030 }
4031
ecb_glMultiTexCoord4s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4032 void ecb_glMultiTexCoord4s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4033 {
4034 GLenum target;
4035 GLshort s;
4036 GLshort t;
4037 GLshort r;
4038 GLshort q;
4039 if(!enif_get_uint(env, argv[0], &target)) Badarg(5353,"target");
4040 if(!egl_get_short(env, argv[1], &s)) Badarg(5353,"s");
4041 if(!egl_get_short(env, argv[2], &t)) Badarg(5353,"t");
4042 if(!egl_get_short(env, argv[3], &r)) Badarg(5353,"r");
4043 if(!egl_get_short(env, argv[4], &q)) Badarg(5353,"q");
4044 weglMultiTexCoord4s(target,s,t,r,q);
4045 }
4046
ecb_glLoadTransposeMatrixf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4047 void ecb_glLoadTransposeMatrixf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4048 {
4049 GLfloat m[16];
4050 {
4051 int m_a;
4052 const ERL_NIF_TERM *m_t;
4053 if(!enif_get_tuple(env, argv[0], &m_a, &m_t)
4054 || (m_a != 12 && m_a != 16)) {
4055 Badarg(5354,"m");
4056 } else {
4057 int i1 = 0;
4058 if(!egl_get_float(env, m_t[i1++], &m[0])) Badarg(5354,"m");
4059 if(!egl_get_float(env, m_t[i1++], &m[1])) Badarg(5354,"m");
4060 if(!egl_get_float(env, m_t[i1++], &m[2])) Badarg(5354,"m");
4061 if(m_a == 16)
4062 if(!egl_get_float(env, m_t[i1++], &m[3])) Badarg(5354,"m");
4063 if(!egl_get_float(env, m_t[i1++], &m[4])) Badarg(5354,"m");
4064 if(!egl_get_float(env, m_t[i1++], &m[5])) Badarg(5354,"m");
4065 if(!egl_get_float(env, m_t[i1++], &m[6])) Badarg(5354,"m");
4066 if(m_a == 16)
4067 if(!egl_get_float(env, m_t[i1++], &m[7])) Badarg(5354,"m");
4068 if(!egl_get_float(env, m_t[i1++], &m[8])) Badarg(5354,"m");
4069 if(!egl_get_float(env, m_t[i1++], &m[9])) Badarg(5354,"m");
4070 if(!egl_get_float(env, m_t[i1++], &m[10])) Badarg(5354,"m");
4071 if(m_a == 16)
4072 if(!egl_get_float(env, m_t[i1++], &m[11])) Badarg(5354,"m");
4073 if(!egl_get_float(env, m_t[i1++], &m[12])) Badarg(5354,"m");
4074 if(!egl_get_float(env, m_t[i1++], &m[13])) Badarg(5354,"m");
4075 if(!egl_get_float(env, m_t[i1++], &m[14])) Badarg(5354,"m");
4076 if(m_a == 16) {
4077 if(!egl_get_float(env, m_t[i1++], &m[15])) Badarg(5354,"m");
4078 } else {
4079 m[3] = 0.0; m[7] = 0.0; m[11] = 0.0; m[15] = 1.0;
4080 }
4081 }};
4082 weglLoadTransposeMatrixf(m);
4083 }
4084
ecb_glLoadTransposeMatrixd(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4085 void ecb_glLoadTransposeMatrixd(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4086 {
4087 GLdouble m[16];
4088 {
4089 int m_a;
4090 const ERL_NIF_TERM *m_t;
4091 if(!enif_get_tuple(env, argv[0], &m_a, &m_t)
4092 || (m_a != 12 && m_a != 16)) {
4093 Badarg(5355,"m");
4094 } else {
4095 int i1 = 0;
4096 if(!enif_get_double(env, m_t[i1++], &m[0])) Badarg(5355,"m");
4097 if(!enif_get_double(env, m_t[i1++], &m[1])) Badarg(5355,"m");
4098 if(!enif_get_double(env, m_t[i1++], &m[2])) Badarg(5355,"m");
4099 if(m_a == 16)
4100 if(!enif_get_double(env, m_t[i1++], &m[3])) Badarg(5355,"m");
4101 if(!enif_get_double(env, m_t[i1++], &m[4])) Badarg(5355,"m");
4102 if(!enif_get_double(env, m_t[i1++], &m[5])) Badarg(5355,"m");
4103 if(!enif_get_double(env, m_t[i1++], &m[6])) Badarg(5355,"m");
4104 if(m_a == 16)
4105 if(!enif_get_double(env, m_t[i1++], &m[7])) Badarg(5355,"m");
4106 if(!enif_get_double(env, m_t[i1++], &m[8])) Badarg(5355,"m");
4107 if(!enif_get_double(env, m_t[i1++], &m[9])) Badarg(5355,"m");
4108 if(!enif_get_double(env, m_t[i1++], &m[10])) Badarg(5355,"m");
4109 if(m_a == 16)
4110 if(!enif_get_double(env, m_t[i1++], &m[11])) Badarg(5355,"m");
4111 if(!enif_get_double(env, m_t[i1++], &m[12])) Badarg(5355,"m");
4112 if(!enif_get_double(env, m_t[i1++], &m[13])) Badarg(5355,"m");
4113 if(!enif_get_double(env, m_t[i1++], &m[14])) Badarg(5355,"m");
4114 if(m_a == 16) {
4115 if(!enif_get_double(env, m_t[i1++], &m[15])) Badarg(5355,"m");
4116 } else {
4117 m[3] = 0.0; m[7] = 0.0; m[11] = 0.0; m[15] = 1.0;
4118 }
4119 }};
4120 weglLoadTransposeMatrixd(m);
4121 }
4122
ecb_glMultTransposeMatrixf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4123 void ecb_glMultTransposeMatrixf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4124 {
4125 GLfloat m[16];
4126 {
4127 int m_a;
4128 const ERL_NIF_TERM *m_t;
4129 if(!enif_get_tuple(env, argv[0], &m_a, &m_t)
4130 || (m_a != 12 && m_a != 16)) {
4131 Badarg(5356,"m");
4132 } else {
4133 int i1 = 0;
4134 if(!egl_get_float(env, m_t[i1++], &m[0])) Badarg(5356,"m");
4135 if(!egl_get_float(env, m_t[i1++], &m[1])) Badarg(5356,"m");
4136 if(!egl_get_float(env, m_t[i1++], &m[2])) Badarg(5356,"m");
4137 if(m_a == 16)
4138 if(!egl_get_float(env, m_t[i1++], &m[3])) Badarg(5356,"m");
4139 if(!egl_get_float(env, m_t[i1++], &m[4])) Badarg(5356,"m");
4140 if(!egl_get_float(env, m_t[i1++], &m[5])) Badarg(5356,"m");
4141 if(!egl_get_float(env, m_t[i1++], &m[6])) Badarg(5356,"m");
4142 if(m_a == 16)
4143 if(!egl_get_float(env, m_t[i1++], &m[7])) Badarg(5356,"m");
4144 if(!egl_get_float(env, m_t[i1++], &m[8])) Badarg(5356,"m");
4145 if(!egl_get_float(env, m_t[i1++], &m[9])) Badarg(5356,"m");
4146 if(!egl_get_float(env, m_t[i1++], &m[10])) Badarg(5356,"m");
4147 if(m_a == 16)
4148 if(!egl_get_float(env, m_t[i1++], &m[11])) Badarg(5356,"m");
4149 if(!egl_get_float(env, m_t[i1++], &m[12])) Badarg(5356,"m");
4150 if(!egl_get_float(env, m_t[i1++], &m[13])) Badarg(5356,"m");
4151 if(!egl_get_float(env, m_t[i1++], &m[14])) Badarg(5356,"m");
4152 if(m_a == 16) {
4153 if(!egl_get_float(env, m_t[i1++], &m[15])) Badarg(5356,"m");
4154 } else {
4155 m[3] = 0.0; m[7] = 0.0; m[11] = 0.0; m[15] = 1.0;
4156 }
4157 }};
4158 weglMultTransposeMatrixf(m);
4159 }
4160
ecb_glMultTransposeMatrixd(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4161 void ecb_glMultTransposeMatrixd(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4162 {
4163 GLdouble m[16];
4164 {
4165 int m_a;
4166 const ERL_NIF_TERM *m_t;
4167 if(!enif_get_tuple(env, argv[0], &m_a, &m_t)
4168 || (m_a != 12 && m_a != 16)) {
4169 Badarg(5357,"m");
4170 } else {
4171 int i1 = 0;
4172 if(!enif_get_double(env, m_t[i1++], &m[0])) Badarg(5357,"m");
4173 if(!enif_get_double(env, m_t[i1++], &m[1])) Badarg(5357,"m");
4174 if(!enif_get_double(env, m_t[i1++], &m[2])) Badarg(5357,"m");
4175 if(m_a == 16)
4176 if(!enif_get_double(env, m_t[i1++], &m[3])) Badarg(5357,"m");
4177 if(!enif_get_double(env, m_t[i1++], &m[4])) Badarg(5357,"m");
4178 if(!enif_get_double(env, m_t[i1++], &m[5])) Badarg(5357,"m");
4179 if(!enif_get_double(env, m_t[i1++], &m[6])) Badarg(5357,"m");
4180 if(m_a == 16)
4181 if(!enif_get_double(env, m_t[i1++], &m[7])) Badarg(5357,"m");
4182 if(!enif_get_double(env, m_t[i1++], &m[8])) Badarg(5357,"m");
4183 if(!enif_get_double(env, m_t[i1++], &m[9])) Badarg(5357,"m");
4184 if(!enif_get_double(env, m_t[i1++], &m[10])) Badarg(5357,"m");
4185 if(m_a == 16)
4186 if(!enif_get_double(env, m_t[i1++], &m[11])) Badarg(5357,"m");
4187 if(!enif_get_double(env, m_t[i1++], &m[12])) Badarg(5357,"m");
4188 if(!enif_get_double(env, m_t[i1++], &m[13])) Badarg(5357,"m");
4189 if(!enif_get_double(env, m_t[i1++], &m[14])) Badarg(5357,"m");
4190 if(m_a == 16) {
4191 if(!enif_get_double(env, m_t[i1++], &m[15])) Badarg(5357,"m");
4192 } else {
4193 m[3] = 0.0; m[7] = 0.0; m[11] = 0.0; m[15] = 1.0;
4194 }
4195 }};
4196 weglMultTransposeMatrixd(m);
4197 }
4198
ecb_glBlendFuncSeparate(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4199 void ecb_glBlendFuncSeparate(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4200 {
4201 GLenum sfactorRGB;
4202 GLenum dfactorRGB;
4203 GLenum sfactorAlpha;
4204 GLenum dfactorAlpha;
4205 if(!enif_get_uint(env, argv[0], &sfactorRGB)) Badarg(5358,"sfactorRGB");
4206 if(!enif_get_uint(env, argv[1], &dfactorRGB)) Badarg(5358,"dfactorRGB");
4207 if(!enif_get_uint(env, argv[2], &sfactorAlpha)) Badarg(5358,"sfactorAlpha");
4208 if(!enif_get_uint(env, argv[3], &dfactorAlpha)) Badarg(5358,"dfactorAlpha");
4209 weglBlendFuncSeparate(sfactorRGB,dfactorRGB,sfactorAlpha,dfactorAlpha);
4210 }
4211
ecb_glMultiDrawArrays(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4212 void ecb_glMultiDrawArrays(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4213 {
4214 GLenum mode;
4215 ErlNifBinary first_bin;
4216 unsigned int first_len;
4217 GLint *first;
4218 ErlNifBinary count_bin;
4219 unsigned int count_len;
4220 GLsizei *count;
4221 GLsizei drawcount;
4222 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5359,"mode");
4223 if(!enif_is_list(env, argv[1])) {
4224 if(enif_is_binary(env, argv[1])) {
4225 enif_inspect_binary(env, argv[1], &first_bin);
4226 } else if(enif_is_tuple(env, argv[1])) {
4227 int first_a;
4228 const ERL_NIF_TERM *first_t;
4229 if(enif_get_tuple(env, argv[1], &first_a, &first_t) &&
4230 enif_is_binary(env, first_t[1]))
4231 enif_inspect_binary(env, first_t[1], &first_bin);
4232 else Badarg(5359, "first");
4233 } else Badarg(5359, "first");
4234 first = (GLint *) first_bin.data;
4235 first_len = first_bin.size / sizeof(GLint);
4236 } else {
4237 ERL_NIF_TERM first_l, first_h, first_t;
4238 std::vector <GLint> first_vec;
4239 GLint first_tmp;
4240 first_l = argv[1];
4241 while(enif_get_list_cell(env, first_l, &first_h, &first_t)) {
4242 if(!enif_get_int(env, first_h, &first_tmp)) Badarg(5359,"first");
4243 first_vec.push_back(first_tmp);
4244 first_l = first_t;
4245 };
4246 first = first_vec.data();
4247 first_len = first_vec.size();
4248 }
4249 if(!enif_is_list(env, argv[2])) {
4250 if(enif_is_binary(env, argv[2])) {
4251 enif_inspect_binary(env, argv[2], &count_bin);
4252 } else if(enif_is_tuple(env, argv[2])) {
4253 int count_a;
4254 const ERL_NIF_TERM *count_t;
4255 if(enif_get_tuple(env, argv[2], &count_a, &count_t) &&
4256 enif_is_binary(env, count_t[1]))
4257 enif_inspect_binary(env, count_t[1], &count_bin);
4258 else Badarg(5359, "count");
4259 } else Badarg(5359, "count");
4260 count = (GLsizei *) count_bin.data;
4261 count_len = count_bin.size / sizeof(GLsizei);
4262 } else {
4263 ERL_NIF_TERM count_l, count_h, count_t;
4264 std::vector <GLsizei> count_vec;
4265 GLsizei count_tmp;
4266 count_l = argv[2];
4267 while(enif_get_list_cell(env, count_l, &count_h, &count_t)) {
4268 if(!enif_get_int(env, count_h, &count_tmp)) Badarg(5359,"count");
4269 count_vec.push_back(count_tmp);
4270 count_l = count_t;
4271 };
4272 count = count_vec.data();
4273 count_len = count_vec.size();
4274 }
4275 if (count_len != first_len) Badarg(5359, "first");
4276 drawcount = (GLsizei) count_len;
4277 weglMultiDrawArrays(mode,first,count,drawcount);
4278 }
4279
ecb_glPointParameterf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4280 void ecb_glPointParameterf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4281 {
4282 GLenum pname;
4283 GLfloat param;
4284 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5361,"pname");
4285 if(!egl_get_float(env, argv[1], ¶m)) Badarg(5361,"param");
4286 weglPointParameterf(pname,param);
4287 }
4288
ecb_glPointParameterfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4289 void ecb_glPointParameterfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4290 {
4291 GLenum pname;
4292 GLfloat params[4];
4293 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5362,"pname");
4294 {
4295 int params_a;
4296 const ERL_NIF_TERM *params_t;
4297 int i;
4298 if(!enif_get_tuple(env, argv[1], ¶ms_a, ¶ms_t)) {
4299 Badarg(5362,"params");
4300 } else {
4301 for(i = 0; i < params_a; i++)
4302 if(!egl_get_float(env, params_t[i], ¶ms[i])) Badarg(5362,"params");
4303 }};
4304 weglPointParameterfv(pname,params);
4305 }
4306
ecb_glPointParameteri(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4307 void ecb_glPointParameteri(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4308 {
4309 GLenum pname;
4310 GLint param;
4311 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5363,"pname");
4312 if(!enif_get_int(env, argv[1], ¶m)) Badarg(5363,"param");
4313 weglPointParameteri(pname,param);
4314 }
4315
ecb_glPointParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4316 void ecb_glPointParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4317 {
4318 GLenum pname;
4319 GLint params[4];
4320 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5364,"pname");
4321 {
4322 int params_a;
4323 const ERL_NIF_TERM *params_t;
4324 int i;
4325 if(!enif_get_tuple(env, argv[1], ¶ms_a, ¶ms_t)) {
4326 Badarg(5364,"params");
4327 } else {
4328 for(i = 0; i < params_a; i++)
4329 if(!enif_get_int(env, params_t[i], ¶ms[i])) Badarg(5364,"params");
4330 }};
4331 weglPointParameteriv(pname,params);
4332 }
4333
ecb_glFogCoordf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4334 void ecb_glFogCoordf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4335 {
4336 GLfloat coord;
4337 if(!egl_get_float(env, argv[0], &coord)) Badarg(5365,"coord");
4338 weglFogCoordf(coord);
4339 }
4340
ecb_glFogCoordd(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4341 void ecb_glFogCoordd(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4342 {
4343 GLdouble coord;
4344 if(!enif_get_double(env, argv[0], &coord)) Badarg(5366,"coord");
4345 weglFogCoordd(coord);
4346 }
4347
ecb_glFogCoordPointer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4348 void ecb_glFogCoordPointer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4349 {
4350 GLenum type;
4351 GLsizei stride;
4352 ErlNifBinary pointer;
4353 void *pointer_idx;
4354 if(!enif_get_uint(env, argv[0], &type)) Badarg(5367,"type");
4355 if(!enif_get_int(env, argv[1], &stride)) Badarg(5367,"stride");
4356 if(!egl_get_ptr(env, argv[2], (void **) &pointer_idx)) {
4357 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[2], &pointer))
4358 pointer_idx = (void *) pointer.data;
4359 else Badarg(5367,"pointer");
4360 }
4361 weglFogCoordPointer(type,stride,pointer_idx);
4362 }
4363
ecb_glSecondaryColor3b(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4364 void ecb_glSecondaryColor3b(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4365 {
4366 GLbyte red;
4367 GLbyte green;
4368 GLbyte blue;
4369 if(!egl_get_byte(env, argv[0], &red)) Badarg(5369,"red");
4370 if(!egl_get_byte(env, argv[1], &green)) Badarg(5369,"green");
4371 if(!egl_get_byte(env, argv[2], &blue)) Badarg(5369,"blue");
4372 weglSecondaryColor3b(red,green,blue);
4373 }
4374
ecb_glSecondaryColor3d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4375 void ecb_glSecondaryColor3d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4376 {
4377 GLdouble red;
4378 GLdouble green;
4379 GLdouble blue;
4380 if(!enif_get_double(env, argv[0], &red)) Badarg(5370,"red");
4381 if(!enif_get_double(env, argv[1], &green)) Badarg(5370,"green");
4382 if(!enif_get_double(env, argv[2], &blue)) Badarg(5370,"blue");
4383 weglSecondaryColor3d(red,green,blue);
4384 }
4385
ecb_glSecondaryColor3f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4386 void ecb_glSecondaryColor3f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4387 {
4388 GLfloat red;
4389 GLfloat green;
4390 GLfloat blue;
4391 if(!egl_get_float(env, argv[0], &red)) Badarg(5371,"red");
4392 if(!egl_get_float(env, argv[1], &green)) Badarg(5371,"green");
4393 if(!egl_get_float(env, argv[2], &blue)) Badarg(5371,"blue");
4394 weglSecondaryColor3f(red,green,blue);
4395 }
4396
ecb_glSecondaryColor3i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4397 void ecb_glSecondaryColor3i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4398 {
4399 GLint red;
4400 GLint green;
4401 GLint blue;
4402 if(!enif_get_int(env, argv[0], &red)) Badarg(5372,"red");
4403 if(!enif_get_int(env, argv[1], &green)) Badarg(5372,"green");
4404 if(!enif_get_int(env, argv[2], &blue)) Badarg(5372,"blue");
4405 weglSecondaryColor3i(red,green,blue);
4406 }
4407
ecb_glSecondaryColor3s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4408 void ecb_glSecondaryColor3s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4409 {
4410 GLshort red;
4411 GLshort green;
4412 GLshort blue;
4413 if(!egl_get_short(env, argv[0], &red)) Badarg(5373,"red");
4414 if(!egl_get_short(env, argv[1], &green)) Badarg(5373,"green");
4415 if(!egl_get_short(env, argv[2], &blue)) Badarg(5373,"blue");
4416 weglSecondaryColor3s(red,green,blue);
4417 }
4418
ecb_glSecondaryColor3ub(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4419 void ecb_glSecondaryColor3ub(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4420 {
4421 GLubyte red;
4422 GLubyte green;
4423 GLubyte blue;
4424 if(!egl_get_ubyte(env, argv[0], &red)) Badarg(5374,"red");
4425 if(!egl_get_ubyte(env, argv[1], &green)) Badarg(5374,"green");
4426 if(!egl_get_ubyte(env, argv[2], &blue)) Badarg(5374,"blue");
4427 weglSecondaryColor3ub(red,green,blue);
4428 }
4429
ecb_glSecondaryColor3ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4430 void ecb_glSecondaryColor3ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4431 {
4432 GLuint red;
4433 GLuint green;
4434 GLuint blue;
4435 if(!enif_get_uint(env, argv[0], &red)) Badarg(5375,"red");
4436 if(!enif_get_uint(env, argv[1], &green)) Badarg(5375,"green");
4437 if(!enif_get_uint(env, argv[2], &blue)) Badarg(5375,"blue");
4438 weglSecondaryColor3ui(red,green,blue);
4439 }
4440
ecb_glSecondaryColor3us(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4441 void ecb_glSecondaryColor3us(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4442 {
4443 GLushort red;
4444 GLushort green;
4445 GLushort blue;
4446 if(!egl_get_ushort(env, argv[0], &red)) Badarg(5376,"red");
4447 if(!egl_get_ushort(env, argv[1], &green)) Badarg(5376,"green");
4448 if(!egl_get_ushort(env, argv[2], &blue)) Badarg(5376,"blue");
4449 weglSecondaryColor3us(red,green,blue);
4450 }
4451
ecb_glSecondaryColorPointer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4452 void ecb_glSecondaryColorPointer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4453 {
4454 GLint size;
4455 GLenum type;
4456 GLsizei stride;
4457 ErlNifBinary pointer;
4458 void *pointer_idx;
4459 if(!enif_get_int(env, argv[0], &size)) Badarg(5377,"size");
4460 if(!enif_get_uint(env, argv[1], &type)) Badarg(5377,"type");
4461 if(!enif_get_int(env, argv[2], &stride)) Badarg(5377,"stride");
4462 if(!egl_get_ptr(env, argv[3], (void **) &pointer_idx)) {
4463 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[3], &pointer))
4464 pointer_idx = (void *) pointer.data;
4465 else Badarg(5377,"pointer");
4466 }
4467 weglSecondaryColorPointer(size,type,stride,pointer_idx);
4468 }
4469
ecb_glWindowPos2d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4470 void ecb_glWindowPos2d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4471 {
4472 GLdouble x;
4473 GLdouble y;
4474 if(!enif_get_double(env, argv[0], &x)) Badarg(5379,"x");
4475 if(!enif_get_double(env, argv[1], &y)) Badarg(5379,"y");
4476 weglWindowPos2d(x,y);
4477 }
4478
ecb_glWindowPos2f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4479 void ecb_glWindowPos2f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4480 {
4481 GLfloat x;
4482 GLfloat y;
4483 if(!egl_get_float(env, argv[0], &x)) Badarg(5380,"x");
4484 if(!egl_get_float(env, argv[1], &y)) Badarg(5380,"y");
4485 weglWindowPos2f(x,y);
4486 }
4487
ecb_glWindowPos2i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4488 void ecb_glWindowPos2i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4489 {
4490 GLint x;
4491 GLint y;
4492 if(!enif_get_int(env, argv[0], &x)) Badarg(5381,"x");
4493 if(!enif_get_int(env, argv[1], &y)) Badarg(5381,"y");
4494 weglWindowPos2i(x,y);
4495 }
4496
ecb_glWindowPos2s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4497 void ecb_glWindowPos2s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4498 {
4499 GLshort x;
4500 GLshort y;
4501 if(!egl_get_short(env, argv[0], &x)) Badarg(5382,"x");
4502 if(!egl_get_short(env, argv[1], &y)) Badarg(5382,"y");
4503 weglWindowPos2s(x,y);
4504 }
4505
ecb_glWindowPos3d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4506 void ecb_glWindowPos3d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4507 {
4508 GLdouble x;
4509 GLdouble y;
4510 GLdouble z;
4511 if(!enif_get_double(env, argv[0], &x)) Badarg(5383,"x");
4512 if(!enif_get_double(env, argv[1], &y)) Badarg(5383,"y");
4513 if(!enif_get_double(env, argv[2], &z)) Badarg(5383,"z");
4514 weglWindowPos3d(x,y,z);
4515 }
4516
ecb_glWindowPos3f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4517 void ecb_glWindowPos3f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4518 {
4519 GLfloat x;
4520 GLfloat y;
4521 GLfloat z;
4522 if(!egl_get_float(env, argv[0], &x)) Badarg(5384,"x");
4523 if(!egl_get_float(env, argv[1], &y)) Badarg(5384,"y");
4524 if(!egl_get_float(env, argv[2], &z)) Badarg(5384,"z");
4525 weglWindowPos3f(x,y,z);
4526 }
4527
ecb_glWindowPos3i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4528 void ecb_glWindowPos3i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4529 {
4530 GLint x;
4531 GLint y;
4532 GLint z;
4533 if(!enif_get_int(env, argv[0], &x)) Badarg(5385,"x");
4534 if(!enif_get_int(env, argv[1], &y)) Badarg(5385,"y");
4535 if(!enif_get_int(env, argv[2], &z)) Badarg(5385,"z");
4536 weglWindowPos3i(x,y,z);
4537 }
4538
ecb_glWindowPos3s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4539 void ecb_glWindowPos3s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4540 {
4541 GLshort x;
4542 GLshort y;
4543 GLshort z;
4544 if(!egl_get_short(env, argv[0], &x)) Badarg(5386,"x");
4545 if(!egl_get_short(env, argv[1], &y)) Badarg(5386,"y");
4546 if(!egl_get_short(env, argv[2], &z)) Badarg(5386,"z");
4547 weglWindowPos3s(x,y,z);
4548 }
4549
ecb_glBlendColor(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4550 void ecb_glBlendColor(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4551 {
4552 GLclampf red;
4553 GLclampf green;
4554 GLclampf blue;
4555 GLclampf alpha;
4556 if(!egl_get_float(env, argv[0], &red)) Badarg(5387,"red");
4557 if(!egl_get_float(env, argv[1], &green)) Badarg(5387,"green");
4558 if(!egl_get_float(env, argv[2], &blue)) Badarg(5387,"blue");
4559 if(!egl_get_float(env, argv[3], &alpha)) Badarg(5387,"alpha");
4560 weglBlendColor(red,green,blue,alpha);
4561 }
4562
ecb_glBlendEquation(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4563 void ecb_glBlendEquation(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4564 {
4565 GLenum mode;
4566 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5388,"mode");
4567 weglBlendEquation(mode);
4568 }
4569
ecb_glGenQueries(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4570 void ecb_glGenQueries(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4571 {
4572 ERL_NIF_TERM reply;
4573 GLsizei n;
4574 if(!enif_get_int(env, argv[0], &n)) Badarg(5389,"n");
4575 std::vector <GLuint> ids (n);
4576 std::vector <ERL_NIF_TERM> ids_ts (n);
4577 weglGenQueries(n,ids.data());
4578 for(int ri=0; ri < (int) n; ri++)
4579 ids_ts[ri] = enif_make_int(env, ids[ri]);
4580 reply = enif_make_list_from_array(env, ids_ts.data(), n);
4581 enif_send(NULL, self, env,
4582 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
4583 }
4584
ecb_glDeleteQueries(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4585 void ecb_glDeleteQueries(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4586 {
4587 GLsizei n;
4588 GLuint *ids;
4589 if(!enif_get_int(env, argv[0], &n)) Badarg(5390,"n");
4590 if(!enif_is_list(env, argv[1])) Badarg(5390, "ids")
4591 else {
4592 ERL_NIF_TERM ids_l, ids_h, ids_t;
4593 std::vector <GLuint> ids_vec;
4594 GLuint ids_tmp;
4595 ids_l = argv[1];
4596 while(enif_get_list_cell(env, ids_l, &ids_h, &ids_t)) {
4597 if(!enif_get_uint(env, ids_h, &ids_tmp)) Badarg(5390,"ids");
4598 ids_vec.push_back(ids_tmp);
4599 ids_l = ids_t;
4600 };
4601 ids = ids_vec.data();
4602 }
4603 weglDeleteQueries(n,ids);
4604 }
4605
ecb_glIsQuery(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4606 void ecb_glIsQuery(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4607 {
4608 GLboolean result;
4609 ERL_NIF_TERM reply;
4610 GLuint id;
4611 if(!enif_get_uint(env, argv[0], &id)) Badarg(5391,"id");
4612 result = weglIsQuery(id);
4613 reply = enif_make_int(env, result);
4614 enif_send(NULL, self, env,
4615 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
4616 }
4617
ecb_glBeginQuery(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4618 void ecb_glBeginQuery(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4619 {
4620 GLenum target;
4621 GLuint id;
4622 if(!enif_get_uint(env, argv[0], &target)) Badarg(5392,"target");
4623 if(!enif_get_uint(env, argv[1], &id)) Badarg(5392,"id");
4624 weglBeginQuery(target,id);
4625 }
4626
ecb_glEndQuery(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4627 void ecb_glEndQuery(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4628 {
4629 GLenum target;
4630 if(!enif_get_uint(env, argv[0], &target)) Badarg(5393,"target");
4631 weglEndQuery(target);
4632 }
4633
ecb_glGetQueryiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4634 void ecb_glGetQueryiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4635 {
4636 ERL_NIF_TERM reply;
4637 GLenum target;
4638 GLenum pname;
4639 GLint params;
4640 if(!enif_get_uint(env, argv[0], &target)) Badarg(5394,"target");
4641 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5394,"pname");
4642 weglGetQueryiv(target,pname,¶ms);
4643 reply = enif_make_int(env, params);
4644 enif_send(NULL, self, env,
4645 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
4646 }
4647
ecb_glGetQueryObjectiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4648 void ecb_glGetQueryObjectiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4649 {
4650 ERL_NIF_TERM reply;
4651 GLuint id;
4652 GLenum pname;
4653 GLint params;
4654 if(!enif_get_uint(env, argv[0], &id)) Badarg(5395,"id");
4655 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5395,"pname");
4656 weglGetQueryObjectiv(id,pname,¶ms);
4657 reply = enif_make_int(env, params);
4658 enif_send(NULL, self, env,
4659 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
4660 }
4661
ecb_glGetQueryObjectuiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4662 void ecb_glGetQueryObjectuiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4663 {
4664 ERL_NIF_TERM reply;
4665 GLuint id;
4666 GLenum pname;
4667 GLuint params;
4668 if(!enif_get_uint(env, argv[0], &id)) Badarg(5396,"id");
4669 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5396,"pname");
4670 weglGetQueryObjectuiv(id,pname,¶ms);
4671 reply = enif_make_int(env, params);
4672 enif_send(NULL, self, env,
4673 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
4674 }
4675
ecb_glBindBuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4676 void ecb_glBindBuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4677 {
4678 GLenum target;
4679 GLuint buffer;
4680 if(!enif_get_uint(env, argv[0], &target)) Badarg(5397,"target");
4681 if(!enif_get_uint(env, argv[1], &buffer)) Badarg(5397,"buffer");
4682 weglBindBuffer(target,buffer);
4683 }
4684
ecb_glDeleteBuffers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4685 void ecb_glDeleteBuffers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4686 {
4687 GLsizei n;
4688 GLuint *buffers;
4689 if(!enif_get_int(env, argv[0], &n)) Badarg(5398,"n");
4690 if(!enif_is_list(env, argv[1])) Badarg(5398, "buffers")
4691 else {
4692 ERL_NIF_TERM buffers_l, buffers_h, buffers_t;
4693 std::vector <GLuint> buffers_vec;
4694 GLuint buffers_tmp;
4695 buffers_l = argv[1];
4696 while(enif_get_list_cell(env, buffers_l, &buffers_h, &buffers_t)) {
4697 if(!enif_get_uint(env, buffers_h, &buffers_tmp)) Badarg(5398,"buffers");
4698 buffers_vec.push_back(buffers_tmp);
4699 buffers_l = buffers_t;
4700 };
4701 buffers = buffers_vec.data();
4702 }
4703 weglDeleteBuffers(n,buffers);
4704 }
4705
ecb_glGenBuffers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4706 void ecb_glGenBuffers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4707 {
4708 ERL_NIF_TERM reply;
4709 GLsizei n;
4710 if(!enif_get_int(env, argv[0], &n)) Badarg(5399,"n");
4711 std::vector <GLuint> buffers (n);
4712 std::vector <ERL_NIF_TERM> buffers_ts (n);
4713 weglGenBuffers(n,buffers.data());
4714 for(int ri=0; ri < (int) n; ri++)
4715 buffers_ts[ri] = enif_make_int(env, buffers[ri]);
4716 reply = enif_make_list_from_array(env, buffers_ts.data(), n);
4717 enif_send(NULL, self, env,
4718 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
4719 }
4720
ecb_glIsBuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4721 void ecb_glIsBuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4722 {
4723 GLboolean result;
4724 ERL_NIF_TERM reply;
4725 GLuint buffer;
4726 if(!enif_get_uint(env, argv[0], &buffer)) Badarg(5400,"buffer");
4727 result = weglIsBuffer(buffer);
4728 reply = enif_make_int(env, result);
4729 enif_send(NULL, self, env,
4730 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
4731 }
4732
ecb_glBufferData(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4733 void ecb_glBufferData(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4734 {
4735 GLenum target;
4736 GLsizeiptr size;
4737 ErlNifBinary data;
4738 void *data_idx;
4739 GLenum usage;
4740 if(!enif_get_uint(env, argv[0], &target)) Badarg(5401,"target");
4741 if(!egl_get_word(env, argv[1], (egl_word *) &size)) Badarg(5401,"size");
4742 if(!egl_get_ptr(env, argv[2], (void **) &data_idx)) {
4743 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[2], &data))
4744 data_idx = (void *) data.data;
4745 else Badarg(5401,"data");
4746 }
4747 if(!enif_get_uint(env, argv[3], &usage)) Badarg(5401,"usage");
4748 weglBufferData(target,size,data_idx,usage);
4749 }
4750
ecb_glBufferSubData(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4751 void ecb_glBufferSubData(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4752 {
4753 GLenum target;
4754 GLintptr offset;
4755 GLsizeiptr size;
4756 ErlNifBinary data;
4757 void *data_idx;
4758 if(!enif_get_uint(env, argv[0], &target)) Badarg(5403,"target");
4759 if(!egl_get_word(env, argv[1], (egl_word *) &offset)) Badarg(5403,"offset");
4760 if(!egl_get_word(env, argv[2], (egl_word *) &size)) Badarg(5403,"size");
4761 if(!egl_get_ptr(env, argv[3], (void **) &data_idx)) {
4762 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[3], &data))
4763 data_idx = (void *) data.data;
4764 else Badarg(5403,"data");
4765 }
4766 weglBufferSubData(target,offset,size,data_idx);
4767 }
4768
ecb_glGetBufferSubData(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4769 void ecb_glGetBufferSubData(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4770 {
4771 GLenum target;
4772 GLintptr offset;
4773 GLsizeiptr size;
4774 ErlNifBinary data;
4775 if(!enif_get_uint(env, argv[0], &target)) Badarg(5405,"target");
4776 if(!egl_get_word(env, argv[1], (egl_word *) &offset)) Badarg(5405,"offset");
4777 if(!egl_get_word(env, argv[2], (egl_word *) &size)) Badarg(5405,"size");
4778 if(enif_is_binary(env, argv[3]))
4779 enif_inspect_binary(env, argv[3], &data);
4780 else if(enif_is_tuple(env, argv[3])) {
4781 int data_a;
4782 const ERL_NIF_TERM *data_t;
4783 if(enif_get_tuple(env, argv[3], &data_a, &data_t) &&
4784 enif_is_binary(env, data_t[1]))
4785 enif_inspect_binary(env, data_t[1], &data);
4786 else Badarg(5405, "data");
4787 } else Badarg(5405, "data");
4788 weglGetBufferSubData(target,offset,size,(void *) data.data);
4789 enif_send(NULL, self, env,
4790 enif_make_tuple2(env,EGL_ATOM_REPLY,
4791 EGL_ATOM_OK));
4792 }
4793
ecb_glGetBufferParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4794 void ecb_glGetBufferParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4795 {
4796 ERL_NIF_TERM reply;
4797 GLenum target;
4798 GLenum pname;
4799 GLint params;
4800 if(!enif_get_uint(env, argv[0], &target)) Badarg(5406,"target");
4801 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5406,"pname");
4802 weglGetBufferParameteriv(target,pname,¶ms);
4803 reply = enif_make_int(env, params);
4804 enif_send(NULL, self, env,
4805 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
4806 }
4807
ecb_glBlendEquationSeparate(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4808 void ecb_glBlendEquationSeparate(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4809 {
4810 GLenum modeRGB;
4811 GLenum modeAlpha;
4812 if(!enif_get_uint(env, argv[0], &modeRGB)) Badarg(5407,"modeRGB");
4813 if(!enif_get_uint(env, argv[1], &modeAlpha)) Badarg(5407,"modeAlpha");
4814 weglBlendEquationSeparate(modeRGB,modeAlpha);
4815 }
4816
ecb_glDrawBuffers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4817 void ecb_glDrawBuffers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4818 {
4819 GLsizei n;
4820 GLenum *bufs;
4821 if(!enif_get_int(env, argv[0], &n)) Badarg(5408,"n");
4822 if(!enif_is_list(env, argv[1])) Badarg(5408, "bufs")
4823 else {
4824 ERL_NIF_TERM bufs_l, bufs_h, bufs_t;
4825 std::vector <GLenum> bufs_vec;
4826 GLenum bufs_tmp;
4827 bufs_l = argv[1];
4828 while(enif_get_list_cell(env, bufs_l, &bufs_h, &bufs_t)) {
4829 if(!enif_get_uint(env, bufs_h, &bufs_tmp)) Badarg(5408,"bufs");
4830 bufs_vec.push_back(bufs_tmp);
4831 bufs_l = bufs_t;
4832 };
4833 bufs = bufs_vec.data();
4834 }
4835 weglDrawBuffers(n,bufs);
4836 }
4837
ecb_glStencilOpSeparate(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4838 void ecb_glStencilOpSeparate(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4839 {
4840 GLenum face;
4841 GLenum sfail;
4842 GLenum dpfail;
4843 GLenum dppass;
4844 if(!enif_get_uint(env, argv[0], &face)) Badarg(5409,"face");
4845 if(!enif_get_uint(env, argv[1], &sfail)) Badarg(5409,"sfail");
4846 if(!enif_get_uint(env, argv[2], &dpfail)) Badarg(5409,"dpfail");
4847 if(!enif_get_uint(env, argv[3], &dppass)) Badarg(5409,"dppass");
4848 weglStencilOpSeparate(face,sfail,dpfail,dppass);
4849 }
4850
ecb_glStencilFuncSeparate(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4851 void ecb_glStencilFuncSeparate(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4852 {
4853 GLenum face;
4854 GLenum func;
4855 GLint ref;
4856 GLuint mask;
4857 if(!enif_get_uint(env, argv[0], &face)) Badarg(5410,"face");
4858 if(!enif_get_uint(env, argv[1], &func)) Badarg(5410,"func");
4859 if(!enif_get_int(env, argv[2], &ref)) Badarg(5410,"ref");
4860 if(!enif_get_uint(env, argv[3], &mask)) Badarg(5410,"mask");
4861 weglStencilFuncSeparate(face,func,ref,mask);
4862 }
4863
ecb_glStencilMaskSeparate(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4864 void ecb_glStencilMaskSeparate(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4865 {
4866 GLenum face;
4867 GLuint mask;
4868 if(!enif_get_uint(env, argv[0], &face)) Badarg(5411,"face");
4869 if(!enif_get_uint(env, argv[1], &mask)) Badarg(5411,"mask");
4870 weglStencilMaskSeparate(face,mask);
4871 }
4872
ecb_glAttachShader(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4873 void ecb_glAttachShader(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4874 {
4875 GLuint program;
4876 GLuint shader;
4877 if(!enif_get_uint(env, argv[0], &program)) Badarg(5412,"program");
4878 if(!enif_get_uint(env, argv[1], &shader)) Badarg(5412,"shader");
4879 weglAttachShader(program,shader);
4880 }
4881
ecb_glBindAttribLocation(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4882 void ecb_glBindAttribLocation(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4883 {
4884 GLuint program;
4885 GLuint index;
4886 ErlNifBinary name;
4887 if(!enif_get_uint(env, argv[0], &program)) Badarg(5413,"program");
4888 if(!enif_get_uint(env, argv[1], &index)) Badarg(5413,"index");
4889 if(!enif_inspect_binary(env, argv[2], &name)) Badarg(5413,"name");
4890 weglBindAttribLocation(program,index,(GLchar *) name.data);
4891 }
4892
ecb_glCompileShader(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4893 void ecb_glCompileShader(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4894 {
4895 GLuint shader;
4896 if(!enif_get_uint(env, argv[0], &shader)) Badarg(5414,"shader");
4897 weglCompileShader(shader);
4898 }
4899
ecb_glCreateProgram(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4900 void ecb_glCreateProgram(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4901 {
4902 GLuint result;
4903 ERL_NIF_TERM reply;
4904 result = weglCreateProgram();
4905 reply = enif_make_int(env, result);
4906 enif_send(NULL, self, env,
4907 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
4908 }
4909
ecb_glCreateShader(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4910 void ecb_glCreateShader(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4911 {
4912 GLuint result;
4913 ERL_NIF_TERM reply;
4914 GLenum type;
4915 if(!enif_get_uint(env, argv[0], &type)) Badarg(5416,"type");
4916 result = weglCreateShader(type);
4917 reply = enif_make_int(env, result);
4918 enif_send(NULL, self, env,
4919 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
4920 }
4921
ecb_glDeleteProgram(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4922 void ecb_glDeleteProgram(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4923 {
4924 GLuint program;
4925 if(!enif_get_uint(env, argv[0], &program)) Badarg(5417,"program");
4926 weglDeleteProgram(program);
4927 }
4928
ecb_glDeleteShader(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4929 void ecb_glDeleteShader(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4930 {
4931 GLuint shader;
4932 if(!enif_get_uint(env, argv[0], &shader)) Badarg(5418,"shader");
4933 weglDeleteShader(shader);
4934 }
4935
ecb_glDetachShader(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4936 void ecb_glDetachShader(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4937 {
4938 GLuint program;
4939 GLuint shader;
4940 if(!enif_get_uint(env, argv[0], &program)) Badarg(5419,"program");
4941 if(!enif_get_uint(env, argv[1], &shader)) Badarg(5419,"shader");
4942 weglDetachShader(program,shader);
4943 }
4944
ecb_glDisableVertexAttribArray(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4945 void ecb_glDisableVertexAttribArray(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4946 {
4947 GLuint index;
4948 if(!enif_get_uint(env, argv[0], &index)) Badarg(5420,"index");
4949 weglDisableVertexAttribArray(index);
4950 }
4951
ecb_glEnableVertexAttribArray(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4952 void ecb_glEnableVertexAttribArray(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4953 {
4954 GLuint index;
4955 if(!enif_get_uint(env, argv[0], &index)) Badarg(5421,"index");
4956 weglEnableVertexAttribArray(index);
4957 }
4958
ecb_glGetActiveAttrib(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4959 void ecb_glGetActiveAttrib(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4960 {
4961 ERL_NIF_TERM reply;
4962 GLuint program;
4963 GLuint index;
4964 GLsizei bufSize;
4965 GLsizei length;
4966 GLint size;
4967 GLenum type;
4968 unsigned char *name;
4969 if(!enif_get_uint(env, argv[0], &program)) Badarg(5422,"program");
4970 if(!enif_get_uint(env, argv[1], &index)) Badarg(5422,"index");
4971 if(!enif_get_int(env, argv[2], &bufSize)) Badarg(5422,"bufSize");
4972 name = (unsigned char *) enif_alloc((int) bufSize*sizeof(GLchar));
4973 weglGetActiveAttrib(program,index,bufSize,&length,&size,&type,(GLchar *) name);
4974 reply = enif_make_tuple3(env,
4975 enif_make_int(env, size),
4976 enif_make_int(env, type),
4977 enif_make_string(env, (const char *) name, ERL_NIF_LATIN1) );
4978 enif_send(NULL, self, env,
4979 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
4980 enif_free(name);
4981 }
4982
ecb_glGetActiveUniform(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])4983 void ecb_glGetActiveUniform(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
4984 {
4985 ERL_NIF_TERM reply;
4986 GLuint program;
4987 GLuint index;
4988 GLsizei bufSize;
4989 GLsizei length;
4990 GLint size;
4991 GLenum type;
4992 unsigned char *name;
4993 if(!enif_get_uint(env, argv[0], &program)) Badarg(5423,"program");
4994 if(!enif_get_uint(env, argv[1], &index)) Badarg(5423,"index");
4995 if(!enif_get_int(env, argv[2], &bufSize)) Badarg(5423,"bufSize");
4996 name = (unsigned char *) enif_alloc((int) bufSize*sizeof(GLchar));
4997 weglGetActiveUniform(program,index,bufSize,&length,&size,&type,(GLchar *) name);
4998 reply = enif_make_tuple3(env,
4999 enif_make_int(env, size),
5000 enif_make_int(env, type),
5001 enif_make_string(env, (const char *) name, ERL_NIF_LATIN1) );
5002 enif_send(NULL, self, env,
5003 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5004 enif_free(name);
5005 }
5006
ecb_glGetAttachedShaders(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5007 void ecb_glGetAttachedShaders(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5008 {
5009 ERL_NIF_TERM reply;
5010 GLuint program;
5011 GLsizei maxCount;
5012 GLsizei count;
5013 if(!enif_get_uint(env, argv[0], &program)) Badarg(5424,"program");
5014 if(!enif_get_int(env, argv[1], &maxCount)) Badarg(5424,"maxCount");
5015 std::vector <GLuint> shaders (maxCount);
5016 std::vector <ERL_NIF_TERM> shaders_ts (maxCount);
5017 weglGetAttachedShaders(program,maxCount,&count,shaders.data());
5018 for(int ri=0; ri < (int) count; ri++)
5019 shaders_ts[ri] = enif_make_int(env, shaders[ri]);
5020 reply = enif_make_list_from_array(env, shaders_ts.data(), count);
5021 enif_send(NULL, self, env,
5022 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5023 }
5024
ecb_glGetAttribLocation(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5025 void ecb_glGetAttribLocation(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5026 {
5027 GLint result;
5028 ERL_NIF_TERM reply;
5029 GLuint program;
5030 ErlNifBinary name;
5031 if(!enif_get_uint(env, argv[0], &program)) Badarg(5425,"program");
5032 if(!enif_inspect_binary(env, argv[1], &name)) Badarg(5425,"name");
5033 result = weglGetAttribLocation(program,(GLchar *) name.data);
5034 reply = enif_make_int(env, result);
5035 enif_send(NULL, self, env,
5036 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5037 }
5038
ecb_glGetProgramiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5039 void ecb_glGetProgramiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5040 {
5041 ERL_NIF_TERM reply;
5042 GLuint program;
5043 GLenum pname;
5044 GLint params;
5045 if(!enif_get_uint(env, argv[0], &program)) Badarg(5426,"program");
5046 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5426,"pname");
5047 weglGetProgramiv(program,pname,¶ms);
5048 reply = enif_make_int(env, params);
5049 enif_send(NULL, self, env,
5050 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5051 }
5052
ecb_glGetProgramInfoLog(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5053 void ecb_glGetProgramInfoLog(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5054 {
5055 ERL_NIF_TERM reply;
5056 GLuint program;
5057 GLsizei bufSize;
5058 GLsizei length;
5059 unsigned char *infoLog;
5060 if(!enif_get_uint(env, argv[0], &program)) Badarg(5427,"program");
5061 if(!enif_get_int(env, argv[1], &bufSize)) Badarg(5427,"bufSize");
5062 infoLog = (unsigned char *) enif_alloc((int) bufSize*sizeof(GLchar));
5063 weglGetProgramInfoLog(program,bufSize,&length,(GLchar *) infoLog);
5064 reply = enif_make_string(env, (const char *) infoLog, ERL_NIF_LATIN1);
5065 enif_send(NULL, self, env,
5066 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5067 enif_free(infoLog);
5068 }
5069
ecb_glGetShaderiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5070 void ecb_glGetShaderiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5071 {
5072 ERL_NIF_TERM reply;
5073 GLuint shader;
5074 GLenum pname;
5075 GLint params;
5076 if(!enif_get_uint(env, argv[0], &shader)) Badarg(5428,"shader");
5077 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5428,"pname");
5078 weglGetShaderiv(shader,pname,¶ms);
5079 reply = enif_make_int(env, params);
5080 enif_send(NULL, self, env,
5081 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5082 }
5083
ecb_glGetShaderInfoLog(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5084 void ecb_glGetShaderInfoLog(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5085 {
5086 ERL_NIF_TERM reply;
5087 GLuint shader;
5088 GLsizei bufSize;
5089 GLsizei length;
5090 unsigned char *infoLog;
5091 if(!enif_get_uint(env, argv[0], &shader)) Badarg(5429,"shader");
5092 if(!enif_get_int(env, argv[1], &bufSize)) Badarg(5429,"bufSize");
5093 infoLog = (unsigned char *) enif_alloc((int) bufSize*sizeof(GLchar));
5094 weglGetShaderInfoLog(shader,bufSize,&length,(GLchar *) infoLog);
5095 reply = enif_make_string(env, (const char *) infoLog, ERL_NIF_LATIN1);
5096 enif_send(NULL, self, env,
5097 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5098 enif_free(infoLog);
5099 }
5100
ecb_glGetShaderSource(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5101 void ecb_glGetShaderSource(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5102 {
5103 ERL_NIF_TERM reply;
5104 GLuint shader;
5105 GLsizei bufSize;
5106 GLsizei length;
5107 unsigned char *source;
5108 if(!enif_get_uint(env, argv[0], &shader)) Badarg(5430,"shader");
5109 if(!enif_get_int(env, argv[1], &bufSize)) Badarg(5430,"bufSize");
5110 source = (unsigned char *) enif_alloc((int) bufSize*sizeof(GLchar));
5111 weglGetShaderSource(shader,bufSize,&length,(GLchar *) source);
5112 reply = enif_make_string(env, (const char *) source, ERL_NIF_LATIN1);
5113 enif_send(NULL, self, env,
5114 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5115 enif_free(source);
5116 }
5117
ecb_glGetUniformLocation(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5118 void ecb_glGetUniformLocation(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5119 {
5120 GLint result;
5121 ERL_NIF_TERM reply;
5122 GLuint program;
5123 ErlNifBinary name;
5124 if(!enif_get_uint(env, argv[0], &program)) Badarg(5431,"program");
5125 if(!enif_inspect_binary(env, argv[1], &name)) Badarg(5431,"name");
5126 result = weglGetUniformLocation(program,(GLchar *) name.data);
5127 reply = enif_make_int(env, result);
5128 enif_send(NULL, self, env,
5129 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5130 }
5131
ecb_glGetUniformfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5132 void ecb_glGetUniformfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5133 {
5134 ERL_NIF_TERM reply;
5135 GLuint program;
5136 GLint location;
5137 GLfloat params[16];
5138 ERL_NIF_TERM params_ts[16];
5139 if(!enif_get_uint(env, argv[0], &program)) Badarg(5432,"program");
5140 if(!enif_get_int(env, argv[1], &location)) Badarg(5432,"location");
5141 weglGetUniformfv(program,location,params);
5142 for(int ri=0; ri < (int) 16; ri++)
5143 params_ts[ri] = enif_make_double(env, (double) params[ri]);
5144 reply = enif_make_tuple_from_array(env, params_ts, 16);
5145 enif_send(NULL, self, env,
5146 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5147 }
5148
ecb_glGetUniformiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5149 void ecb_glGetUniformiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5150 {
5151 ERL_NIF_TERM reply;
5152 GLuint program;
5153 GLint location;
5154 GLint params[16];
5155 ERL_NIF_TERM params_ts[16];
5156 if(!enif_get_uint(env, argv[0], &program)) Badarg(5433,"program");
5157 if(!enif_get_int(env, argv[1], &location)) Badarg(5433,"location");
5158 weglGetUniformiv(program,location,params);
5159 for(int ri=0; ri < (int) 16; ri++)
5160 params_ts[ri] = enif_make_int(env, params[ri]);
5161 reply = enif_make_tuple_from_array(env, params_ts, 16);
5162 enif_send(NULL, self, env,
5163 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5164 }
5165
ecb_glGetVertexAttribdv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5166 void ecb_glGetVertexAttribdv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5167 {
5168 ERL_NIF_TERM reply;
5169 GLuint index;
5170 GLenum pname;
5171 GLdouble params[4];
5172 if(!enif_get_uint(env, argv[0], &index)) Badarg(5434,"index");
5173 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5434,"pname");
5174 weglGetVertexAttribdv(index,pname,params);
5175 reply = enif_make_tuple4(env,
5176 enif_make_double(env, params[0]),
5177 enif_make_double(env, params[1]),
5178 enif_make_double(env, params[2]),
5179 enif_make_double(env, params[3]));
5180 enif_send(NULL, self, env,
5181 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5182 }
5183
ecb_glGetVertexAttribfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5184 void ecb_glGetVertexAttribfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5185 {
5186 ERL_NIF_TERM reply;
5187 GLuint index;
5188 GLenum pname;
5189 GLfloat params[4];
5190 if(!enif_get_uint(env, argv[0], &index)) Badarg(5435,"index");
5191 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5435,"pname");
5192 weglGetVertexAttribfv(index,pname,params);
5193 reply = enif_make_tuple4(env,
5194 enif_make_double(env, (double) params[0]),
5195 enif_make_double(env, (double) params[1]),
5196 enif_make_double(env, (double) params[2]),
5197 enif_make_double(env, (double) params[3]));
5198 enif_send(NULL, self, env,
5199 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5200 }
5201
ecb_glGetVertexAttribiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5202 void ecb_glGetVertexAttribiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5203 {
5204 ERL_NIF_TERM reply;
5205 GLuint index;
5206 GLenum pname;
5207 GLint params[4];
5208 if(!enif_get_uint(env, argv[0], &index)) Badarg(5436,"index");
5209 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5436,"pname");
5210 weglGetVertexAttribiv(index,pname,params);
5211 reply = enif_make_tuple4(env,
5212 enif_make_int(env, params[0]),
5213 enif_make_int(env, params[1]),
5214 enif_make_int(env, params[2]),
5215 enif_make_int(env, params[3]));
5216 enif_send(NULL, self, env,
5217 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5218 }
5219
ecb_glIsProgram(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5220 void ecb_glIsProgram(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5221 {
5222 GLboolean result;
5223 ERL_NIF_TERM reply;
5224 GLuint program;
5225 if(!enif_get_uint(env, argv[0], &program)) Badarg(5437,"program");
5226 result = weglIsProgram(program);
5227 reply = enif_make_int(env, result);
5228 enif_send(NULL, self, env,
5229 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5230 }
5231
ecb_glIsShader(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5232 void ecb_glIsShader(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5233 {
5234 GLboolean result;
5235 ERL_NIF_TERM reply;
5236 GLuint shader;
5237 if(!enif_get_uint(env, argv[0], &shader)) Badarg(5438,"shader");
5238 result = weglIsShader(shader);
5239 reply = enif_make_int(env, result);
5240 enif_send(NULL, self, env,
5241 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
5242 }
5243
ecb_glLinkProgram(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5244 void ecb_glLinkProgram(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5245 {
5246 GLuint program;
5247 if(!enif_get_uint(env, argv[0], &program)) Badarg(5439,"program");
5248 weglLinkProgram(program);
5249 }
5250
ecb_glShaderSource(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5251 void ecb_glShaderSource(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5252 {
5253 GLuint shader;
5254 GLsizei count;
5255 if(!enif_get_uint(env, argv[0], &shader)) Badarg(5440,"shader");
5256 if(!enif_get_int(env, argv[1], &count)) Badarg(5440,"count");
5257 ERL_NIF_TERM string_l, string_h, string_t;
5258 ErlNifBinary string_tmp;
5259 std::vector <GLchar *> string;
5260 string_l = argv[2];
5261 while(enif_get_list_cell(env, string_l, &string_h, &string_t)) {
5262 if(!enif_inspect_binary(env, string_h, &string_tmp)) Badarg(5440,"string");
5263 string.push_back((GLchar *) string_tmp.data);
5264 string_l = string_t;
5265 }
5266 weglShaderSource(shader,count,(const GLchar **) string.data(),NULL);
5267 }
5268
ecb_glUseProgram(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5269 void ecb_glUseProgram(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5270 {
5271 GLuint program;
5272 if(!enif_get_uint(env, argv[0], &program)) Badarg(5441,"program");
5273 weglUseProgram(program);
5274 }
5275
ecb_glUniform1f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5276 void ecb_glUniform1f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5277 {
5278 GLint location;
5279 GLfloat v0;
5280 if(!enif_get_int(env, argv[0], &location)) Badarg(5442,"location");
5281 if(!egl_get_float(env, argv[1], &v0)) Badarg(5442,"v0");
5282 weglUniform1f(location,v0);
5283 }
5284
ecb_glUniform2f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5285 void ecb_glUniform2f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5286 {
5287 GLint location;
5288 GLfloat v0;
5289 GLfloat v1;
5290 if(!enif_get_int(env, argv[0], &location)) Badarg(5443,"location");
5291 if(!egl_get_float(env, argv[1], &v0)) Badarg(5443,"v0");
5292 if(!egl_get_float(env, argv[2], &v1)) Badarg(5443,"v1");
5293 weglUniform2f(location,v0,v1);
5294 }
5295
ecb_glUniform3f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5296 void ecb_glUniform3f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5297 {
5298 GLint location;
5299 GLfloat v0;
5300 GLfloat v1;
5301 GLfloat v2;
5302 if(!enif_get_int(env, argv[0], &location)) Badarg(5444,"location");
5303 if(!egl_get_float(env, argv[1], &v0)) Badarg(5444,"v0");
5304 if(!egl_get_float(env, argv[2], &v1)) Badarg(5444,"v1");
5305 if(!egl_get_float(env, argv[3], &v2)) Badarg(5444,"v2");
5306 weglUniform3f(location,v0,v1,v2);
5307 }
5308
ecb_glUniform4f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5309 void ecb_glUniform4f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5310 {
5311 GLint location;
5312 GLfloat v0;
5313 GLfloat v1;
5314 GLfloat v2;
5315 GLfloat v3;
5316 if(!enif_get_int(env, argv[0], &location)) Badarg(5445,"location");
5317 if(!egl_get_float(env, argv[1], &v0)) Badarg(5445,"v0");
5318 if(!egl_get_float(env, argv[2], &v1)) Badarg(5445,"v1");
5319 if(!egl_get_float(env, argv[3], &v2)) Badarg(5445,"v2");
5320 if(!egl_get_float(env, argv[4], &v3)) Badarg(5445,"v3");
5321 weglUniform4f(location,v0,v1,v2,v3);
5322 }
5323
ecb_glUniform1i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5324 void ecb_glUniform1i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5325 {
5326 GLint location;
5327 GLint v0;
5328 if(!enif_get_int(env, argv[0], &location)) Badarg(5446,"location");
5329 if(!enif_get_int(env, argv[1], &v0)) Badarg(5446,"v0");
5330 weglUniform1i(location,v0);
5331 }
5332
ecb_glUniform2i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5333 void ecb_glUniform2i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5334 {
5335 GLint location;
5336 GLint v0;
5337 GLint v1;
5338 if(!enif_get_int(env, argv[0], &location)) Badarg(5447,"location");
5339 if(!enif_get_int(env, argv[1], &v0)) Badarg(5447,"v0");
5340 if(!enif_get_int(env, argv[2], &v1)) Badarg(5447,"v1");
5341 weglUniform2i(location,v0,v1);
5342 }
5343
ecb_glUniform3i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5344 void ecb_glUniform3i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5345 {
5346 GLint location;
5347 GLint v0;
5348 GLint v1;
5349 GLint v2;
5350 if(!enif_get_int(env, argv[0], &location)) Badarg(5448,"location");
5351 if(!enif_get_int(env, argv[1], &v0)) Badarg(5448,"v0");
5352 if(!enif_get_int(env, argv[2], &v1)) Badarg(5448,"v1");
5353 if(!enif_get_int(env, argv[3], &v2)) Badarg(5448,"v2");
5354 weglUniform3i(location,v0,v1,v2);
5355 }
5356
ecb_glUniform4i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5357 void ecb_glUniform4i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5358 {
5359 GLint location;
5360 GLint v0;
5361 GLint v1;
5362 GLint v2;
5363 GLint v3;
5364 if(!enif_get_int(env, argv[0], &location)) Badarg(5449,"location");
5365 if(!enif_get_int(env, argv[1], &v0)) Badarg(5449,"v0");
5366 if(!enif_get_int(env, argv[2], &v1)) Badarg(5449,"v1");
5367 if(!enif_get_int(env, argv[3], &v2)) Badarg(5449,"v2");
5368 if(!enif_get_int(env, argv[4], &v3)) Badarg(5449,"v3");
5369 weglUniform4i(location,v0,v1,v2,v3);
5370 }
5371
ecb_glUniform1fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5372 void ecb_glUniform1fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5373 {
5374 GLint location;
5375 GLsizei count;
5376 GLfloat *value;
5377 if(!enif_get_int(env, argv[0], &location)) Badarg(5450,"location");
5378 if(!enif_get_int(env, argv[1], &count)) Badarg(5450,"count");
5379 if(!enif_is_list(env, argv[2])) Badarg(5450, "value")
5380 else {
5381 ERL_NIF_TERM value_l, value_h, value_t;
5382 std::vector <GLfloat> value_vec;
5383 GLfloat value_tmp;
5384 value_l = argv[2];
5385 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
5386 if(!egl_get_float(env, value_h, &value_tmp)) Badarg(5450,"value");
5387 value_vec.push_back(value_tmp);
5388 value_l = value_t;
5389 };
5390 value = value_vec.data();
5391 }
5392 weglUniform1fv(location,count,value);
5393 }
5394
ecb_glUniform2fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5395 void ecb_glUniform2fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5396 {
5397 GLint location;
5398 GLsizei count;
5399 GLfloat *value;
5400 if(!enif_get_int(env, argv[0], &location)) Badarg(5451,"location");
5401 if(!enif_get_int(env, argv[1], &count)) Badarg(5451,"count");
5402 if(!enif_is_list(env, argv[2])) { Badarg(5451,"value")}
5403 int value_a;
5404 const ERL_NIF_TERM *value_tpl;
5405 ERL_NIF_TERM value_l, value_h, value_t;
5406 std::vector <GLfloat> value_vec (2*count);
5407 GLfloat *value_ptr = value_vec.data();
5408 value_l = argv[2];
5409 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
5410 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 2) Badarg(5451,"value");
5411 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5451,"value");
5412 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5451,"value");
5413 value_l = value_t;
5414 };
5415 value = value_vec.data();
5416 weglUniform2fv(location,count,value);
5417 }
5418
ecb_glUniform3fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5419 void ecb_glUniform3fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5420 {
5421 GLint location;
5422 GLsizei count;
5423 GLfloat *value;
5424 if(!enif_get_int(env, argv[0], &location)) Badarg(5452,"location");
5425 if(!enif_get_int(env, argv[1], &count)) Badarg(5452,"count");
5426 if(!enif_is_list(env, argv[2])) { Badarg(5452,"value")}
5427 int value_a;
5428 const ERL_NIF_TERM *value_tpl;
5429 ERL_NIF_TERM value_l, value_h, value_t;
5430 std::vector <GLfloat> value_vec (3*count);
5431 GLfloat *value_ptr = value_vec.data();
5432 value_l = argv[2];
5433 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
5434 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 3) Badarg(5452,"value");
5435 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5452,"value");
5436 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5452,"value");
5437 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5452,"value");
5438 value_l = value_t;
5439 };
5440 value = value_vec.data();
5441 weglUniform3fv(location,count,value);
5442 }
5443
ecb_glUniform4fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5444 void ecb_glUniform4fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5445 {
5446 GLint location;
5447 GLsizei count;
5448 GLfloat *value;
5449 if(!enif_get_int(env, argv[0], &location)) Badarg(5453,"location");
5450 if(!enif_get_int(env, argv[1], &count)) Badarg(5453,"count");
5451 if(!enif_is_list(env, argv[2])) { Badarg(5453,"value")}
5452 int value_a;
5453 const ERL_NIF_TERM *value_tpl;
5454 ERL_NIF_TERM value_l, value_h, value_t;
5455 std::vector <GLfloat> value_vec (4*count);
5456 GLfloat *value_ptr = value_vec.data();
5457 value_l = argv[2];
5458 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
5459 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5453,"value");
5460 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5453,"value");
5461 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5453,"value");
5462 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5453,"value");
5463 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5453,"value");
5464 value_l = value_t;
5465 };
5466 value = value_vec.data();
5467 weglUniform4fv(location,count,value);
5468 }
5469
ecb_glUniform1iv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5470 void ecb_glUniform1iv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5471 {
5472 GLint location;
5473 GLsizei count;
5474 GLint *value;
5475 if(!enif_get_int(env, argv[0], &location)) Badarg(5454,"location");
5476 if(!enif_get_int(env, argv[1], &count)) Badarg(5454,"count");
5477 if(!enif_is_list(env, argv[2])) Badarg(5454, "value")
5478 else {
5479 ERL_NIF_TERM value_l, value_h, value_t;
5480 std::vector <GLint> value_vec;
5481 GLint value_tmp;
5482 value_l = argv[2];
5483 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
5484 if(!enif_get_int(env, value_h, &value_tmp)) Badarg(5454,"value");
5485 value_vec.push_back(value_tmp);
5486 value_l = value_t;
5487 };
5488 value = value_vec.data();
5489 }
5490 weglUniform1iv(location,count,value);
5491 }
5492
ecb_glUniform2iv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5493 void ecb_glUniform2iv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5494 {
5495 GLint location;
5496 GLsizei count;
5497 GLint *value;
5498 if(!enif_get_int(env, argv[0], &location)) Badarg(5455,"location");
5499 if(!enif_get_int(env, argv[1], &count)) Badarg(5455,"count");
5500 if(!enif_is_list(env, argv[2])) { Badarg(5455,"value")}
5501 int value_a;
5502 const ERL_NIF_TERM *value_tpl;
5503 ERL_NIF_TERM value_l, value_h, value_t;
5504 std::vector <GLint> value_vec (2*count);
5505 GLint *value_ptr = value_vec.data();
5506 value_l = argv[2];
5507 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
5508 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 2) Badarg(5455,"value");
5509 if(!enif_get_int(env, value_tpl[0], value_ptr++)) Badarg(5455,"value");
5510 if(!enif_get_int(env, value_tpl[1], value_ptr++)) Badarg(5455,"value");
5511 value_l = value_t;
5512 };
5513 value = value_vec.data();
5514 weglUniform2iv(location,count,value);
5515 }
5516
ecb_glUniform3iv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5517 void ecb_glUniform3iv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5518 {
5519 GLint location;
5520 GLsizei count;
5521 GLint *value;
5522 if(!enif_get_int(env, argv[0], &location)) Badarg(5456,"location");
5523 if(!enif_get_int(env, argv[1], &count)) Badarg(5456,"count");
5524 if(!enif_is_list(env, argv[2])) { Badarg(5456,"value")}
5525 int value_a;
5526 const ERL_NIF_TERM *value_tpl;
5527 ERL_NIF_TERM value_l, value_h, value_t;
5528 std::vector <GLint> value_vec (3*count);
5529 GLint *value_ptr = value_vec.data();
5530 value_l = argv[2];
5531 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
5532 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 3) Badarg(5456,"value");
5533 if(!enif_get_int(env, value_tpl[0], value_ptr++)) Badarg(5456,"value");
5534 if(!enif_get_int(env, value_tpl[1], value_ptr++)) Badarg(5456,"value");
5535 if(!enif_get_int(env, value_tpl[2], value_ptr++)) Badarg(5456,"value");
5536 value_l = value_t;
5537 };
5538 value = value_vec.data();
5539 weglUniform3iv(location,count,value);
5540 }
5541
ecb_glUniform4iv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5542 void ecb_glUniform4iv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5543 {
5544 GLint location;
5545 GLsizei count;
5546 GLint *value;
5547 if(!enif_get_int(env, argv[0], &location)) Badarg(5457,"location");
5548 if(!enif_get_int(env, argv[1], &count)) Badarg(5457,"count");
5549 if(!enif_is_list(env, argv[2])) { Badarg(5457,"value")}
5550 int value_a;
5551 const ERL_NIF_TERM *value_tpl;
5552 ERL_NIF_TERM value_l, value_h, value_t;
5553 std::vector <GLint> value_vec (4*count);
5554 GLint *value_ptr = value_vec.data();
5555 value_l = argv[2];
5556 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
5557 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5457,"value");
5558 if(!enif_get_int(env, value_tpl[0], value_ptr++)) Badarg(5457,"value");
5559 if(!enif_get_int(env, value_tpl[1], value_ptr++)) Badarg(5457,"value");
5560 if(!enif_get_int(env, value_tpl[2], value_ptr++)) Badarg(5457,"value");
5561 if(!enif_get_int(env, value_tpl[3], value_ptr++)) Badarg(5457,"value");
5562 value_l = value_t;
5563 };
5564 value = value_vec.data();
5565 weglUniform4iv(location,count,value);
5566 }
5567
ecb_glUniformMatrix2fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5568 void ecb_glUniformMatrix2fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5569 {
5570 GLint location;
5571 GLsizei count;
5572 GLboolean transpose;
5573 GLfloat *value;
5574 if(!enif_get_int(env, argv[0], &location)) Badarg(5458,"location");
5575 if(!enif_get_int(env, argv[1], &count)) Badarg(5458,"count");
5576 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5458,"transpose");
5577 if(!enif_is_list(env, argv[3])) { Badarg(5458,"value")}
5578 int value_a;
5579 const ERL_NIF_TERM *value_tpl;
5580 ERL_NIF_TERM value_l, value_h, value_t;
5581 std::vector <GLfloat> value_vec (4*count);
5582 GLfloat *value_ptr = value_vec.data();
5583 value_l = argv[3];
5584 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
5585 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5458,"value");
5586 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5458,"value");
5587 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5458,"value");
5588 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5458,"value");
5589 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5458,"value");
5590 value_l = value_t;
5591 };
5592 value = value_vec.data();
5593 weglUniformMatrix2fv(location,count,transpose,value);
5594 }
5595
ecb_glUniformMatrix3fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5596 void ecb_glUniformMatrix3fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5597 {
5598 GLint location;
5599 GLsizei count;
5600 GLboolean transpose;
5601 GLfloat *value;
5602 if(!enif_get_int(env, argv[0], &location)) Badarg(5459,"location");
5603 if(!enif_get_int(env, argv[1], &count)) Badarg(5459,"count");
5604 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5459,"transpose");
5605 if(!enif_is_list(env, argv[3])) { Badarg(5459,"value")}
5606 int value_a;
5607 const ERL_NIF_TERM *value_tpl;
5608 ERL_NIF_TERM value_l, value_h, value_t;
5609 std::vector <GLfloat> value_vec (9*count);
5610 GLfloat *value_ptr = value_vec.data();
5611 value_l = argv[3];
5612 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
5613 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 9) Badarg(5459,"value");
5614 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5459,"value");
5615 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5459,"value");
5616 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5459,"value");
5617 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5459,"value");
5618 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5459,"value");
5619 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5459,"value");
5620 if(!egl_get_float(env, value_tpl[6], value_ptr++)) Badarg(5459,"value");
5621 if(!egl_get_float(env, value_tpl[7], value_ptr++)) Badarg(5459,"value");
5622 if(!egl_get_float(env, value_tpl[8], value_ptr++)) Badarg(5459,"value");
5623 value_l = value_t;
5624 };
5625 value = value_vec.data();
5626 weglUniformMatrix3fv(location,count,transpose,value);
5627 }
5628
ecb_glUniformMatrix4fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5629 void ecb_glUniformMatrix4fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5630 {
5631 GLint location;
5632 GLsizei count;
5633 GLboolean transpose;
5634 GLfloat *value;
5635 if(!enif_get_int(env, argv[0], &location)) Badarg(5460,"location");
5636 if(!enif_get_int(env, argv[1], &count)) Badarg(5460,"count");
5637 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5460,"transpose");
5638 if(!enif_is_list(env, argv[3])) { Badarg(5460,"value")}
5639 int value_a;
5640 const ERL_NIF_TERM *value_tpl;
5641 ERL_NIF_TERM value_l, value_h, value_t;
5642 std::vector <GLfloat> value_vec (16*count);
5643 GLfloat *value_ptr = value_vec.data();
5644 value_l = argv[3];
5645 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
5646 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 16) Badarg(5460,"value");
5647 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5460,"value");
5648 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5460,"value");
5649 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5460,"value");
5650 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5460,"value");
5651 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5460,"value");
5652 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5460,"value");
5653 if(!egl_get_float(env, value_tpl[6], value_ptr++)) Badarg(5460,"value");
5654 if(!egl_get_float(env, value_tpl[7], value_ptr++)) Badarg(5460,"value");
5655 if(!egl_get_float(env, value_tpl[8], value_ptr++)) Badarg(5460,"value");
5656 if(!egl_get_float(env, value_tpl[9], value_ptr++)) Badarg(5460,"value");
5657 if(!egl_get_float(env, value_tpl[10], value_ptr++)) Badarg(5460,"value");
5658 if(!egl_get_float(env, value_tpl[11], value_ptr++)) Badarg(5460,"value");
5659 if(!egl_get_float(env, value_tpl[12], value_ptr++)) Badarg(5460,"value");
5660 if(!egl_get_float(env, value_tpl[13], value_ptr++)) Badarg(5460,"value");
5661 if(!egl_get_float(env, value_tpl[14], value_ptr++)) Badarg(5460,"value");
5662 if(!egl_get_float(env, value_tpl[15], value_ptr++)) Badarg(5460,"value");
5663 value_l = value_t;
5664 };
5665 value = value_vec.data();
5666 weglUniformMatrix4fv(location,count,transpose,value);
5667 }
5668
ecb_glValidateProgram(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5669 void ecb_glValidateProgram(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5670 {
5671 GLuint program;
5672 if(!enif_get_uint(env, argv[0], &program)) Badarg(5461,"program");
5673 weglValidateProgram(program);
5674 }
5675
ecb_glVertexAttrib1d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5676 void ecb_glVertexAttrib1d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5677 {
5678 GLuint index;
5679 GLdouble x;
5680 if(!enif_get_uint(env, argv[0], &index)) Badarg(5462,"index");
5681 if(!enif_get_double(env, argv[1], &x)) Badarg(5462,"x");
5682 weglVertexAttrib1d(index,x);
5683 }
5684
ecb_glVertexAttrib1f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5685 void ecb_glVertexAttrib1f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5686 {
5687 GLuint index;
5688 GLfloat x;
5689 if(!enif_get_uint(env, argv[0], &index)) Badarg(5463,"index");
5690 if(!egl_get_float(env, argv[1], &x)) Badarg(5463,"x");
5691 weglVertexAttrib1f(index,x);
5692 }
5693
ecb_glVertexAttrib1s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5694 void ecb_glVertexAttrib1s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5695 {
5696 GLuint index;
5697 GLshort x;
5698 if(!enif_get_uint(env, argv[0], &index)) Badarg(5464,"index");
5699 if(!egl_get_short(env, argv[1], &x)) Badarg(5464,"x");
5700 weglVertexAttrib1s(index,x);
5701 }
5702
ecb_glVertexAttrib2d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5703 void ecb_glVertexAttrib2d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5704 {
5705 GLuint index;
5706 GLdouble x;
5707 GLdouble y;
5708 if(!enif_get_uint(env, argv[0], &index)) Badarg(5465,"index");
5709 if(!enif_get_double(env, argv[1], &x)) Badarg(5465,"x");
5710 if(!enif_get_double(env, argv[2], &y)) Badarg(5465,"y");
5711 weglVertexAttrib2d(index,x,y);
5712 }
5713
ecb_glVertexAttrib2f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5714 void ecb_glVertexAttrib2f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5715 {
5716 GLuint index;
5717 GLfloat x;
5718 GLfloat y;
5719 if(!enif_get_uint(env, argv[0], &index)) Badarg(5466,"index");
5720 if(!egl_get_float(env, argv[1], &x)) Badarg(5466,"x");
5721 if(!egl_get_float(env, argv[2], &y)) Badarg(5466,"y");
5722 weglVertexAttrib2f(index,x,y);
5723 }
5724
ecb_glVertexAttrib2s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5725 void ecb_glVertexAttrib2s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5726 {
5727 GLuint index;
5728 GLshort x;
5729 GLshort y;
5730 if(!enif_get_uint(env, argv[0], &index)) Badarg(5467,"index");
5731 if(!egl_get_short(env, argv[1], &x)) Badarg(5467,"x");
5732 if(!egl_get_short(env, argv[2], &y)) Badarg(5467,"y");
5733 weglVertexAttrib2s(index,x,y);
5734 }
5735
ecb_glVertexAttrib3d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5736 void ecb_glVertexAttrib3d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5737 {
5738 GLuint index;
5739 GLdouble x;
5740 GLdouble y;
5741 GLdouble z;
5742 if(!enif_get_uint(env, argv[0], &index)) Badarg(5468,"index");
5743 if(!enif_get_double(env, argv[1], &x)) Badarg(5468,"x");
5744 if(!enif_get_double(env, argv[2], &y)) Badarg(5468,"y");
5745 if(!enif_get_double(env, argv[3], &z)) Badarg(5468,"z");
5746 weglVertexAttrib3d(index,x,y,z);
5747 }
5748
ecb_glVertexAttrib3f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5749 void ecb_glVertexAttrib3f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5750 {
5751 GLuint index;
5752 GLfloat x;
5753 GLfloat y;
5754 GLfloat z;
5755 if(!enif_get_uint(env, argv[0], &index)) Badarg(5469,"index");
5756 if(!egl_get_float(env, argv[1], &x)) Badarg(5469,"x");
5757 if(!egl_get_float(env, argv[2], &y)) Badarg(5469,"y");
5758 if(!egl_get_float(env, argv[3], &z)) Badarg(5469,"z");
5759 weglVertexAttrib3f(index,x,y,z);
5760 }
5761
ecb_glVertexAttrib3s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5762 void ecb_glVertexAttrib3s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5763 {
5764 GLuint index;
5765 GLshort x;
5766 GLshort y;
5767 GLshort z;
5768 if(!enif_get_uint(env, argv[0], &index)) Badarg(5470,"index");
5769 if(!egl_get_short(env, argv[1], &x)) Badarg(5470,"x");
5770 if(!egl_get_short(env, argv[2], &y)) Badarg(5470,"y");
5771 if(!egl_get_short(env, argv[3], &z)) Badarg(5470,"z");
5772 weglVertexAttrib3s(index,x,y,z);
5773 }
5774
ecb_glVertexAttrib4Nbv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5775 void ecb_glVertexAttrib4Nbv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5776 {
5777 GLuint index;
5778 GLbyte v[4];
5779 if(!enif_get_uint(env, argv[0], &index)) Badarg(5471,"index");
5780 {
5781 int v_a;
5782 const ERL_NIF_TERM *v_t;
5783 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
5784 Badarg(5471,"v");
5785 } else {
5786 int i1 = 0;
5787 if(!egl_get_byte(env, v_t[i1++], &v[0])) Badarg(5471,"v");
5788 if(!egl_get_byte(env, v_t[i1++], &v[1])) Badarg(5471,"v");
5789 if(!egl_get_byte(env, v_t[i1++], &v[2])) Badarg(5471,"v");
5790 if(!egl_get_byte(env, v_t[i1++], &v[3])) Badarg(5471,"v");
5791 }};
5792 weglVertexAttrib4Nbv(index,v);
5793 }
5794
ecb_glVertexAttrib4Niv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5795 void ecb_glVertexAttrib4Niv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5796 {
5797 GLuint index;
5798 GLint v[4];
5799 if(!enif_get_uint(env, argv[0], &index)) Badarg(5472,"index");
5800 {
5801 int v_a;
5802 const ERL_NIF_TERM *v_t;
5803 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
5804 Badarg(5472,"v");
5805 } else {
5806 int i1 = 0;
5807 if(!enif_get_int(env, v_t[i1++], &v[0])) Badarg(5472,"v");
5808 if(!enif_get_int(env, v_t[i1++], &v[1])) Badarg(5472,"v");
5809 if(!enif_get_int(env, v_t[i1++], &v[2])) Badarg(5472,"v");
5810 if(!enif_get_int(env, v_t[i1++], &v[3])) Badarg(5472,"v");
5811 }};
5812 weglVertexAttrib4Niv(index,v);
5813 }
5814
ecb_glVertexAttrib4Nsv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5815 void ecb_glVertexAttrib4Nsv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5816 {
5817 GLuint index;
5818 GLshort v[4];
5819 if(!enif_get_uint(env, argv[0], &index)) Badarg(5473,"index");
5820 {
5821 int v_a;
5822 const ERL_NIF_TERM *v_t;
5823 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
5824 Badarg(5473,"v");
5825 } else {
5826 int i1 = 0;
5827 if(!egl_get_short(env, v_t[i1++], &v[0])) Badarg(5473,"v");
5828 if(!egl_get_short(env, v_t[i1++], &v[1])) Badarg(5473,"v");
5829 if(!egl_get_short(env, v_t[i1++], &v[2])) Badarg(5473,"v");
5830 if(!egl_get_short(env, v_t[i1++], &v[3])) Badarg(5473,"v");
5831 }};
5832 weglVertexAttrib4Nsv(index,v);
5833 }
5834
ecb_glVertexAttrib4Nub(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5835 void ecb_glVertexAttrib4Nub(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5836 {
5837 GLuint index;
5838 GLubyte x;
5839 GLubyte y;
5840 GLubyte z;
5841 GLubyte w;
5842 if(!enif_get_uint(env, argv[0], &index)) Badarg(5474,"index");
5843 if(!egl_get_ubyte(env, argv[1], &x)) Badarg(5474,"x");
5844 if(!egl_get_ubyte(env, argv[2], &y)) Badarg(5474,"y");
5845 if(!egl_get_ubyte(env, argv[3], &z)) Badarg(5474,"z");
5846 if(!egl_get_ubyte(env, argv[4], &w)) Badarg(5474,"w");
5847 weglVertexAttrib4Nub(index,x,y,z,w);
5848 }
5849
ecb_glVertexAttrib4Nuiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5850 void ecb_glVertexAttrib4Nuiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5851 {
5852 GLuint index;
5853 GLuint v[4];
5854 if(!enif_get_uint(env, argv[0], &index)) Badarg(5475,"index");
5855 {
5856 int v_a;
5857 const ERL_NIF_TERM *v_t;
5858 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
5859 Badarg(5475,"v");
5860 } else {
5861 int i1 = 0;
5862 if(!enif_get_uint(env, v_t[i1++], &v[0])) Badarg(5475,"v");
5863 if(!enif_get_uint(env, v_t[i1++], &v[1])) Badarg(5475,"v");
5864 if(!enif_get_uint(env, v_t[i1++], &v[2])) Badarg(5475,"v");
5865 if(!enif_get_uint(env, v_t[i1++], &v[3])) Badarg(5475,"v");
5866 }};
5867 weglVertexAttrib4Nuiv(index,v);
5868 }
5869
ecb_glVertexAttrib4Nusv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5870 void ecb_glVertexAttrib4Nusv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5871 {
5872 GLuint index;
5873 GLushort v[4];
5874 if(!enif_get_uint(env, argv[0], &index)) Badarg(5476,"index");
5875 {
5876 int v_a;
5877 const ERL_NIF_TERM *v_t;
5878 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
5879 Badarg(5476,"v");
5880 } else {
5881 int i1 = 0;
5882 if(!egl_get_ushort(env, v_t[i1++], &v[0])) Badarg(5476,"v");
5883 if(!egl_get_ushort(env, v_t[i1++], &v[1])) Badarg(5476,"v");
5884 if(!egl_get_ushort(env, v_t[i1++], &v[2])) Badarg(5476,"v");
5885 if(!egl_get_ushort(env, v_t[i1++], &v[3])) Badarg(5476,"v");
5886 }};
5887 weglVertexAttrib4Nusv(index,v);
5888 }
5889
ecb_glVertexAttrib4bv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5890 void ecb_glVertexAttrib4bv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5891 {
5892 GLuint index;
5893 GLbyte v[4];
5894 if(!enif_get_uint(env, argv[0], &index)) Badarg(5477,"index");
5895 {
5896 int v_a;
5897 const ERL_NIF_TERM *v_t;
5898 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
5899 Badarg(5477,"v");
5900 } else {
5901 int i1 = 0;
5902 if(!egl_get_byte(env, v_t[i1++], &v[0])) Badarg(5477,"v");
5903 if(!egl_get_byte(env, v_t[i1++], &v[1])) Badarg(5477,"v");
5904 if(!egl_get_byte(env, v_t[i1++], &v[2])) Badarg(5477,"v");
5905 if(!egl_get_byte(env, v_t[i1++], &v[3])) Badarg(5477,"v");
5906 }};
5907 weglVertexAttrib4bv(index,v);
5908 }
5909
ecb_glVertexAttrib4d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5910 void ecb_glVertexAttrib4d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5911 {
5912 GLuint index;
5913 GLdouble x;
5914 GLdouble y;
5915 GLdouble z;
5916 GLdouble w;
5917 if(!enif_get_uint(env, argv[0], &index)) Badarg(5478,"index");
5918 if(!enif_get_double(env, argv[1], &x)) Badarg(5478,"x");
5919 if(!enif_get_double(env, argv[2], &y)) Badarg(5478,"y");
5920 if(!enif_get_double(env, argv[3], &z)) Badarg(5478,"z");
5921 if(!enif_get_double(env, argv[4], &w)) Badarg(5478,"w");
5922 weglVertexAttrib4d(index,x,y,z,w);
5923 }
5924
ecb_glVertexAttrib4f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5925 void ecb_glVertexAttrib4f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5926 {
5927 GLuint index;
5928 GLfloat x;
5929 GLfloat y;
5930 GLfloat z;
5931 GLfloat w;
5932 if(!enif_get_uint(env, argv[0], &index)) Badarg(5479,"index");
5933 if(!egl_get_float(env, argv[1], &x)) Badarg(5479,"x");
5934 if(!egl_get_float(env, argv[2], &y)) Badarg(5479,"y");
5935 if(!egl_get_float(env, argv[3], &z)) Badarg(5479,"z");
5936 if(!egl_get_float(env, argv[4], &w)) Badarg(5479,"w");
5937 weglVertexAttrib4f(index,x,y,z,w);
5938 }
5939
ecb_glVertexAttrib4iv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5940 void ecb_glVertexAttrib4iv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5941 {
5942 GLuint index;
5943 GLint v[4];
5944 if(!enif_get_uint(env, argv[0], &index)) Badarg(5480,"index");
5945 {
5946 int v_a;
5947 const ERL_NIF_TERM *v_t;
5948 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
5949 Badarg(5480,"v");
5950 } else {
5951 int i1 = 0;
5952 if(!enif_get_int(env, v_t[i1++], &v[0])) Badarg(5480,"v");
5953 if(!enif_get_int(env, v_t[i1++], &v[1])) Badarg(5480,"v");
5954 if(!enif_get_int(env, v_t[i1++], &v[2])) Badarg(5480,"v");
5955 if(!enif_get_int(env, v_t[i1++], &v[3])) Badarg(5480,"v");
5956 }};
5957 weglVertexAttrib4iv(index,v);
5958 }
5959
ecb_glVertexAttrib4s(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5960 void ecb_glVertexAttrib4s(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5961 {
5962 GLuint index;
5963 GLshort x;
5964 GLshort y;
5965 GLshort z;
5966 GLshort w;
5967 if(!enif_get_uint(env, argv[0], &index)) Badarg(5481,"index");
5968 if(!egl_get_short(env, argv[1], &x)) Badarg(5481,"x");
5969 if(!egl_get_short(env, argv[2], &y)) Badarg(5481,"y");
5970 if(!egl_get_short(env, argv[3], &z)) Badarg(5481,"z");
5971 if(!egl_get_short(env, argv[4], &w)) Badarg(5481,"w");
5972 weglVertexAttrib4s(index,x,y,z,w);
5973 }
5974
ecb_glVertexAttrib4ubv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5975 void ecb_glVertexAttrib4ubv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5976 {
5977 GLuint index;
5978 GLubyte v[4];
5979 if(!enif_get_uint(env, argv[0], &index)) Badarg(5482,"index");
5980 {
5981 int v_a;
5982 const ERL_NIF_TERM *v_t;
5983 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
5984 Badarg(5482,"v");
5985 } else {
5986 int i1 = 0;
5987 if(!egl_get_ubyte(env, v_t[i1++], &v[0])) Badarg(5482,"v");
5988 if(!egl_get_ubyte(env, v_t[i1++], &v[1])) Badarg(5482,"v");
5989 if(!egl_get_ubyte(env, v_t[i1++], &v[2])) Badarg(5482,"v");
5990 if(!egl_get_ubyte(env, v_t[i1++], &v[3])) Badarg(5482,"v");
5991 }};
5992 weglVertexAttrib4ubv(index,v);
5993 }
5994
ecb_glVertexAttrib4uiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])5995 void ecb_glVertexAttrib4uiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
5996 {
5997 GLuint index;
5998 GLuint v[4];
5999 if(!enif_get_uint(env, argv[0], &index)) Badarg(5483,"index");
6000 {
6001 int v_a;
6002 const ERL_NIF_TERM *v_t;
6003 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
6004 Badarg(5483,"v");
6005 } else {
6006 int i1 = 0;
6007 if(!enif_get_uint(env, v_t[i1++], &v[0])) Badarg(5483,"v");
6008 if(!enif_get_uint(env, v_t[i1++], &v[1])) Badarg(5483,"v");
6009 if(!enif_get_uint(env, v_t[i1++], &v[2])) Badarg(5483,"v");
6010 if(!enif_get_uint(env, v_t[i1++], &v[3])) Badarg(5483,"v");
6011 }};
6012 weglVertexAttrib4uiv(index,v);
6013 }
6014
ecb_glVertexAttrib4usv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6015 void ecb_glVertexAttrib4usv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6016 {
6017 GLuint index;
6018 GLushort v[4];
6019 if(!enif_get_uint(env, argv[0], &index)) Badarg(5484,"index");
6020 {
6021 int v_a;
6022 const ERL_NIF_TERM *v_t;
6023 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
6024 Badarg(5484,"v");
6025 } else {
6026 int i1 = 0;
6027 if(!egl_get_ushort(env, v_t[i1++], &v[0])) Badarg(5484,"v");
6028 if(!egl_get_ushort(env, v_t[i1++], &v[1])) Badarg(5484,"v");
6029 if(!egl_get_ushort(env, v_t[i1++], &v[2])) Badarg(5484,"v");
6030 if(!egl_get_ushort(env, v_t[i1++], &v[3])) Badarg(5484,"v");
6031 }};
6032 weglVertexAttrib4usv(index,v);
6033 }
6034
ecb_glVertexAttribPointer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6035 void ecb_glVertexAttribPointer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6036 {
6037 GLuint index;
6038 GLint size;
6039 GLenum type;
6040 GLboolean normalized;
6041 GLsizei stride;
6042 ErlNifBinary pointer;
6043 void *pointer_idx;
6044 if(!enif_get_uint(env, argv[0], &index)) Badarg(5485,"index");
6045 if(!enif_get_int(env, argv[1], &size)) Badarg(5485,"size");
6046 if(!enif_get_uint(env, argv[2], &type)) Badarg(5485,"type");
6047 if(!egl_get_ubyte(env, argv[3], &normalized)) Badarg(5485,"normalized");
6048 if(!enif_get_int(env, argv[4], &stride)) Badarg(5485,"stride");
6049 if(!egl_get_ptr(env, argv[5], (void **) &pointer_idx)) {
6050 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[5], &pointer))
6051 pointer_idx = (void *) pointer.data;
6052 else Badarg(5485,"pointer");
6053 }
6054 weglVertexAttribPointer(index,size,type,normalized,stride,pointer_idx);
6055 }
6056
ecb_glUniformMatrix2x3fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6057 void ecb_glUniformMatrix2x3fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6058 {
6059 GLint location;
6060 GLsizei count;
6061 GLboolean transpose;
6062 GLfloat *value;
6063 if(!enif_get_int(env, argv[0], &location)) Badarg(5487,"location");
6064 if(!enif_get_int(env, argv[1], &count)) Badarg(5487,"count");
6065 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5487,"transpose");
6066 if(!enif_is_list(env, argv[3])) { Badarg(5487,"value")}
6067 int value_a;
6068 const ERL_NIF_TERM *value_tpl;
6069 ERL_NIF_TERM value_l, value_h, value_t;
6070 std::vector <GLfloat> value_vec (6*count);
6071 GLfloat *value_ptr = value_vec.data();
6072 value_l = argv[3];
6073 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
6074 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 6) Badarg(5487,"value");
6075 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5487,"value");
6076 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5487,"value");
6077 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5487,"value");
6078 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5487,"value");
6079 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5487,"value");
6080 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5487,"value");
6081 value_l = value_t;
6082 };
6083 value = value_vec.data();
6084 weglUniformMatrix2x3fv(location,count,transpose,value);
6085 }
6086
ecb_glUniformMatrix3x2fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6087 void ecb_glUniformMatrix3x2fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6088 {
6089 GLint location;
6090 GLsizei count;
6091 GLboolean transpose;
6092 GLfloat *value;
6093 if(!enif_get_int(env, argv[0], &location)) Badarg(5488,"location");
6094 if(!enif_get_int(env, argv[1], &count)) Badarg(5488,"count");
6095 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5488,"transpose");
6096 if(!enif_is_list(env, argv[3])) { Badarg(5488,"value")}
6097 int value_a;
6098 const ERL_NIF_TERM *value_tpl;
6099 ERL_NIF_TERM value_l, value_h, value_t;
6100 std::vector <GLfloat> value_vec (6*count);
6101 GLfloat *value_ptr = value_vec.data();
6102 value_l = argv[3];
6103 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
6104 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 6) Badarg(5488,"value");
6105 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5488,"value");
6106 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5488,"value");
6107 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5488,"value");
6108 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5488,"value");
6109 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5488,"value");
6110 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5488,"value");
6111 value_l = value_t;
6112 };
6113 value = value_vec.data();
6114 weglUniformMatrix3x2fv(location,count,transpose,value);
6115 }
6116
ecb_glUniformMatrix2x4fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6117 void ecb_glUniformMatrix2x4fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6118 {
6119 GLint location;
6120 GLsizei count;
6121 GLboolean transpose;
6122 GLfloat *value;
6123 if(!enif_get_int(env, argv[0], &location)) Badarg(5489,"location");
6124 if(!enif_get_int(env, argv[1], &count)) Badarg(5489,"count");
6125 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5489,"transpose");
6126 if(!enif_is_list(env, argv[3])) { Badarg(5489,"value")}
6127 int value_a;
6128 const ERL_NIF_TERM *value_tpl;
6129 ERL_NIF_TERM value_l, value_h, value_t;
6130 std::vector <GLfloat> value_vec (8*count);
6131 GLfloat *value_ptr = value_vec.data();
6132 value_l = argv[3];
6133 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
6134 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 8) Badarg(5489,"value");
6135 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5489,"value");
6136 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5489,"value");
6137 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5489,"value");
6138 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5489,"value");
6139 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5489,"value");
6140 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5489,"value");
6141 if(!egl_get_float(env, value_tpl[6], value_ptr++)) Badarg(5489,"value");
6142 if(!egl_get_float(env, value_tpl[7], value_ptr++)) Badarg(5489,"value");
6143 value_l = value_t;
6144 };
6145 value = value_vec.data();
6146 weglUniformMatrix2x4fv(location,count,transpose,value);
6147 }
6148
ecb_glUniformMatrix4x2fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6149 void ecb_glUniformMatrix4x2fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6150 {
6151 GLint location;
6152 GLsizei count;
6153 GLboolean transpose;
6154 GLfloat *value;
6155 if(!enif_get_int(env, argv[0], &location)) Badarg(5490,"location");
6156 if(!enif_get_int(env, argv[1], &count)) Badarg(5490,"count");
6157 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5490,"transpose");
6158 if(!enif_is_list(env, argv[3])) { Badarg(5490,"value")}
6159 int value_a;
6160 const ERL_NIF_TERM *value_tpl;
6161 ERL_NIF_TERM value_l, value_h, value_t;
6162 std::vector <GLfloat> value_vec (8*count);
6163 GLfloat *value_ptr = value_vec.data();
6164 value_l = argv[3];
6165 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
6166 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 8) Badarg(5490,"value");
6167 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5490,"value");
6168 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5490,"value");
6169 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5490,"value");
6170 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5490,"value");
6171 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5490,"value");
6172 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5490,"value");
6173 if(!egl_get_float(env, value_tpl[6], value_ptr++)) Badarg(5490,"value");
6174 if(!egl_get_float(env, value_tpl[7], value_ptr++)) Badarg(5490,"value");
6175 value_l = value_t;
6176 };
6177 value = value_vec.data();
6178 weglUniformMatrix4x2fv(location,count,transpose,value);
6179 }
6180
ecb_glUniformMatrix3x4fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6181 void ecb_glUniformMatrix3x4fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6182 {
6183 GLint location;
6184 GLsizei count;
6185 GLboolean transpose;
6186 GLfloat *value;
6187 if(!enif_get_int(env, argv[0], &location)) Badarg(5491,"location");
6188 if(!enif_get_int(env, argv[1], &count)) Badarg(5491,"count");
6189 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5491,"transpose");
6190 if(!enif_is_list(env, argv[3])) { Badarg(5491,"value")}
6191 int value_a;
6192 const ERL_NIF_TERM *value_tpl;
6193 ERL_NIF_TERM value_l, value_h, value_t;
6194 std::vector <GLfloat> value_vec (12*count);
6195 GLfloat *value_ptr = value_vec.data();
6196 value_l = argv[3];
6197 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
6198 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 12) Badarg(5491,"value");
6199 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5491,"value");
6200 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5491,"value");
6201 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5491,"value");
6202 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5491,"value");
6203 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5491,"value");
6204 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5491,"value");
6205 if(!egl_get_float(env, value_tpl[6], value_ptr++)) Badarg(5491,"value");
6206 if(!egl_get_float(env, value_tpl[7], value_ptr++)) Badarg(5491,"value");
6207 if(!egl_get_float(env, value_tpl[8], value_ptr++)) Badarg(5491,"value");
6208 if(!egl_get_float(env, value_tpl[9], value_ptr++)) Badarg(5491,"value");
6209 if(!egl_get_float(env, value_tpl[10], value_ptr++)) Badarg(5491,"value");
6210 if(!egl_get_float(env, value_tpl[11], value_ptr++)) Badarg(5491,"value");
6211 value_l = value_t;
6212 };
6213 value = value_vec.data();
6214 weglUniformMatrix3x4fv(location,count,transpose,value);
6215 }
6216
ecb_glUniformMatrix4x3fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6217 void ecb_glUniformMatrix4x3fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6218 {
6219 GLint location;
6220 GLsizei count;
6221 GLboolean transpose;
6222 GLfloat *value;
6223 if(!enif_get_int(env, argv[0], &location)) Badarg(5492,"location");
6224 if(!enif_get_int(env, argv[1], &count)) Badarg(5492,"count");
6225 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5492,"transpose");
6226 if(!enif_is_list(env, argv[3])) { Badarg(5492,"value")}
6227 int value_a;
6228 const ERL_NIF_TERM *value_tpl;
6229 ERL_NIF_TERM value_l, value_h, value_t;
6230 std::vector <GLfloat> value_vec (12*count);
6231 GLfloat *value_ptr = value_vec.data();
6232 value_l = argv[3];
6233 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
6234 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 12) Badarg(5492,"value");
6235 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5492,"value");
6236 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5492,"value");
6237 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5492,"value");
6238 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5492,"value");
6239 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5492,"value");
6240 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5492,"value");
6241 if(!egl_get_float(env, value_tpl[6], value_ptr++)) Badarg(5492,"value");
6242 if(!egl_get_float(env, value_tpl[7], value_ptr++)) Badarg(5492,"value");
6243 if(!egl_get_float(env, value_tpl[8], value_ptr++)) Badarg(5492,"value");
6244 if(!egl_get_float(env, value_tpl[9], value_ptr++)) Badarg(5492,"value");
6245 if(!egl_get_float(env, value_tpl[10], value_ptr++)) Badarg(5492,"value");
6246 if(!egl_get_float(env, value_tpl[11], value_ptr++)) Badarg(5492,"value");
6247 value_l = value_t;
6248 };
6249 value = value_vec.data();
6250 weglUniformMatrix4x3fv(location,count,transpose,value);
6251 }
6252
ecb_glColorMaski(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6253 void ecb_glColorMaski(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6254 {
6255 GLuint index;
6256 GLboolean r;
6257 GLboolean g;
6258 GLboolean b;
6259 GLboolean a;
6260 if(!enif_get_uint(env, argv[0], &index)) Badarg(5493,"index");
6261 if(!egl_get_ubyte(env, argv[1], &r)) Badarg(5493,"r");
6262 if(!egl_get_ubyte(env, argv[2], &g)) Badarg(5493,"g");
6263 if(!egl_get_ubyte(env, argv[3], &b)) Badarg(5493,"b");
6264 if(!egl_get_ubyte(env, argv[4], &a)) Badarg(5493,"a");
6265 weglColorMaski(index,r,g,b,a);
6266 }
6267
ecb_glGetBooleani_v(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6268 void ecb_glGetBooleani_v(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6269 {
6270 ERL_NIF_TERM reply;
6271 GLenum target;
6272 GLuint index;
6273 GLboolean data[16];
6274 ERL_NIF_TERM data_ts[16];
6275 if(!enif_get_uint(env, argv[0], &target)) Badarg(5494,"target");
6276 if(!enif_get_uint(env, argv[1], &index)) Badarg(5494,"index");
6277 weglGetBooleani_v(target,index,data);
6278 for(int ri=0; ri < (int) 16; ri++)
6279 data_ts[ri] = enif_make_int(env, data[ri]);
6280 reply = enif_make_list_from_array(env, data_ts, 16);
6281 enif_send(NULL, self, env,
6282 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
6283 }
6284
ecb_glGetIntegeri_v(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6285 void ecb_glGetIntegeri_v(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6286 {
6287 ERL_NIF_TERM reply;
6288 GLenum target;
6289 GLuint index;
6290 GLint data[16];
6291 ERL_NIF_TERM data_ts[16];
6292 if(!enif_get_uint(env, argv[0], &target)) Badarg(5495,"target");
6293 if(!enif_get_uint(env, argv[1], &index)) Badarg(5495,"index");
6294 weglGetIntegeri_v(target,index,data);
6295 for(int ri=0; ri < (int) 16; ri++)
6296 data_ts[ri] = enif_make_int(env, data[ri]);
6297 reply = enif_make_list_from_array(env, data_ts, 16);
6298 enif_send(NULL, self, env,
6299 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
6300 }
6301
ecb_glEnablei(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6302 void ecb_glEnablei(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6303 {
6304 GLenum target;
6305 GLuint index;
6306 if(!enif_get_uint(env, argv[0], &target)) Badarg(5496,"target");
6307 if(!enif_get_uint(env, argv[1], &index)) Badarg(5496,"index");
6308 weglEnablei(target,index);
6309 }
6310
ecb_glDisablei(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6311 void ecb_glDisablei(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6312 {
6313 GLenum target;
6314 GLuint index;
6315 if(!enif_get_uint(env, argv[0], &target)) Badarg(5497,"target");
6316 if(!enif_get_uint(env, argv[1], &index)) Badarg(5497,"index");
6317 weglDisablei(target,index);
6318 }
6319
ecb_glIsEnabledi(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6320 void ecb_glIsEnabledi(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6321 {
6322 GLboolean result;
6323 ERL_NIF_TERM reply;
6324 GLenum target;
6325 GLuint index;
6326 if(!enif_get_uint(env, argv[0], &target)) Badarg(5498,"target");
6327 if(!enif_get_uint(env, argv[1], &index)) Badarg(5498,"index");
6328 result = weglIsEnabledi(target,index);
6329 reply = enif_make_int(env, result);
6330 enif_send(NULL, self, env,
6331 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
6332 }
6333
ecb_glBeginTransformFeedback(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6334 void ecb_glBeginTransformFeedback(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6335 {
6336 GLenum primitiveMode;
6337 if(!enif_get_uint(env, argv[0], &primitiveMode)) Badarg(5499,"primitiveMode");
6338 weglBeginTransformFeedback(primitiveMode);
6339 }
6340
ecb_glEndTransformFeedback(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6341 void ecb_glEndTransformFeedback(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6342 {
6343 weglEndTransformFeedback();
6344 }
6345
ecb_glBindBufferRange(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6346 void ecb_glBindBufferRange(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6347 {
6348 GLenum target;
6349 GLuint index;
6350 GLuint buffer;
6351 GLintptr offset;
6352 GLsizeiptr size;
6353 if(!enif_get_uint(env, argv[0], &target)) Badarg(5501,"target");
6354 if(!enif_get_uint(env, argv[1], &index)) Badarg(5501,"index");
6355 if(!enif_get_uint(env, argv[2], &buffer)) Badarg(5501,"buffer");
6356 if(!egl_get_word(env, argv[3], (egl_word *) &offset)) Badarg(5501,"offset");
6357 if(!egl_get_word(env, argv[4], (egl_word *) &size)) Badarg(5501,"size");
6358 weglBindBufferRange(target,index,buffer,offset,size);
6359 }
6360
ecb_glBindBufferBase(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6361 void ecb_glBindBufferBase(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6362 {
6363 GLenum target;
6364 GLuint index;
6365 GLuint buffer;
6366 if(!enif_get_uint(env, argv[0], &target)) Badarg(5502,"target");
6367 if(!enif_get_uint(env, argv[1], &index)) Badarg(5502,"index");
6368 if(!enif_get_uint(env, argv[2], &buffer)) Badarg(5502,"buffer");
6369 weglBindBufferBase(target,index,buffer);
6370 }
6371
ecb_glTransformFeedbackVaryings(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6372 void ecb_glTransformFeedbackVaryings(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6373 {
6374 GLuint program;
6375 GLsizei count;
6376 GLenum bufferMode;
6377 if(!enif_get_uint(env, argv[0], &program)) Badarg(5503,"program");
6378 if(!enif_get_int(env, argv[1], &count)) Badarg(5503,"count");
6379 ERL_NIF_TERM varyings_l, varyings_h, varyings_t;
6380 ErlNifBinary varyings_tmp;
6381 std::vector <GLchar *> varyings;
6382 varyings_l = argv[2];
6383 while(enif_get_list_cell(env, varyings_l, &varyings_h, &varyings_t)) {
6384 if(!enif_inspect_binary(env, varyings_h, &varyings_tmp)) Badarg(5503,"varyings");
6385 varyings.push_back((GLchar *) varyings_tmp.data);
6386 varyings_l = varyings_t;
6387 }
6388 if(!enif_get_uint(env, argv[3], &bufferMode)) Badarg(5503,"bufferMode");
6389 weglTransformFeedbackVaryings(program,count,(const GLchar **) varyings.data(),bufferMode);
6390 }
6391
ecb_glGetTransformFeedbackVarying(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6392 void ecb_glGetTransformFeedbackVarying(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6393 {
6394 ERL_NIF_TERM reply;
6395 GLuint program;
6396 GLuint index;
6397 GLsizei bufSize;
6398 GLsizei length;
6399 GLsizei size;
6400 GLenum type;
6401 unsigned char *name;
6402 if(!enif_get_uint(env, argv[0], &program)) Badarg(5504,"program");
6403 if(!enif_get_uint(env, argv[1], &index)) Badarg(5504,"index");
6404 if(!enif_get_int(env, argv[2], &bufSize)) Badarg(5504,"bufSize");
6405 name = (unsigned char *) enif_alloc((int) bufSize*sizeof(GLchar));
6406 weglGetTransformFeedbackVarying(program,index,bufSize,&length,&size,&type,(GLchar *) name);
6407 reply = enif_make_tuple3(env,
6408 enif_make_int(env, size),
6409 enif_make_int(env, type),
6410 enif_make_string(env, (const char *) name, ERL_NIF_LATIN1) );
6411 enif_send(NULL, self, env,
6412 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
6413 enif_free(name);
6414 }
6415
ecb_glClampColor(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6416 void ecb_glClampColor(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6417 {
6418 GLenum target;
6419 GLenum clamp;
6420 if(!enif_get_uint(env, argv[0], &target)) Badarg(5505,"target");
6421 if(!enif_get_uint(env, argv[1], &clamp)) Badarg(5505,"clamp");
6422 weglClampColor(target,clamp);
6423 }
6424
ecb_glBeginConditionalRender(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6425 void ecb_glBeginConditionalRender(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6426 {
6427 GLuint id;
6428 GLenum mode;
6429 if(!enif_get_uint(env, argv[0], &id)) Badarg(5506,"id");
6430 if(!enif_get_uint(env, argv[1], &mode)) Badarg(5506,"mode");
6431 weglBeginConditionalRender(id,mode);
6432 }
6433
ecb_glEndConditionalRender(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6434 void ecb_glEndConditionalRender(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6435 {
6436 weglEndConditionalRender();
6437 }
6438
ecb_glVertexAttribIPointer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6439 void ecb_glVertexAttribIPointer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6440 {
6441 GLuint index;
6442 GLint size;
6443 GLenum type;
6444 GLsizei stride;
6445 ErlNifBinary pointer;
6446 void *pointer_idx;
6447 if(!enif_get_uint(env, argv[0], &index)) Badarg(5508,"index");
6448 if(!enif_get_int(env, argv[1], &size)) Badarg(5508,"size");
6449 if(!enif_get_uint(env, argv[2], &type)) Badarg(5508,"type");
6450 if(!enif_get_int(env, argv[3], &stride)) Badarg(5508,"stride");
6451 if(!egl_get_ptr(env, argv[4], (void **) &pointer_idx)) {
6452 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[4], &pointer))
6453 pointer_idx = (void *) pointer.data;
6454 else Badarg(5508,"pointer");
6455 }
6456 weglVertexAttribIPointer(index,size,type,stride,pointer_idx);
6457 }
6458
ecb_glGetVertexAttribIiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6459 void ecb_glGetVertexAttribIiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6460 {
6461 ERL_NIF_TERM reply;
6462 GLuint index;
6463 GLenum pname;
6464 GLint params[4];
6465 if(!enif_get_uint(env, argv[0], &index)) Badarg(5510,"index");
6466 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5510,"pname");
6467 weglGetVertexAttribIiv(index,pname,params);
6468 reply = enif_make_tuple4(env,
6469 enif_make_int(env, params[0]),
6470 enif_make_int(env, params[1]),
6471 enif_make_int(env, params[2]),
6472 enif_make_int(env, params[3]));
6473 enif_send(NULL, self, env,
6474 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
6475 }
6476
ecb_glGetVertexAttribIuiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6477 void ecb_glGetVertexAttribIuiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6478 {
6479 ERL_NIF_TERM reply;
6480 GLuint index;
6481 GLenum pname;
6482 GLuint params[4];
6483 if(!enif_get_uint(env, argv[0], &index)) Badarg(5511,"index");
6484 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5511,"pname");
6485 weglGetVertexAttribIuiv(index,pname,params);
6486 reply = enif_make_tuple4(env,
6487 enif_make_int(env, params[0]),
6488 enif_make_int(env, params[1]),
6489 enif_make_int(env, params[2]),
6490 enif_make_int(env, params[3]));
6491 enif_send(NULL, self, env,
6492 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
6493 }
6494
ecb_glVertexAttribI1i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6495 void ecb_glVertexAttribI1i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6496 {
6497 GLuint index;
6498 GLint x;
6499 if(!enif_get_uint(env, argv[0], &index)) Badarg(5512,"index");
6500 if(!enif_get_int(env, argv[1], &x)) Badarg(5512,"x");
6501 weglVertexAttribI1i(index,x);
6502 }
6503
ecb_glVertexAttribI2i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6504 void ecb_glVertexAttribI2i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6505 {
6506 GLuint index;
6507 GLint x;
6508 GLint y;
6509 if(!enif_get_uint(env, argv[0], &index)) Badarg(5513,"index");
6510 if(!enif_get_int(env, argv[1], &x)) Badarg(5513,"x");
6511 if(!enif_get_int(env, argv[2], &y)) Badarg(5513,"y");
6512 weglVertexAttribI2i(index,x,y);
6513 }
6514
ecb_glVertexAttribI3i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6515 void ecb_glVertexAttribI3i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6516 {
6517 GLuint index;
6518 GLint x;
6519 GLint y;
6520 GLint z;
6521 if(!enif_get_uint(env, argv[0], &index)) Badarg(5514,"index");
6522 if(!enif_get_int(env, argv[1], &x)) Badarg(5514,"x");
6523 if(!enif_get_int(env, argv[2], &y)) Badarg(5514,"y");
6524 if(!enif_get_int(env, argv[3], &z)) Badarg(5514,"z");
6525 weglVertexAttribI3i(index,x,y,z);
6526 }
6527
ecb_glVertexAttribI4i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6528 void ecb_glVertexAttribI4i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6529 {
6530 GLuint index;
6531 GLint x;
6532 GLint y;
6533 GLint z;
6534 GLint w;
6535 if(!enif_get_uint(env, argv[0], &index)) Badarg(5515,"index");
6536 if(!enif_get_int(env, argv[1], &x)) Badarg(5515,"x");
6537 if(!enif_get_int(env, argv[2], &y)) Badarg(5515,"y");
6538 if(!enif_get_int(env, argv[3], &z)) Badarg(5515,"z");
6539 if(!enif_get_int(env, argv[4], &w)) Badarg(5515,"w");
6540 weglVertexAttribI4i(index,x,y,z,w);
6541 }
6542
ecb_glVertexAttribI1ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6543 void ecb_glVertexAttribI1ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6544 {
6545 GLuint index;
6546 GLuint x;
6547 if(!enif_get_uint(env, argv[0], &index)) Badarg(5516,"index");
6548 if(!enif_get_uint(env, argv[1], &x)) Badarg(5516,"x");
6549 weglVertexAttribI1ui(index,x);
6550 }
6551
ecb_glVertexAttribI2ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6552 void ecb_glVertexAttribI2ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6553 {
6554 GLuint index;
6555 GLuint x;
6556 GLuint y;
6557 if(!enif_get_uint(env, argv[0], &index)) Badarg(5517,"index");
6558 if(!enif_get_uint(env, argv[1], &x)) Badarg(5517,"x");
6559 if(!enif_get_uint(env, argv[2], &y)) Badarg(5517,"y");
6560 weglVertexAttribI2ui(index,x,y);
6561 }
6562
ecb_glVertexAttribI3ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6563 void ecb_glVertexAttribI3ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6564 {
6565 GLuint index;
6566 GLuint x;
6567 GLuint y;
6568 GLuint z;
6569 if(!enif_get_uint(env, argv[0], &index)) Badarg(5518,"index");
6570 if(!enif_get_uint(env, argv[1], &x)) Badarg(5518,"x");
6571 if(!enif_get_uint(env, argv[2], &y)) Badarg(5518,"y");
6572 if(!enif_get_uint(env, argv[3], &z)) Badarg(5518,"z");
6573 weglVertexAttribI3ui(index,x,y,z);
6574 }
6575
ecb_glVertexAttribI4ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6576 void ecb_glVertexAttribI4ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6577 {
6578 GLuint index;
6579 GLuint x;
6580 GLuint y;
6581 GLuint z;
6582 GLuint w;
6583 if(!enif_get_uint(env, argv[0], &index)) Badarg(5519,"index");
6584 if(!enif_get_uint(env, argv[1], &x)) Badarg(5519,"x");
6585 if(!enif_get_uint(env, argv[2], &y)) Badarg(5519,"y");
6586 if(!enif_get_uint(env, argv[3], &z)) Badarg(5519,"z");
6587 if(!enif_get_uint(env, argv[4], &w)) Badarg(5519,"w");
6588 weglVertexAttribI4ui(index,x,y,z,w);
6589 }
6590
ecb_glVertexAttribI4bv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6591 void ecb_glVertexAttribI4bv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6592 {
6593 GLuint index;
6594 GLbyte v[4];
6595 if(!enif_get_uint(env, argv[0], &index)) Badarg(5520,"index");
6596 {
6597 int v_a;
6598 const ERL_NIF_TERM *v_t;
6599 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
6600 Badarg(5520,"v");
6601 } else {
6602 int i1 = 0;
6603 if(!egl_get_byte(env, v_t[i1++], &v[0])) Badarg(5520,"v");
6604 if(!egl_get_byte(env, v_t[i1++], &v[1])) Badarg(5520,"v");
6605 if(!egl_get_byte(env, v_t[i1++], &v[2])) Badarg(5520,"v");
6606 if(!egl_get_byte(env, v_t[i1++], &v[3])) Badarg(5520,"v");
6607 }};
6608 weglVertexAttribI4bv(index,v);
6609 }
6610
ecb_glVertexAttribI4sv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6611 void ecb_glVertexAttribI4sv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6612 {
6613 GLuint index;
6614 GLshort v[4];
6615 if(!enif_get_uint(env, argv[0], &index)) Badarg(5521,"index");
6616 {
6617 int v_a;
6618 const ERL_NIF_TERM *v_t;
6619 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
6620 Badarg(5521,"v");
6621 } else {
6622 int i1 = 0;
6623 if(!egl_get_short(env, v_t[i1++], &v[0])) Badarg(5521,"v");
6624 if(!egl_get_short(env, v_t[i1++], &v[1])) Badarg(5521,"v");
6625 if(!egl_get_short(env, v_t[i1++], &v[2])) Badarg(5521,"v");
6626 if(!egl_get_short(env, v_t[i1++], &v[3])) Badarg(5521,"v");
6627 }};
6628 weglVertexAttribI4sv(index,v);
6629 }
6630
ecb_glVertexAttribI4ubv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6631 void ecb_glVertexAttribI4ubv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6632 {
6633 GLuint index;
6634 GLubyte v[4];
6635 if(!enif_get_uint(env, argv[0], &index)) Badarg(5522,"index");
6636 {
6637 int v_a;
6638 const ERL_NIF_TERM *v_t;
6639 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
6640 Badarg(5522,"v");
6641 } else {
6642 int i1 = 0;
6643 if(!egl_get_ubyte(env, v_t[i1++], &v[0])) Badarg(5522,"v");
6644 if(!egl_get_ubyte(env, v_t[i1++], &v[1])) Badarg(5522,"v");
6645 if(!egl_get_ubyte(env, v_t[i1++], &v[2])) Badarg(5522,"v");
6646 if(!egl_get_ubyte(env, v_t[i1++], &v[3])) Badarg(5522,"v");
6647 }};
6648 weglVertexAttribI4ubv(index,v);
6649 }
6650
ecb_glVertexAttribI4usv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6651 void ecb_glVertexAttribI4usv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6652 {
6653 GLuint index;
6654 GLushort v[4];
6655 if(!enif_get_uint(env, argv[0], &index)) Badarg(5523,"index");
6656 {
6657 int v_a;
6658 const ERL_NIF_TERM *v_t;
6659 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
6660 Badarg(5523,"v");
6661 } else {
6662 int i1 = 0;
6663 if(!egl_get_ushort(env, v_t[i1++], &v[0])) Badarg(5523,"v");
6664 if(!egl_get_ushort(env, v_t[i1++], &v[1])) Badarg(5523,"v");
6665 if(!egl_get_ushort(env, v_t[i1++], &v[2])) Badarg(5523,"v");
6666 if(!egl_get_ushort(env, v_t[i1++], &v[3])) Badarg(5523,"v");
6667 }};
6668 weglVertexAttribI4usv(index,v);
6669 }
6670
ecb_glGetUniformuiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6671 void ecb_glGetUniformuiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6672 {
6673 ERL_NIF_TERM reply;
6674 GLuint program;
6675 GLint location;
6676 GLuint params[16];
6677 ERL_NIF_TERM params_ts[16];
6678 if(!enif_get_uint(env, argv[0], &program)) Badarg(5524,"program");
6679 if(!enif_get_int(env, argv[1], &location)) Badarg(5524,"location");
6680 weglGetUniformuiv(program,location,params);
6681 for(int ri=0; ri < (int) 16; ri++)
6682 params_ts[ri] = enif_make_int(env, params[ri]);
6683 reply = enif_make_tuple_from_array(env, params_ts, 16);
6684 enif_send(NULL, self, env,
6685 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
6686 }
6687
ecb_glBindFragDataLocation(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6688 void ecb_glBindFragDataLocation(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6689 {
6690 GLuint program;
6691 GLuint color;
6692 ErlNifBinary name;
6693 if(!enif_get_uint(env, argv[0], &program)) Badarg(5525,"program");
6694 if(!enif_get_uint(env, argv[1], &color)) Badarg(5525,"color");
6695 if(!enif_inspect_binary(env, argv[2], &name)) Badarg(5525,"name");
6696 weglBindFragDataLocation(program,color,(GLchar *) name.data);
6697 }
6698
ecb_glGetFragDataLocation(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6699 void ecb_glGetFragDataLocation(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6700 {
6701 GLint result;
6702 ERL_NIF_TERM reply;
6703 GLuint program;
6704 ErlNifBinary name;
6705 if(!enif_get_uint(env, argv[0], &program)) Badarg(5526,"program");
6706 if(!enif_inspect_binary(env, argv[1], &name)) Badarg(5526,"name");
6707 result = weglGetFragDataLocation(program,(GLchar *) name.data);
6708 reply = enif_make_int(env, result);
6709 enif_send(NULL, self, env,
6710 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
6711 }
6712
ecb_glUniform1ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6713 void ecb_glUniform1ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6714 {
6715 GLint location;
6716 GLuint v0;
6717 if(!enif_get_int(env, argv[0], &location)) Badarg(5527,"location");
6718 if(!enif_get_uint(env, argv[1], &v0)) Badarg(5527,"v0");
6719 weglUniform1ui(location,v0);
6720 }
6721
ecb_glUniform2ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6722 void ecb_glUniform2ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6723 {
6724 GLint location;
6725 GLuint v0;
6726 GLuint v1;
6727 if(!enif_get_int(env, argv[0], &location)) Badarg(5528,"location");
6728 if(!enif_get_uint(env, argv[1], &v0)) Badarg(5528,"v0");
6729 if(!enif_get_uint(env, argv[2], &v1)) Badarg(5528,"v1");
6730 weglUniform2ui(location,v0,v1);
6731 }
6732
ecb_glUniform3ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6733 void ecb_glUniform3ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6734 {
6735 GLint location;
6736 GLuint v0;
6737 GLuint v1;
6738 GLuint v2;
6739 if(!enif_get_int(env, argv[0], &location)) Badarg(5529,"location");
6740 if(!enif_get_uint(env, argv[1], &v0)) Badarg(5529,"v0");
6741 if(!enif_get_uint(env, argv[2], &v1)) Badarg(5529,"v1");
6742 if(!enif_get_uint(env, argv[3], &v2)) Badarg(5529,"v2");
6743 weglUniform3ui(location,v0,v1,v2);
6744 }
6745
ecb_glUniform4ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6746 void ecb_glUniform4ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6747 {
6748 GLint location;
6749 GLuint v0;
6750 GLuint v1;
6751 GLuint v2;
6752 GLuint v3;
6753 if(!enif_get_int(env, argv[0], &location)) Badarg(5530,"location");
6754 if(!enif_get_uint(env, argv[1], &v0)) Badarg(5530,"v0");
6755 if(!enif_get_uint(env, argv[2], &v1)) Badarg(5530,"v1");
6756 if(!enif_get_uint(env, argv[3], &v2)) Badarg(5530,"v2");
6757 if(!enif_get_uint(env, argv[4], &v3)) Badarg(5530,"v3");
6758 weglUniform4ui(location,v0,v1,v2,v3);
6759 }
6760
ecb_glUniform1uiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6761 void ecb_glUniform1uiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6762 {
6763 GLint location;
6764 GLsizei count;
6765 GLuint *value;
6766 if(!enif_get_int(env, argv[0], &location)) Badarg(5531,"location");
6767 if(!enif_get_int(env, argv[1], &count)) Badarg(5531,"count");
6768 if(!enif_is_list(env, argv[2])) Badarg(5531, "value")
6769 else {
6770 ERL_NIF_TERM value_l, value_h, value_t;
6771 std::vector <GLuint> value_vec;
6772 GLuint value_tmp;
6773 value_l = argv[2];
6774 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
6775 if(!enif_get_uint(env, value_h, &value_tmp)) Badarg(5531,"value");
6776 value_vec.push_back(value_tmp);
6777 value_l = value_t;
6778 };
6779 value = value_vec.data();
6780 }
6781 weglUniform1uiv(location,count,value);
6782 }
6783
ecb_glUniform2uiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6784 void ecb_glUniform2uiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6785 {
6786 GLint location;
6787 GLsizei count;
6788 GLuint *value;
6789 if(!enif_get_int(env, argv[0], &location)) Badarg(5532,"location");
6790 if(!enif_get_int(env, argv[1], &count)) Badarg(5532,"count");
6791 if(!enif_is_list(env, argv[2])) { Badarg(5532,"value")}
6792 int value_a;
6793 const ERL_NIF_TERM *value_tpl;
6794 ERL_NIF_TERM value_l, value_h, value_t;
6795 std::vector <GLuint> value_vec (2*count);
6796 GLuint *value_ptr = value_vec.data();
6797 value_l = argv[2];
6798 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
6799 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 2) Badarg(5532,"value");
6800 if(!enif_get_uint(env, value_tpl[0], value_ptr++)) Badarg(5532,"value");
6801 if(!enif_get_uint(env, value_tpl[1], value_ptr++)) Badarg(5532,"value");
6802 value_l = value_t;
6803 };
6804 value = value_vec.data();
6805 weglUniform2uiv(location,count,value);
6806 }
6807
ecb_glUniform3uiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6808 void ecb_glUniform3uiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6809 {
6810 GLint location;
6811 GLsizei count;
6812 GLuint *value;
6813 if(!enif_get_int(env, argv[0], &location)) Badarg(5533,"location");
6814 if(!enif_get_int(env, argv[1], &count)) Badarg(5533,"count");
6815 if(!enif_is_list(env, argv[2])) { Badarg(5533,"value")}
6816 int value_a;
6817 const ERL_NIF_TERM *value_tpl;
6818 ERL_NIF_TERM value_l, value_h, value_t;
6819 std::vector <GLuint> value_vec (3*count);
6820 GLuint *value_ptr = value_vec.data();
6821 value_l = argv[2];
6822 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
6823 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 3) Badarg(5533,"value");
6824 if(!enif_get_uint(env, value_tpl[0], value_ptr++)) Badarg(5533,"value");
6825 if(!enif_get_uint(env, value_tpl[1], value_ptr++)) Badarg(5533,"value");
6826 if(!enif_get_uint(env, value_tpl[2], value_ptr++)) Badarg(5533,"value");
6827 value_l = value_t;
6828 };
6829 value = value_vec.data();
6830 weglUniform3uiv(location,count,value);
6831 }
6832
ecb_glUniform4uiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6833 void ecb_glUniform4uiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6834 {
6835 GLint location;
6836 GLsizei count;
6837 GLuint *value;
6838 if(!enif_get_int(env, argv[0], &location)) Badarg(5534,"location");
6839 if(!enif_get_int(env, argv[1], &count)) Badarg(5534,"count");
6840 if(!enif_is_list(env, argv[2])) { Badarg(5534,"value")}
6841 int value_a;
6842 const ERL_NIF_TERM *value_tpl;
6843 ERL_NIF_TERM value_l, value_h, value_t;
6844 std::vector <GLuint> value_vec (4*count);
6845 GLuint *value_ptr = value_vec.data();
6846 value_l = argv[2];
6847 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
6848 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5534,"value");
6849 if(!enif_get_uint(env, value_tpl[0], value_ptr++)) Badarg(5534,"value");
6850 if(!enif_get_uint(env, value_tpl[1], value_ptr++)) Badarg(5534,"value");
6851 if(!enif_get_uint(env, value_tpl[2], value_ptr++)) Badarg(5534,"value");
6852 if(!enif_get_uint(env, value_tpl[3], value_ptr++)) Badarg(5534,"value");
6853 value_l = value_t;
6854 };
6855 value = value_vec.data();
6856 weglUniform4uiv(location,count,value);
6857 }
6858
ecb_glTexParameterIiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6859 void ecb_glTexParameterIiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6860 {
6861 GLenum target;
6862 GLenum pname;
6863 GLint params[4];
6864 if(!enif_get_uint(env, argv[0], &target)) Badarg(5535,"target");
6865 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5535,"pname");
6866 {
6867 int params_a;
6868 const ERL_NIF_TERM *params_t;
6869 int i;
6870 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
6871 Badarg(5535,"params");
6872 } else {
6873 for(i = 0; i < params_a; i++)
6874 if(!enif_get_int(env, params_t[i], ¶ms[i])) Badarg(5535,"params");
6875 }};
6876 weglTexParameterIiv(target,pname,params);
6877 }
6878
ecb_glTexParameterIuiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6879 void ecb_glTexParameterIuiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6880 {
6881 GLenum target;
6882 GLenum pname;
6883 GLuint params[4];
6884 if(!enif_get_uint(env, argv[0], &target)) Badarg(5536,"target");
6885 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5536,"pname");
6886 {
6887 int params_a;
6888 const ERL_NIF_TERM *params_t;
6889 int i;
6890 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
6891 Badarg(5536,"params");
6892 } else {
6893 for(i = 0; i < params_a; i++)
6894 if(!enif_get_uint(env, params_t[i], ¶ms[i])) Badarg(5536,"params");
6895 }};
6896 weglTexParameterIuiv(target,pname,params);
6897 }
6898
ecb_glGetTexParameterIiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6899 void ecb_glGetTexParameterIiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6900 {
6901 ERL_NIF_TERM reply;
6902 GLenum target;
6903 GLenum pname;
6904 GLint params[4];
6905 if(!enif_get_uint(env, argv[0], &target)) Badarg(5537,"target");
6906 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5537,"pname");
6907 weglGetTexParameterIiv(target,pname,params);
6908 reply = enif_make_tuple4(env,
6909 enif_make_int(env, params[0]),
6910 enif_make_int(env, params[1]),
6911 enif_make_int(env, params[2]),
6912 enif_make_int(env, params[3]));
6913 enif_send(NULL, self, env,
6914 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
6915 }
6916
ecb_glGetTexParameterIuiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6917 void ecb_glGetTexParameterIuiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6918 {
6919 ERL_NIF_TERM reply;
6920 GLenum target;
6921 GLenum pname;
6922 GLuint params[4];
6923 if(!enif_get_uint(env, argv[0], &target)) Badarg(5538,"target");
6924 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5538,"pname");
6925 weglGetTexParameterIuiv(target,pname,params);
6926 reply = enif_make_tuple4(env,
6927 enif_make_int(env, params[0]),
6928 enif_make_int(env, params[1]),
6929 enif_make_int(env, params[2]),
6930 enif_make_int(env, params[3]));
6931 enif_send(NULL, self, env,
6932 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
6933 }
6934
ecb_glClearBufferiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6935 void ecb_glClearBufferiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6936 {
6937 GLenum buffer;
6938 GLint drawbuffer;
6939 GLint value[4];
6940 if(!enif_get_uint(env, argv[0], &buffer)) Badarg(5539,"buffer");
6941 if(!enif_get_int(env, argv[1], &drawbuffer)) Badarg(5539,"drawbuffer");
6942 {
6943 int value_a;
6944 const ERL_NIF_TERM *value_t;
6945 int i;
6946 if(!enif_get_tuple(env, argv[2], &value_a, &value_t)) {
6947 Badarg(5539,"value");
6948 } else {
6949 for(i = 0; i < value_a; i++)
6950 if(!enif_get_int(env, value_t[i], &value[i])) Badarg(5539,"value");
6951 }};
6952 weglClearBufferiv(buffer,drawbuffer,value);
6953 }
6954
ecb_glClearBufferuiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6955 void ecb_glClearBufferuiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6956 {
6957 GLenum buffer;
6958 GLint drawbuffer;
6959 GLuint value[4];
6960 if(!enif_get_uint(env, argv[0], &buffer)) Badarg(5540,"buffer");
6961 if(!enif_get_int(env, argv[1], &drawbuffer)) Badarg(5540,"drawbuffer");
6962 {
6963 int value_a;
6964 const ERL_NIF_TERM *value_t;
6965 int i;
6966 if(!enif_get_tuple(env, argv[2], &value_a, &value_t)) {
6967 Badarg(5540,"value");
6968 } else {
6969 for(i = 0; i < value_a; i++)
6970 if(!enif_get_uint(env, value_t[i], &value[i])) Badarg(5540,"value");
6971 }};
6972 weglClearBufferuiv(buffer,drawbuffer,value);
6973 }
6974
ecb_glClearBufferfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6975 void ecb_glClearBufferfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6976 {
6977 GLenum buffer;
6978 GLint drawbuffer;
6979 GLfloat value[4];
6980 if(!enif_get_uint(env, argv[0], &buffer)) Badarg(5541,"buffer");
6981 if(!enif_get_int(env, argv[1], &drawbuffer)) Badarg(5541,"drawbuffer");
6982 {
6983 int value_a;
6984 const ERL_NIF_TERM *value_t;
6985 int i;
6986 if(!enif_get_tuple(env, argv[2], &value_a, &value_t)) {
6987 Badarg(5541,"value");
6988 } else {
6989 for(i = 0; i < value_a; i++)
6990 if(!egl_get_float(env, value_t[i], &value[i])) Badarg(5541,"value");
6991 }};
6992 weglClearBufferfv(buffer,drawbuffer,value);
6993 }
6994
ecb_glClearBufferfi(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])6995 void ecb_glClearBufferfi(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
6996 {
6997 GLenum buffer;
6998 GLint drawbuffer;
6999 GLfloat depth;
7000 GLint stencil;
7001 if(!enif_get_uint(env, argv[0], &buffer)) Badarg(5542,"buffer");
7002 if(!enif_get_int(env, argv[1], &drawbuffer)) Badarg(5542,"drawbuffer");
7003 if(!egl_get_float(env, argv[2], &depth)) Badarg(5542,"depth");
7004 if(!enif_get_int(env, argv[3], &stencil)) Badarg(5542,"stencil");
7005 weglClearBufferfi(buffer,drawbuffer,depth,stencil);
7006 }
7007
ecb_glGetStringi(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7008 void ecb_glGetStringi(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7009 {
7010 const GLubyte * result;
7011 ERL_NIF_TERM reply;
7012 GLenum name;
7013 GLuint index;
7014 if(!enif_get_uint(env, argv[0], &name)) Badarg(5543,"name");
7015 if(!enif_get_uint(env, argv[1], &index)) Badarg(5543,"index");
7016 result = weglGetStringi(name,index);
7017 reply = enif_make_string(env, (const char *) result, ERL_NIF_LATIN1);
7018 enif_send(NULL, self, env,
7019 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7020 }
7021
ecb_glIsRenderbuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7022 void ecb_glIsRenderbuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7023 {
7024 GLboolean result;
7025 ERL_NIF_TERM reply;
7026 GLuint renderbuffer;
7027 if(!enif_get_uint(env, argv[0], &renderbuffer)) Badarg(5544,"renderbuffer");
7028 result = weglIsRenderbuffer(renderbuffer);
7029 reply = enif_make_int(env, result);
7030 enif_send(NULL, self, env,
7031 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7032 }
7033
ecb_glBindRenderbuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7034 void ecb_glBindRenderbuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7035 {
7036 GLenum target;
7037 GLuint renderbuffer;
7038 if(!enif_get_uint(env, argv[0], &target)) Badarg(5545,"target");
7039 if(!enif_get_uint(env, argv[1], &renderbuffer)) Badarg(5545,"renderbuffer");
7040 weglBindRenderbuffer(target,renderbuffer);
7041 }
7042
ecb_glDeleteRenderbuffers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7043 void ecb_glDeleteRenderbuffers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7044 {
7045 GLsizei n;
7046 GLuint *renderbuffers;
7047 if(!enif_get_int(env, argv[0], &n)) Badarg(5546,"n");
7048 if(!enif_is_list(env, argv[1])) Badarg(5546, "renderbuffers")
7049 else {
7050 ERL_NIF_TERM renderbuffers_l, renderbuffers_h, renderbuffers_t;
7051 std::vector <GLuint> renderbuffers_vec;
7052 GLuint renderbuffers_tmp;
7053 renderbuffers_l = argv[1];
7054 while(enif_get_list_cell(env, renderbuffers_l, &renderbuffers_h, &renderbuffers_t)) {
7055 if(!enif_get_uint(env, renderbuffers_h, &renderbuffers_tmp)) Badarg(5546,"renderbuffers");
7056 renderbuffers_vec.push_back(renderbuffers_tmp);
7057 renderbuffers_l = renderbuffers_t;
7058 };
7059 renderbuffers = renderbuffers_vec.data();
7060 }
7061 weglDeleteRenderbuffers(n,renderbuffers);
7062 }
7063
ecb_glGenRenderbuffers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7064 void ecb_glGenRenderbuffers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7065 {
7066 ERL_NIF_TERM reply;
7067 GLsizei n;
7068 if(!enif_get_int(env, argv[0], &n)) Badarg(5547,"n");
7069 std::vector <GLuint> renderbuffers (n);
7070 std::vector <ERL_NIF_TERM> renderbuffers_ts (n);
7071 weglGenRenderbuffers(n,renderbuffers.data());
7072 for(int ri=0; ri < (int) n; ri++)
7073 renderbuffers_ts[ri] = enif_make_int(env, renderbuffers[ri]);
7074 reply = enif_make_list_from_array(env, renderbuffers_ts.data(), n);
7075 enif_send(NULL, self, env,
7076 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7077 }
7078
ecb_glRenderbufferStorage(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7079 void ecb_glRenderbufferStorage(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7080 {
7081 GLenum target;
7082 GLenum internalformat;
7083 GLsizei width;
7084 GLsizei height;
7085 if(!enif_get_uint(env, argv[0], &target)) Badarg(5548,"target");
7086 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5548,"internalformat");
7087 if(!enif_get_int(env, argv[2], &width)) Badarg(5548,"width");
7088 if(!enif_get_int(env, argv[3], &height)) Badarg(5548,"height");
7089 weglRenderbufferStorage(target,internalformat,width,height);
7090 }
7091
ecb_glGetRenderbufferParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7092 void ecb_glGetRenderbufferParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7093 {
7094 ERL_NIF_TERM reply;
7095 GLenum target;
7096 GLenum pname;
7097 GLint params;
7098 if(!enif_get_uint(env, argv[0], &target)) Badarg(5549,"target");
7099 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5549,"pname");
7100 weglGetRenderbufferParameteriv(target,pname,¶ms);
7101 reply = enif_make_int(env, params);
7102 enif_send(NULL, self, env,
7103 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7104 }
7105
ecb_glIsFramebuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7106 void ecb_glIsFramebuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7107 {
7108 GLboolean result;
7109 ERL_NIF_TERM reply;
7110 GLuint framebuffer;
7111 if(!enif_get_uint(env, argv[0], &framebuffer)) Badarg(5550,"framebuffer");
7112 result = weglIsFramebuffer(framebuffer);
7113 reply = enif_make_int(env, result);
7114 enif_send(NULL, self, env,
7115 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7116 }
7117
ecb_glBindFramebuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7118 void ecb_glBindFramebuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7119 {
7120 GLenum target;
7121 GLuint framebuffer;
7122 if(!enif_get_uint(env, argv[0], &target)) Badarg(5551,"target");
7123 if(!enif_get_uint(env, argv[1], &framebuffer)) Badarg(5551,"framebuffer");
7124 weglBindFramebuffer(target,framebuffer);
7125 }
7126
ecb_glDeleteFramebuffers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7127 void ecb_glDeleteFramebuffers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7128 {
7129 GLsizei n;
7130 GLuint *framebuffers;
7131 if(!enif_get_int(env, argv[0], &n)) Badarg(5552,"n");
7132 if(!enif_is_list(env, argv[1])) Badarg(5552, "framebuffers")
7133 else {
7134 ERL_NIF_TERM framebuffers_l, framebuffers_h, framebuffers_t;
7135 std::vector <GLuint> framebuffers_vec;
7136 GLuint framebuffers_tmp;
7137 framebuffers_l = argv[1];
7138 while(enif_get_list_cell(env, framebuffers_l, &framebuffers_h, &framebuffers_t)) {
7139 if(!enif_get_uint(env, framebuffers_h, &framebuffers_tmp)) Badarg(5552,"framebuffers");
7140 framebuffers_vec.push_back(framebuffers_tmp);
7141 framebuffers_l = framebuffers_t;
7142 };
7143 framebuffers = framebuffers_vec.data();
7144 }
7145 weglDeleteFramebuffers(n,framebuffers);
7146 }
7147
ecb_glGenFramebuffers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7148 void ecb_glGenFramebuffers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7149 {
7150 ERL_NIF_TERM reply;
7151 GLsizei n;
7152 if(!enif_get_int(env, argv[0], &n)) Badarg(5553,"n");
7153 std::vector <GLuint> framebuffers (n);
7154 std::vector <ERL_NIF_TERM> framebuffers_ts (n);
7155 weglGenFramebuffers(n,framebuffers.data());
7156 for(int ri=0; ri < (int) n; ri++)
7157 framebuffers_ts[ri] = enif_make_int(env, framebuffers[ri]);
7158 reply = enif_make_list_from_array(env, framebuffers_ts.data(), n);
7159 enif_send(NULL, self, env,
7160 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7161 }
7162
ecb_glCheckFramebufferStatus(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7163 void ecb_glCheckFramebufferStatus(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7164 {
7165 GLenum result;
7166 ERL_NIF_TERM reply;
7167 GLenum target;
7168 if(!enif_get_uint(env, argv[0], &target)) Badarg(5554,"target");
7169 result = weglCheckFramebufferStatus(target);
7170 reply = enif_make_int(env, result);
7171 enif_send(NULL, self, env,
7172 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7173 }
7174
ecb_glFramebufferTexture1D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7175 void ecb_glFramebufferTexture1D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7176 {
7177 GLenum target;
7178 GLenum attachment;
7179 GLenum textarget;
7180 GLuint texture;
7181 GLint level;
7182 if(!enif_get_uint(env, argv[0], &target)) Badarg(5555,"target");
7183 if(!enif_get_uint(env, argv[1], &attachment)) Badarg(5555,"attachment");
7184 if(!enif_get_uint(env, argv[2], &textarget)) Badarg(5555,"textarget");
7185 if(!enif_get_uint(env, argv[3], &texture)) Badarg(5555,"texture");
7186 if(!enif_get_int(env, argv[4], &level)) Badarg(5555,"level");
7187 weglFramebufferTexture1D(target,attachment,textarget,texture,level);
7188 }
7189
ecb_glFramebufferTexture2D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7190 void ecb_glFramebufferTexture2D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7191 {
7192 GLenum target;
7193 GLenum attachment;
7194 GLenum textarget;
7195 GLuint texture;
7196 GLint level;
7197 if(!enif_get_uint(env, argv[0], &target)) Badarg(5556,"target");
7198 if(!enif_get_uint(env, argv[1], &attachment)) Badarg(5556,"attachment");
7199 if(!enif_get_uint(env, argv[2], &textarget)) Badarg(5556,"textarget");
7200 if(!enif_get_uint(env, argv[3], &texture)) Badarg(5556,"texture");
7201 if(!enif_get_int(env, argv[4], &level)) Badarg(5556,"level");
7202 weglFramebufferTexture2D(target,attachment,textarget,texture,level);
7203 }
7204
ecb_glFramebufferTexture3D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7205 void ecb_glFramebufferTexture3D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7206 {
7207 GLenum target;
7208 GLenum attachment;
7209 GLenum textarget;
7210 GLuint texture;
7211 GLint level;
7212 GLint zoffset;
7213 if(!enif_get_uint(env, argv[0], &target)) Badarg(5557,"target");
7214 if(!enif_get_uint(env, argv[1], &attachment)) Badarg(5557,"attachment");
7215 if(!enif_get_uint(env, argv[2], &textarget)) Badarg(5557,"textarget");
7216 if(!enif_get_uint(env, argv[3], &texture)) Badarg(5557,"texture");
7217 if(!enif_get_int(env, argv[4], &level)) Badarg(5557,"level");
7218 if(!enif_get_int(env, argv[5], &zoffset)) Badarg(5557,"zoffset");
7219 weglFramebufferTexture3D(target,attachment,textarget,texture,level,zoffset);
7220 }
7221
ecb_glFramebufferRenderbuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7222 void ecb_glFramebufferRenderbuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7223 {
7224 GLenum target;
7225 GLenum attachment;
7226 GLenum renderbuffertarget;
7227 GLuint renderbuffer;
7228 if(!enif_get_uint(env, argv[0], &target)) Badarg(5558,"target");
7229 if(!enif_get_uint(env, argv[1], &attachment)) Badarg(5558,"attachment");
7230 if(!enif_get_uint(env, argv[2], &renderbuffertarget)) Badarg(5558,"renderbuffertarget");
7231 if(!enif_get_uint(env, argv[3], &renderbuffer)) Badarg(5558,"renderbuffer");
7232 weglFramebufferRenderbuffer(target,attachment,renderbuffertarget,renderbuffer);
7233 }
7234
ecb_glGetFramebufferAttachmentParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7235 void ecb_glGetFramebufferAttachmentParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7236 {
7237 ERL_NIF_TERM reply;
7238 GLenum target;
7239 GLenum attachment;
7240 GLenum pname;
7241 GLint params;
7242 if(!enif_get_uint(env, argv[0], &target)) Badarg(5559,"target");
7243 if(!enif_get_uint(env, argv[1], &attachment)) Badarg(5559,"attachment");
7244 if(!enif_get_uint(env, argv[2], &pname)) Badarg(5559,"pname");
7245 weglGetFramebufferAttachmentParameteriv(target,attachment,pname,¶ms);
7246 reply = enif_make_int(env, params);
7247 enif_send(NULL, self, env,
7248 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7249 }
7250
ecb_glGenerateMipmap(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7251 void ecb_glGenerateMipmap(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7252 {
7253 GLenum target;
7254 if(!enif_get_uint(env, argv[0], &target)) Badarg(5560,"target");
7255 weglGenerateMipmap(target);
7256 }
7257
ecb_glBlitFramebuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7258 void ecb_glBlitFramebuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7259 {
7260 GLint srcX0;
7261 GLint srcY0;
7262 GLint srcX1;
7263 GLint srcY1;
7264 GLint dstX0;
7265 GLint dstY0;
7266 GLint dstX1;
7267 GLint dstY1;
7268 GLbitfield mask;
7269 GLenum filter;
7270 if(!enif_get_int(env, argv[0], &srcX0)) Badarg(5561,"srcX0");
7271 if(!enif_get_int(env, argv[1], &srcY0)) Badarg(5561,"srcY0");
7272 if(!enif_get_int(env, argv[2], &srcX1)) Badarg(5561,"srcX1");
7273 if(!enif_get_int(env, argv[3], &srcY1)) Badarg(5561,"srcY1");
7274 if(!enif_get_int(env, argv[4], &dstX0)) Badarg(5561,"dstX0");
7275 if(!enif_get_int(env, argv[5], &dstY0)) Badarg(5561,"dstY0");
7276 if(!enif_get_int(env, argv[6], &dstX1)) Badarg(5561,"dstX1");
7277 if(!enif_get_int(env, argv[7], &dstY1)) Badarg(5561,"dstY1");
7278 if(!enif_get_uint(env, argv[8], &mask)) Badarg(5561,"mask");
7279 if(!enif_get_uint(env, argv[9], &filter)) Badarg(5561,"filter");
7280 weglBlitFramebuffer(srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter);
7281 }
7282
ecb_glRenderbufferStorageMultisample(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7283 void ecb_glRenderbufferStorageMultisample(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7284 {
7285 GLenum target;
7286 GLsizei samples;
7287 GLenum internalformat;
7288 GLsizei width;
7289 GLsizei height;
7290 if(!enif_get_uint(env, argv[0], &target)) Badarg(5562,"target");
7291 if(!enif_get_int(env, argv[1], &samples)) Badarg(5562,"samples");
7292 if(!enif_get_uint(env, argv[2], &internalformat)) Badarg(5562,"internalformat");
7293 if(!enif_get_int(env, argv[3], &width)) Badarg(5562,"width");
7294 if(!enif_get_int(env, argv[4], &height)) Badarg(5562,"height");
7295 weglRenderbufferStorageMultisample(target,samples,internalformat,width,height);
7296 }
7297
ecb_glFramebufferTextureLayer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7298 void ecb_glFramebufferTextureLayer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7299 {
7300 GLenum target;
7301 GLenum attachment;
7302 GLuint texture;
7303 GLint level;
7304 GLint layer;
7305 if(!enif_get_uint(env, argv[0], &target)) Badarg(5563,"target");
7306 if(!enif_get_uint(env, argv[1], &attachment)) Badarg(5563,"attachment");
7307 if(!enif_get_uint(env, argv[2], &texture)) Badarg(5563,"texture");
7308 if(!enif_get_int(env, argv[3], &level)) Badarg(5563,"level");
7309 if(!enif_get_int(env, argv[4], &layer)) Badarg(5563,"layer");
7310 weglFramebufferTextureLayer(target,attachment,texture,level,layer);
7311 }
7312
ecb_glFlushMappedBufferRange(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7313 void ecb_glFlushMappedBufferRange(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7314 {
7315 GLenum target;
7316 GLintptr offset;
7317 GLsizeiptr length;
7318 if(!enif_get_uint(env, argv[0], &target)) Badarg(5564,"target");
7319 if(!egl_get_word(env, argv[1], (egl_word *) &offset)) Badarg(5564,"offset");
7320 if(!egl_get_word(env, argv[2], (egl_word *) &length)) Badarg(5564,"length");
7321 weglFlushMappedBufferRange(target,offset,length);
7322 }
7323
ecb_glBindVertexArray(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7324 void ecb_glBindVertexArray(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7325 {
7326 GLuint array;
7327 if(!enif_get_uint(env, argv[0], &array)) Badarg(5565,"array");
7328 weglBindVertexArray(array);
7329 }
7330
ecb_glDeleteVertexArrays(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7331 void ecb_glDeleteVertexArrays(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7332 {
7333 GLsizei n;
7334 GLuint *arrays;
7335 if(!enif_get_int(env, argv[0], &n)) Badarg(5566,"n");
7336 if(!enif_is_list(env, argv[1])) Badarg(5566, "arrays")
7337 else {
7338 ERL_NIF_TERM arrays_l, arrays_h, arrays_t;
7339 std::vector <GLuint> arrays_vec;
7340 GLuint arrays_tmp;
7341 arrays_l = argv[1];
7342 while(enif_get_list_cell(env, arrays_l, &arrays_h, &arrays_t)) {
7343 if(!enif_get_uint(env, arrays_h, &arrays_tmp)) Badarg(5566,"arrays");
7344 arrays_vec.push_back(arrays_tmp);
7345 arrays_l = arrays_t;
7346 };
7347 arrays = arrays_vec.data();
7348 }
7349 weglDeleteVertexArrays(n,arrays);
7350 }
7351
ecb_glGenVertexArrays(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7352 void ecb_glGenVertexArrays(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7353 {
7354 ERL_NIF_TERM reply;
7355 GLsizei n;
7356 if(!enif_get_int(env, argv[0], &n)) Badarg(5567,"n");
7357 std::vector <GLuint> arrays (n);
7358 std::vector <ERL_NIF_TERM> arrays_ts (n);
7359 weglGenVertexArrays(n,arrays.data());
7360 for(int ri=0; ri < (int) n; ri++)
7361 arrays_ts[ri] = enif_make_int(env, arrays[ri]);
7362 reply = enif_make_list_from_array(env, arrays_ts.data(), n);
7363 enif_send(NULL, self, env,
7364 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7365 }
7366
ecb_glIsVertexArray(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7367 void ecb_glIsVertexArray(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7368 {
7369 GLboolean result;
7370 ERL_NIF_TERM reply;
7371 GLuint array;
7372 if(!enif_get_uint(env, argv[0], &array)) Badarg(5568,"array");
7373 result = weglIsVertexArray(array);
7374 reply = enif_make_int(env, result);
7375 enif_send(NULL, self, env,
7376 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7377 }
7378
ecb_glDrawArraysInstanced(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7379 void ecb_glDrawArraysInstanced(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7380 {
7381 GLenum mode;
7382 GLint first;
7383 GLsizei count;
7384 GLsizei instancecount;
7385 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5569,"mode");
7386 if(!enif_get_int(env, argv[1], &first)) Badarg(5569,"first");
7387 if(!enif_get_int(env, argv[2], &count)) Badarg(5569,"count");
7388 if(!enif_get_int(env, argv[3], &instancecount)) Badarg(5569,"instancecount");
7389 weglDrawArraysInstanced(mode,first,count,instancecount);
7390 }
7391
ecb_glDrawElementsInstanced(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7392 void ecb_glDrawElementsInstanced(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7393 {
7394 GLenum mode;
7395 GLsizei count;
7396 GLenum type;
7397 ErlNifBinary indices;
7398 void *indices_idx;
7399 GLsizei instancecount;
7400 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5570,"mode");
7401 if(!enif_get_int(env, argv[1], &count)) Badarg(5570,"count");
7402 if(!enif_get_uint(env, argv[2], &type)) Badarg(5570,"type");
7403 if(!egl_get_ptr(env, argv[3], (void **) &indices_idx)) {
7404 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[3], &indices))
7405 indices_idx = (void *) indices.data;
7406 else Badarg(5570,"indices");
7407 }
7408 if(!enif_get_int(env, argv[4], &instancecount)) Badarg(5570,"instancecount");
7409 weglDrawElementsInstanced(mode,count,type,indices_idx,instancecount);
7410 }
7411
ecb_glTexBuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7412 void ecb_glTexBuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7413 {
7414 GLenum target;
7415 GLenum internalformat;
7416 GLuint buffer;
7417 if(!enif_get_uint(env, argv[0], &target)) Badarg(5572,"target");
7418 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5572,"internalformat");
7419 if(!enif_get_uint(env, argv[2], &buffer)) Badarg(5572,"buffer");
7420 weglTexBuffer(target,internalformat,buffer);
7421 }
7422
ecb_glPrimitiveRestartIndex(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7423 void ecb_glPrimitiveRestartIndex(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7424 {
7425 GLuint index;
7426 if(!enif_get_uint(env, argv[0], &index)) Badarg(5573,"index");
7427 weglPrimitiveRestartIndex(index);
7428 }
7429
ecb_glCopyBufferSubData(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7430 void ecb_glCopyBufferSubData(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7431 {
7432 GLenum readTarget;
7433 GLenum writeTarget;
7434 GLintptr readOffset;
7435 GLintptr writeOffset;
7436 GLsizeiptr size;
7437 if(!enif_get_uint(env, argv[0], &readTarget)) Badarg(5574,"readTarget");
7438 if(!enif_get_uint(env, argv[1], &writeTarget)) Badarg(5574,"writeTarget");
7439 if(!egl_get_word(env, argv[2], (egl_word *) &readOffset)) Badarg(5574,"readOffset");
7440 if(!egl_get_word(env, argv[3], (egl_word *) &writeOffset)) Badarg(5574,"writeOffset");
7441 if(!egl_get_word(env, argv[4], (egl_word *) &size)) Badarg(5574,"size");
7442 weglCopyBufferSubData(readTarget,writeTarget,readOffset,writeOffset,size);
7443 }
7444
ecb_glGetUniformIndices(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7445 void ecb_glGetUniformIndices(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7446 {
7447 ERL_NIF_TERM reply;
7448 GLuint program;
7449 GLsizei uniformCount;
7450 if(!enif_get_uint(env, argv[0], &program)) Badarg(5575,"program");
7451 if(!enif_get_int(env, argv[1], &uniformCount)) Badarg(5575,"uniformCount");
7452 ERL_NIF_TERM uniformNames_l, uniformNames_h, uniformNames_t;
7453 ErlNifBinary uniformNames_tmp;
7454 std::vector <GLchar *> uniformNames;
7455 uniformNames_l = argv[2];
7456 while(enif_get_list_cell(env, uniformNames_l, &uniformNames_h, &uniformNames_t)) {
7457 if(!enif_inspect_binary(env, uniformNames_h, &uniformNames_tmp)) Badarg(5575,"uniformNames");
7458 uniformNames.push_back((GLchar *) uniformNames_tmp.data);
7459 uniformNames_l = uniformNames_t;
7460 }
7461 std::vector <GLuint> uniformIndices (uniformCount);
7462 std::vector <ERL_NIF_TERM> uniformIndices_ts (uniformCount);
7463 weglGetUniformIndices(program,uniformCount,(const GLchar **) uniformNames.data(),uniformIndices.data());
7464 for(int ri=0; ri < (int) uniformCount; ri++)
7465 uniformIndices_ts[ri] = enif_make_int(env, uniformIndices[ri]);
7466 reply = enif_make_list_from_array(env, uniformIndices_ts.data(), uniformCount);
7467 enif_send(NULL, self, env,
7468 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7469 }
7470
ecb_glGetActiveUniformsiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7471 void ecb_glGetActiveUniformsiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7472 {
7473 ERL_NIF_TERM reply;
7474 GLuint program;
7475 GLsizei uniformCount;
7476 GLuint *uniformIndices;
7477 GLenum pname;
7478 if(!enif_get_uint(env, argv[0], &program)) Badarg(5576,"program");
7479 if(!enif_get_int(env, argv[1], &uniformCount)) Badarg(5576,"uniformCount");
7480 if(!enif_is_list(env, argv[2])) Badarg(5576, "uniformIndices")
7481 else {
7482 ERL_NIF_TERM uniformIndices_l, uniformIndices_h, uniformIndices_t;
7483 std::vector <GLuint> uniformIndices_vec;
7484 GLuint uniformIndices_tmp;
7485 uniformIndices_l = argv[2];
7486 while(enif_get_list_cell(env, uniformIndices_l, &uniformIndices_h, &uniformIndices_t)) {
7487 if(!enif_get_uint(env, uniformIndices_h, &uniformIndices_tmp)) Badarg(5576,"uniformIndices");
7488 uniformIndices_vec.push_back(uniformIndices_tmp);
7489 uniformIndices_l = uniformIndices_t;
7490 };
7491 uniformIndices = uniformIndices_vec.data();
7492 }
7493 if(!enif_get_uint(env, argv[3], &pname)) Badarg(5576,"pname");
7494 std::vector <GLint> params (uniformCount);
7495 std::vector <ERL_NIF_TERM> params_ts (uniformCount);
7496 weglGetActiveUniformsiv(program,uniformCount,uniformIndices,pname,params.data());
7497 for(int ri=0; ri < (int) uniformCount; ri++)
7498 params_ts[ri] = enif_make_int(env, params[ri]);
7499 reply = enif_make_list_from_array(env, params_ts.data(), uniformCount);
7500 enif_send(NULL, self, env,
7501 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7502 }
7503
ecb_glGetActiveUniformName(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7504 void ecb_glGetActiveUniformName(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7505 {
7506 ERL_NIF_TERM reply;
7507 GLuint program;
7508 GLuint uniformIndex;
7509 GLsizei bufSize;
7510 GLsizei length;
7511 unsigned char *uniformName;
7512 if(!enif_get_uint(env, argv[0], &program)) Badarg(5577,"program");
7513 if(!enif_get_uint(env, argv[1], &uniformIndex)) Badarg(5577,"uniformIndex");
7514 if(!enif_get_int(env, argv[2], &bufSize)) Badarg(5577,"bufSize");
7515 uniformName = (unsigned char *) enif_alloc((int) bufSize*sizeof(GLchar));
7516 weglGetActiveUniformName(program,uniformIndex,bufSize,&length,(GLchar *) uniformName);
7517 reply = enif_make_string(env, (const char *) uniformName, ERL_NIF_LATIN1);
7518 enif_send(NULL, self, env,
7519 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7520 enif_free(uniformName);
7521 }
7522
ecb_glGetUniformBlockIndex(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7523 void ecb_glGetUniformBlockIndex(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7524 {
7525 GLuint result;
7526 ERL_NIF_TERM reply;
7527 GLuint program;
7528 ErlNifBinary uniformBlockName;
7529 if(!enif_get_uint(env, argv[0], &program)) Badarg(5578,"program");
7530 if(!enif_inspect_binary(env, argv[1], &uniformBlockName)) Badarg(5578,"uniformBlockName");
7531 result = weglGetUniformBlockIndex(program,(GLchar *) uniformBlockName.data);
7532 reply = enif_make_int(env, result);
7533 enif_send(NULL, self, env,
7534 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7535 }
7536
ecb_glGetActiveUniformBlockiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7537 void ecb_glGetActiveUniformBlockiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7538 {
7539 GLuint program;
7540 GLuint uniformBlockIndex;
7541 GLenum pname;
7542 ErlNifBinary params;
7543 if(!enif_get_uint(env, argv[0], &program)) Badarg(5579,"program");
7544 if(!enif_get_uint(env, argv[1], &uniformBlockIndex)) Badarg(5579,"uniformBlockIndex");
7545 if(!enif_get_uint(env, argv[2], &pname)) Badarg(5579,"pname");
7546 if(enif_is_binary(env, argv[3]))
7547 enif_inspect_binary(env, argv[3], ¶ms);
7548 else if(enif_is_tuple(env, argv[3])) {
7549 int params_a;
7550 const ERL_NIF_TERM *params_t;
7551 if(enif_get_tuple(env, argv[3], ¶ms_a, ¶ms_t) &&
7552 enif_is_binary(env, params_t[1]))
7553 enif_inspect_binary(env, params_t[1], ¶ms);
7554 else Badarg(5579, "params");
7555 } else Badarg(5579, "params");
7556 weglGetActiveUniformBlockiv(program,uniformBlockIndex,pname,(GLint *) params.data);
7557 enif_send(NULL, self, env,
7558 enif_make_tuple2(env,EGL_ATOM_REPLY,
7559 EGL_ATOM_OK));
7560 }
7561
ecb_glGetActiveUniformBlockName(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7562 void ecb_glGetActiveUniformBlockName(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7563 {
7564 ERL_NIF_TERM reply;
7565 GLuint program;
7566 GLuint uniformBlockIndex;
7567 GLsizei bufSize;
7568 GLsizei length;
7569 unsigned char *uniformBlockName;
7570 if(!enif_get_uint(env, argv[0], &program)) Badarg(5580,"program");
7571 if(!enif_get_uint(env, argv[1], &uniformBlockIndex)) Badarg(5580,"uniformBlockIndex");
7572 if(!enif_get_int(env, argv[2], &bufSize)) Badarg(5580,"bufSize");
7573 uniformBlockName = (unsigned char *) enif_alloc((int) bufSize*sizeof(GLchar));
7574 weglGetActiveUniformBlockName(program,uniformBlockIndex,bufSize,&length,(GLchar *) uniformBlockName);
7575 reply = enif_make_string(env, (const char *) uniformBlockName, ERL_NIF_LATIN1);
7576 enif_send(NULL, self, env,
7577 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7578 enif_free(uniformBlockName);
7579 }
7580
ecb_glUniformBlockBinding(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7581 void ecb_glUniformBlockBinding(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7582 {
7583 GLuint program;
7584 GLuint uniformBlockIndex;
7585 GLuint uniformBlockBinding;
7586 if(!enif_get_uint(env, argv[0], &program)) Badarg(5581,"program");
7587 if(!enif_get_uint(env, argv[1], &uniformBlockIndex)) Badarg(5581,"uniformBlockIndex");
7588 if(!enif_get_uint(env, argv[2], &uniformBlockBinding)) Badarg(5581,"uniformBlockBinding");
7589 weglUniformBlockBinding(program,uniformBlockIndex,uniformBlockBinding);
7590 }
7591
ecb_glDrawElementsBaseVertex(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7592 void ecb_glDrawElementsBaseVertex(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7593 {
7594 GLenum mode;
7595 GLsizei count;
7596 GLenum type;
7597 ErlNifBinary indices;
7598 void *indices_idx;
7599 GLint basevertex;
7600 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5582,"mode");
7601 if(!enif_get_int(env, argv[1], &count)) Badarg(5582,"count");
7602 if(!enif_get_uint(env, argv[2], &type)) Badarg(5582,"type");
7603 if(!egl_get_ptr(env, argv[3], (void **) &indices_idx)) {
7604 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[3], &indices))
7605 indices_idx = (void *) indices.data;
7606 else Badarg(5582,"indices");
7607 }
7608 if(!enif_get_int(env, argv[4], &basevertex)) Badarg(5582,"basevertex");
7609 weglDrawElementsBaseVertex(mode,count,type,indices_idx,basevertex);
7610 }
7611
ecb_glDrawRangeElementsBaseVertex(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7612 void ecb_glDrawRangeElementsBaseVertex(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7613 {
7614 GLenum mode;
7615 GLuint start;
7616 GLuint end;
7617 GLsizei count;
7618 GLenum type;
7619 ErlNifBinary indices;
7620 void *indices_idx;
7621 GLint basevertex;
7622 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5584,"mode");
7623 if(!enif_get_uint(env, argv[1], &start)) Badarg(5584,"start");
7624 if(!enif_get_uint(env, argv[2], &end)) Badarg(5584,"end");
7625 if(!enif_get_int(env, argv[3], &count)) Badarg(5584,"count");
7626 if(!enif_get_uint(env, argv[4], &type)) Badarg(5584,"type");
7627 if(!egl_get_ptr(env, argv[5], (void **) &indices_idx)) {
7628 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[5], &indices))
7629 indices_idx = (void *) indices.data;
7630 else Badarg(5584,"indices");
7631 }
7632 if(!enif_get_int(env, argv[6], &basevertex)) Badarg(5584,"basevertex");
7633 weglDrawRangeElementsBaseVertex(mode,start,end,count,type,indices_idx,basevertex);
7634 }
7635
ecb_glDrawElementsInstancedBaseVertex(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7636 void ecb_glDrawElementsInstancedBaseVertex(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7637 {
7638 GLenum mode;
7639 GLsizei count;
7640 GLenum type;
7641 ErlNifBinary indices;
7642 void *indices_idx;
7643 GLsizei instancecount;
7644 GLint basevertex;
7645 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5586,"mode");
7646 if(!enif_get_int(env, argv[1], &count)) Badarg(5586,"count");
7647 if(!enif_get_uint(env, argv[2], &type)) Badarg(5586,"type");
7648 if(!egl_get_ptr(env, argv[3], (void **) &indices_idx)) {
7649 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[3], &indices))
7650 indices_idx = (void *) indices.data;
7651 else Badarg(5586,"indices");
7652 }
7653 if(!enif_get_int(env, argv[4], &instancecount)) Badarg(5586,"instancecount");
7654 if(!enif_get_int(env, argv[5], &basevertex)) Badarg(5586,"basevertex");
7655 weglDrawElementsInstancedBaseVertex(mode,count,type,indices_idx,instancecount,basevertex);
7656 }
7657
ecb_glProvokingVertex(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7658 void ecb_glProvokingVertex(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7659 {
7660 GLenum mode;
7661 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5588,"mode");
7662 weglProvokingVertex(mode);
7663 }
7664
ecb_glFenceSync(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7665 void ecb_glFenceSync(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7666 {
7667 GLsync result;
7668 ERL_NIF_TERM reply;
7669 GLenum condition;
7670 GLbitfield flags;
7671 if(!enif_get_uint(env, argv[0], &condition)) Badarg(5589,"condition");
7672 if(!enif_get_uint(env, argv[1], &flags)) Badarg(5589,"flags");
7673 result = weglFenceSync(condition,flags);
7674 reply = enif_make_uint64(env, (egl_uint64_t) result);
7675 enif_send(NULL, self, env,
7676 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7677 }
7678
ecb_glIsSync(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7679 void ecb_glIsSync(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7680 {
7681 GLboolean result;
7682 ERL_NIF_TERM reply;
7683 egl_uint64_t sync;
7684 if(!egl_get_ptr(env, argv[0], (void **) &sync)) Badarg(5590,"sync");
7685 result = weglIsSync((GLsync) sync);
7686 reply = enif_make_int(env, result);
7687 enif_send(NULL, self, env,
7688 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7689 }
7690
ecb_glDeleteSync(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7691 void ecb_glDeleteSync(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7692 {
7693 egl_uint64_t sync;
7694 if(!egl_get_ptr(env, argv[0], (void **) &sync)) Badarg(5591,"sync");
7695 weglDeleteSync((GLsync) sync);
7696 }
7697
ecb_glClientWaitSync(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7698 void ecb_glClientWaitSync(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7699 {
7700 GLenum result;
7701 ERL_NIF_TERM reply;
7702 egl_uint64_t sync;
7703 GLbitfield flags;
7704 GLuint64 timeout;
7705 if(!egl_get_ptr(env, argv[0], (void **) &sync)) Badarg(5592,"sync");
7706 if(!enif_get_uint(env, argv[1], &flags)) Badarg(5592,"flags");
7707 if(!enif_get_uint64(env, argv[2], (egl_uint64_t *) &timeout)) Badarg(5592,"timeout");
7708 result = weglClientWaitSync((GLsync) sync,flags,timeout);
7709 reply = enif_make_int(env, result);
7710 enif_send(NULL, self, env,
7711 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7712 }
7713
ecb_glWaitSync(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7714 void ecb_glWaitSync(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7715 {
7716 egl_uint64_t sync;
7717 GLbitfield flags;
7718 GLuint64 timeout;
7719 if(!egl_get_ptr(env, argv[0], (void **) &sync)) Badarg(5593,"sync");
7720 if(!enif_get_uint(env, argv[1], &flags)) Badarg(5593,"flags");
7721 if(!enif_get_uint64(env, argv[2], (egl_uint64_t *) &timeout)) Badarg(5593,"timeout");
7722 weglWaitSync((GLsync) sync,flags,timeout);
7723 }
7724
ecb_glGetInteger64v(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7725 void ecb_glGetInteger64v(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7726 {
7727 ERL_NIF_TERM reply;
7728 GLenum pname;
7729 GLint64 data[16];
7730 ERL_NIF_TERM data_ts[16];
7731 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5594,"pname");
7732 weglGetInteger64v(pname,data);
7733 for(int ri=0; ri < (int) 16; ri++)
7734 data_ts[ri] = enif_make_int64(env, (egl_int64_t) data[ri]);
7735 reply = enif_make_list_from_array(env, data_ts, 16);
7736 enif_send(NULL, self, env,
7737 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7738 }
7739
ecb_glGetSynciv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7740 void ecb_glGetSynciv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7741 {
7742 ERL_NIF_TERM reply;
7743 egl_uint64_t sync;
7744 GLenum pname;
7745 GLsizei bufSize;
7746 GLsizei length;
7747 if(!egl_get_ptr(env, argv[0], (void **) &sync)) Badarg(5595,"sync");
7748 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5595,"pname");
7749 if(!enif_get_int(env, argv[2], &bufSize)) Badarg(5595,"bufSize");
7750 std::vector <GLint> values (bufSize);
7751 std::vector <ERL_NIF_TERM> values_ts (bufSize);
7752 weglGetSynciv((GLsync) sync,pname,bufSize,&length,values.data());
7753 for(int ri=0; ri < (int) length; ri++)
7754 values_ts[ri] = enif_make_int(env, values[ri]);
7755 reply = enif_make_list_from_array(env, values_ts.data(), length);
7756 enif_send(NULL, self, env,
7757 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7758 }
7759
ecb_glGetInteger64i_v(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7760 void ecb_glGetInteger64i_v(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7761 {
7762 ERL_NIF_TERM reply;
7763 GLenum target;
7764 GLuint index;
7765 GLint64 data[16];
7766 ERL_NIF_TERM data_ts[16];
7767 if(!enif_get_uint(env, argv[0], &target)) Badarg(5596,"target");
7768 if(!enif_get_uint(env, argv[1], &index)) Badarg(5596,"index");
7769 weglGetInteger64i_v(target,index,data);
7770 for(int ri=0; ri < (int) 16; ri++)
7771 data_ts[ri] = enif_make_int64(env, (egl_int64_t) data[ri]);
7772 reply = enif_make_list_from_array(env, data_ts, 16);
7773 enif_send(NULL, self, env,
7774 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7775 }
7776
ecb_glGetBufferParameteri64v(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7777 void ecb_glGetBufferParameteri64v(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7778 {
7779 ERL_NIF_TERM reply;
7780 GLenum target;
7781 GLenum pname;
7782 GLint64 params[16];
7783 ERL_NIF_TERM params_ts[16];
7784 if(!enif_get_uint(env, argv[0], &target)) Badarg(5597,"target");
7785 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5597,"pname");
7786 weglGetBufferParameteri64v(target,pname,params);
7787 for(int ri=0; ri < (int) 16; ri++)
7788 params_ts[ri] = enif_make_int64(env, (egl_int64_t) params[ri]);
7789 reply = enif_make_list_from_array(env, params_ts, 16);
7790 enif_send(NULL, self, env,
7791 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7792 }
7793
ecb_glFramebufferTexture(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7794 void ecb_glFramebufferTexture(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7795 {
7796 GLenum target;
7797 GLenum attachment;
7798 GLuint texture;
7799 GLint level;
7800 if(!enif_get_uint(env, argv[0], &target)) Badarg(5598,"target");
7801 if(!enif_get_uint(env, argv[1], &attachment)) Badarg(5598,"attachment");
7802 if(!enif_get_uint(env, argv[2], &texture)) Badarg(5598,"texture");
7803 if(!enif_get_int(env, argv[3], &level)) Badarg(5598,"level");
7804 weglFramebufferTexture(target,attachment,texture,level);
7805 }
7806
ecb_glTexImage2DMultisample(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7807 void ecb_glTexImage2DMultisample(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7808 {
7809 GLenum target;
7810 GLsizei samples;
7811 GLenum internalformat;
7812 GLsizei width;
7813 GLsizei height;
7814 GLboolean fixedsamplelocations;
7815 if(!enif_get_uint(env, argv[0], &target)) Badarg(5599,"target");
7816 if(!enif_get_int(env, argv[1], &samples)) Badarg(5599,"samples");
7817 if(!enif_get_uint(env, argv[2], &internalformat)) Badarg(5599,"internalformat");
7818 if(!enif_get_int(env, argv[3], &width)) Badarg(5599,"width");
7819 if(!enif_get_int(env, argv[4], &height)) Badarg(5599,"height");
7820 if(!egl_get_ubyte(env, argv[5], &fixedsamplelocations)) Badarg(5599,"fixedsamplelocations");
7821 weglTexImage2DMultisample(target,samples,internalformat,width,height,fixedsamplelocations);
7822 }
7823
ecb_glTexImage3DMultisample(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7824 void ecb_glTexImage3DMultisample(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7825 {
7826 GLenum target;
7827 GLsizei samples;
7828 GLenum internalformat;
7829 GLsizei width;
7830 GLsizei height;
7831 GLsizei depth;
7832 GLboolean fixedsamplelocations;
7833 if(!enif_get_uint(env, argv[0], &target)) Badarg(5600,"target");
7834 if(!enif_get_int(env, argv[1], &samples)) Badarg(5600,"samples");
7835 if(!enif_get_uint(env, argv[2], &internalformat)) Badarg(5600,"internalformat");
7836 if(!enif_get_int(env, argv[3], &width)) Badarg(5600,"width");
7837 if(!enif_get_int(env, argv[4], &height)) Badarg(5600,"height");
7838 if(!enif_get_int(env, argv[5], &depth)) Badarg(5600,"depth");
7839 if(!egl_get_ubyte(env, argv[6], &fixedsamplelocations)) Badarg(5600,"fixedsamplelocations");
7840 weglTexImage3DMultisample(target,samples,internalformat,width,height,depth,fixedsamplelocations);
7841 }
7842
ecb_glGetMultisamplefv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7843 void ecb_glGetMultisamplefv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7844 {
7845 ERL_NIF_TERM reply;
7846 GLenum pname;
7847 GLuint index;
7848 GLfloat val[2];
7849 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5601,"pname");
7850 if(!enif_get_uint(env, argv[1], &index)) Badarg(5601,"index");
7851 weglGetMultisamplefv(pname,index,val);
7852 reply = enif_make_tuple2(env,
7853 enif_make_double(env, (double) val[0]),
7854 enif_make_double(env, (double) val[1]));
7855 enif_send(NULL, self, env,
7856 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7857 }
7858
ecb_glSampleMaski(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7859 void ecb_glSampleMaski(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7860 {
7861 GLuint maskNumber;
7862 GLbitfield mask;
7863 if(!enif_get_uint(env, argv[0], &maskNumber)) Badarg(5602,"maskNumber");
7864 if(!enif_get_uint(env, argv[1], &mask)) Badarg(5602,"mask");
7865 weglSampleMaski(maskNumber,mask);
7866 }
7867
ecb_glBindFragDataLocationIndexed(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7868 void ecb_glBindFragDataLocationIndexed(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7869 {
7870 GLuint program;
7871 GLuint colorNumber;
7872 GLuint index;
7873 ErlNifBinary name;
7874 if(!enif_get_uint(env, argv[0], &program)) Badarg(5603,"program");
7875 if(!enif_get_uint(env, argv[1], &colorNumber)) Badarg(5603,"colorNumber");
7876 if(!enif_get_uint(env, argv[2], &index)) Badarg(5603,"index");
7877 if(!enif_inspect_binary(env, argv[3], &name)) Badarg(5603,"name");
7878 weglBindFragDataLocationIndexed(program,colorNumber,index,(GLchar *) name.data);
7879 }
7880
ecb_glGetFragDataIndex(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7881 void ecb_glGetFragDataIndex(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7882 {
7883 GLint result;
7884 ERL_NIF_TERM reply;
7885 GLuint program;
7886 ErlNifBinary name;
7887 if(!enif_get_uint(env, argv[0], &program)) Badarg(5604,"program");
7888 if(!enif_inspect_binary(env, argv[1], &name)) Badarg(5604,"name");
7889 result = weglGetFragDataIndex(program,(GLchar *) name.data);
7890 reply = enif_make_int(env, result);
7891 enif_send(NULL, self, env,
7892 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7893 }
7894
ecb_glGenSamplers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7895 void ecb_glGenSamplers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7896 {
7897 ERL_NIF_TERM reply;
7898 GLsizei count;
7899 if(!enif_get_int(env, argv[0], &count)) Badarg(5605,"count");
7900 std::vector <GLuint> samplers (count);
7901 std::vector <ERL_NIF_TERM> samplers_ts (count);
7902 weglGenSamplers(count,samplers.data());
7903 for(int ri=0; ri < (int) count; ri++)
7904 samplers_ts[ri] = enif_make_int(env, samplers[ri]);
7905 reply = enif_make_list_from_array(env, samplers_ts.data(), count);
7906 enif_send(NULL, self, env,
7907 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7908 }
7909
ecb_glDeleteSamplers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7910 void ecb_glDeleteSamplers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7911 {
7912 GLsizei count;
7913 GLuint *samplers;
7914 if(!enif_get_int(env, argv[0], &count)) Badarg(5606,"count");
7915 if(!enif_is_list(env, argv[1])) Badarg(5606, "samplers")
7916 else {
7917 ERL_NIF_TERM samplers_l, samplers_h, samplers_t;
7918 std::vector <GLuint> samplers_vec;
7919 GLuint samplers_tmp;
7920 samplers_l = argv[1];
7921 while(enif_get_list_cell(env, samplers_l, &samplers_h, &samplers_t)) {
7922 if(!enif_get_uint(env, samplers_h, &samplers_tmp)) Badarg(5606,"samplers");
7923 samplers_vec.push_back(samplers_tmp);
7924 samplers_l = samplers_t;
7925 };
7926 samplers = samplers_vec.data();
7927 }
7928 weglDeleteSamplers(count,samplers);
7929 }
7930
ecb_glIsSampler(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7931 void ecb_glIsSampler(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7932 {
7933 GLboolean result;
7934 ERL_NIF_TERM reply;
7935 GLuint sampler;
7936 if(!enif_get_uint(env, argv[0], &sampler)) Badarg(5607,"sampler");
7937 result = weglIsSampler(sampler);
7938 reply = enif_make_int(env, result);
7939 enif_send(NULL, self, env,
7940 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
7941 }
7942
ecb_glBindSampler(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7943 void ecb_glBindSampler(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7944 {
7945 GLuint unit;
7946 GLuint sampler;
7947 if(!enif_get_uint(env, argv[0], &unit)) Badarg(5608,"unit");
7948 if(!enif_get_uint(env, argv[1], &sampler)) Badarg(5608,"sampler");
7949 weglBindSampler(unit,sampler);
7950 }
7951
ecb_glSamplerParameteri(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7952 void ecb_glSamplerParameteri(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7953 {
7954 GLuint sampler;
7955 GLenum pname;
7956 GLint param;
7957 if(!enif_get_uint(env, argv[0], &sampler)) Badarg(5609,"sampler");
7958 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5609,"pname");
7959 if(!enif_get_int(env, argv[2], ¶m)) Badarg(5609,"param");
7960 weglSamplerParameteri(sampler,pname,param);
7961 }
7962
ecb_glSamplerParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7963 void ecb_glSamplerParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7964 {
7965 GLuint sampler;
7966 GLenum pname;
7967 GLint *param;
7968 if(!enif_get_uint(env, argv[0], &sampler)) Badarg(5610,"sampler");
7969 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5610,"pname");
7970 if(!enif_is_list(env, argv[2])) Badarg(5610, "param")
7971 else {
7972 ERL_NIF_TERM param_l, param_h, param_t;
7973 std::vector <GLint> param_vec;
7974 GLint param_tmp;
7975 param_l = argv[2];
7976 while(enif_get_list_cell(env, param_l, ¶m_h, ¶m_t)) {
7977 if(!enif_get_int(env, param_h, ¶m_tmp)) Badarg(5610,"param");
7978 param_vec.push_back(param_tmp);
7979 param_l = param_t;
7980 };
7981 param = param_vec.data();
7982 }
7983 weglSamplerParameteriv(sampler,pname,param);
7984 }
7985
ecb_glSamplerParameterf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7986 void ecb_glSamplerParameterf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7987 {
7988 GLuint sampler;
7989 GLenum pname;
7990 GLfloat param;
7991 if(!enif_get_uint(env, argv[0], &sampler)) Badarg(5611,"sampler");
7992 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5611,"pname");
7993 if(!egl_get_float(env, argv[2], ¶m)) Badarg(5611,"param");
7994 weglSamplerParameterf(sampler,pname,param);
7995 }
7996
ecb_glSamplerParameterfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])7997 void ecb_glSamplerParameterfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
7998 {
7999 GLuint sampler;
8000 GLenum pname;
8001 GLfloat *param;
8002 if(!enif_get_uint(env, argv[0], &sampler)) Badarg(5612,"sampler");
8003 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5612,"pname");
8004 if(!enif_is_list(env, argv[2])) Badarg(5612, "param")
8005 else {
8006 ERL_NIF_TERM param_l, param_h, param_t;
8007 std::vector <GLfloat> param_vec;
8008 GLfloat param_tmp;
8009 param_l = argv[2];
8010 while(enif_get_list_cell(env, param_l, ¶m_h, ¶m_t)) {
8011 if(!egl_get_float(env, param_h, ¶m_tmp)) Badarg(5612,"param");
8012 param_vec.push_back(param_tmp);
8013 param_l = param_t;
8014 };
8015 param = param_vec.data();
8016 }
8017 weglSamplerParameterfv(sampler,pname,param);
8018 }
8019
ecb_glSamplerParameterIiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8020 void ecb_glSamplerParameterIiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8021 {
8022 GLuint sampler;
8023 GLenum pname;
8024 GLint *param;
8025 if(!enif_get_uint(env, argv[0], &sampler)) Badarg(5613,"sampler");
8026 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5613,"pname");
8027 if(!enif_is_list(env, argv[2])) Badarg(5613, "param")
8028 else {
8029 ERL_NIF_TERM param_l, param_h, param_t;
8030 std::vector <GLint> param_vec;
8031 GLint param_tmp;
8032 param_l = argv[2];
8033 while(enif_get_list_cell(env, param_l, ¶m_h, ¶m_t)) {
8034 if(!enif_get_int(env, param_h, ¶m_tmp)) Badarg(5613,"param");
8035 param_vec.push_back(param_tmp);
8036 param_l = param_t;
8037 };
8038 param = param_vec.data();
8039 }
8040 weglSamplerParameterIiv(sampler,pname,param);
8041 }
8042
ecb_glSamplerParameterIuiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8043 void ecb_glSamplerParameterIuiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8044 {
8045 GLuint sampler;
8046 GLenum pname;
8047 GLuint *param;
8048 if(!enif_get_uint(env, argv[0], &sampler)) Badarg(5614,"sampler");
8049 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5614,"pname");
8050 if(!enif_is_list(env, argv[2])) Badarg(5614, "param")
8051 else {
8052 ERL_NIF_TERM param_l, param_h, param_t;
8053 std::vector <GLuint> param_vec;
8054 GLuint param_tmp;
8055 param_l = argv[2];
8056 while(enif_get_list_cell(env, param_l, ¶m_h, ¶m_t)) {
8057 if(!enif_get_uint(env, param_h, ¶m_tmp)) Badarg(5614,"param");
8058 param_vec.push_back(param_tmp);
8059 param_l = param_t;
8060 };
8061 param = param_vec.data();
8062 }
8063 weglSamplerParameterIuiv(sampler,pname,param);
8064 }
8065
ecb_glGetSamplerParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8066 void ecb_glGetSamplerParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8067 {
8068 ERL_NIF_TERM reply;
8069 GLuint sampler;
8070 GLenum pname;
8071 GLint params[4];
8072 if(!enif_get_uint(env, argv[0], &sampler)) Badarg(5615,"sampler");
8073 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5615,"pname");
8074 weglGetSamplerParameteriv(sampler,pname,params);
8075 reply = enif_make_list4(env,
8076 enif_make_int(env, params[0]),
8077 enif_make_int(env, params[1]),
8078 enif_make_int(env, params[2]),
8079 enif_make_int(env, params[3]));
8080 enif_send(NULL, self, env,
8081 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8082 }
8083
ecb_glGetSamplerParameterIiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8084 void ecb_glGetSamplerParameterIiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8085 {
8086 ERL_NIF_TERM reply;
8087 GLuint sampler;
8088 GLenum pname;
8089 GLint params[4];
8090 if(!enif_get_uint(env, argv[0], &sampler)) Badarg(5616,"sampler");
8091 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5616,"pname");
8092 weglGetSamplerParameterIiv(sampler,pname,params);
8093 reply = enif_make_list4(env,
8094 enif_make_int(env, params[0]),
8095 enif_make_int(env, params[1]),
8096 enif_make_int(env, params[2]),
8097 enif_make_int(env, params[3]));
8098 enif_send(NULL, self, env,
8099 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8100 }
8101
ecb_glGetSamplerParameterfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8102 void ecb_glGetSamplerParameterfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8103 {
8104 ERL_NIF_TERM reply;
8105 GLuint sampler;
8106 GLenum pname;
8107 GLfloat params[4];
8108 if(!enif_get_uint(env, argv[0], &sampler)) Badarg(5617,"sampler");
8109 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5617,"pname");
8110 weglGetSamplerParameterfv(sampler,pname,params);
8111 reply = enif_make_list4(env,
8112 enif_make_double(env, (double) params[0]),
8113 enif_make_double(env, (double) params[1]),
8114 enif_make_double(env, (double) params[2]),
8115 enif_make_double(env, (double) params[3]));
8116 enif_send(NULL, self, env,
8117 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8118 }
8119
ecb_glGetSamplerParameterIuiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8120 void ecb_glGetSamplerParameterIuiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8121 {
8122 ERL_NIF_TERM reply;
8123 GLuint sampler;
8124 GLenum pname;
8125 GLuint params[4];
8126 if(!enif_get_uint(env, argv[0], &sampler)) Badarg(5618,"sampler");
8127 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5618,"pname");
8128 weglGetSamplerParameterIuiv(sampler,pname,params);
8129 reply = enif_make_list4(env,
8130 enif_make_int(env, params[0]),
8131 enif_make_int(env, params[1]),
8132 enif_make_int(env, params[2]),
8133 enif_make_int(env, params[3]));
8134 enif_send(NULL, self, env,
8135 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8136 }
8137
ecb_glQueryCounter(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8138 void ecb_glQueryCounter(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8139 {
8140 GLuint id;
8141 GLenum target;
8142 if(!enif_get_uint(env, argv[0], &id)) Badarg(5619,"id");
8143 if(!enif_get_uint(env, argv[1], &target)) Badarg(5619,"target");
8144 weglQueryCounter(id,target);
8145 }
8146
ecb_glGetQueryObjecti64v(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8147 void ecb_glGetQueryObjecti64v(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8148 {
8149 ERL_NIF_TERM reply;
8150 GLuint id;
8151 GLenum pname;
8152 GLint64 params;
8153 if(!enif_get_uint(env, argv[0], &id)) Badarg(5620,"id");
8154 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5620,"pname");
8155 weglGetQueryObjecti64v(id,pname,¶ms);
8156 reply = enif_make_int64(env, (egl_int64_t) params);
8157 enif_send(NULL, self, env,
8158 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8159 }
8160
ecb_glGetQueryObjectui64v(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8161 void ecb_glGetQueryObjectui64v(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8162 {
8163 ERL_NIF_TERM reply;
8164 GLuint id;
8165 GLenum pname;
8166 GLuint64 params;
8167 if(!enif_get_uint(env, argv[0], &id)) Badarg(5621,"id");
8168 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5621,"pname");
8169 weglGetQueryObjectui64v(id,pname,¶ms);
8170 reply = enif_make_int64(env, (egl_int64_t) params);
8171 enif_send(NULL, self, env,
8172 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8173 }
8174
ecb_glVertexAttribDivisor(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8175 void ecb_glVertexAttribDivisor(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8176 {
8177 GLuint index;
8178 GLuint divisor;
8179 if(!enif_get_uint(env, argv[0], &index)) Badarg(5622,"index");
8180 if(!enif_get_uint(env, argv[1], &divisor)) Badarg(5622,"divisor");
8181 weglVertexAttribDivisor(index,divisor);
8182 }
8183
ecb_glMinSampleShading(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8184 void ecb_glMinSampleShading(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8185 {
8186 GLfloat value;
8187 if(!egl_get_float(env, argv[0], &value)) Badarg(5623,"value");
8188 weglMinSampleShading(value);
8189 }
8190
ecb_glBlendEquationi(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8191 void ecb_glBlendEquationi(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8192 {
8193 GLuint buf;
8194 GLenum mode;
8195 if(!enif_get_uint(env, argv[0], &buf)) Badarg(5624,"buf");
8196 if(!enif_get_uint(env, argv[1], &mode)) Badarg(5624,"mode");
8197 weglBlendEquationi(buf,mode);
8198 }
8199
ecb_glBlendEquationSeparatei(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8200 void ecb_glBlendEquationSeparatei(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8201 {
8202 GLuint buf;
8203 GLenum modeRGB;
8204 GLenum modeAlpha;
8205 if(!enif_get_uint(env, argv[0], &buf)) Badarg(5625,"buf");
8206 if(!enif_get_uint(env, argv[1], &modeRGB)) Badarg(5625,"modeRGB");
8207 if(!enif_get_uint(env, argv[2], &modeAlpha)) Badarg(5625,"modeAlpha");
8208 weglBlendEquationSeparatei(buf,modeRGB,modeAlpha);
8209 }
8210
ecb_glBlendFunci(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8211 void ecb_glBlendFunci(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8212 {
8213 GLuint buf;
8214 GLenum src;
8215 GLenum dst;
8216 if(!enif_get_uint(env, argv[0], &buf)) Badarg(5626,"buf");
8217 if(!enif_get_uint(env, argv[1], &src)) Badarg(5626,"src");
8218 if(!enif_get_uint(env, argv[2], &dst)) Badarg(5626,"dst");
8219 weglBlendFunci(buf,src,dst);
8220 }
8221
ecb_glBlendFuncSeparatei(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8222 void ecb_glBlendFuncSeparatei(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8223 {
8224 GLuint buf;
8225 GLenum srcRGB;
8226 GLenum dstRGB;
8227 GLenum srcAlpha;
8228 GLenum dstAlpha;
8229 if(!enif_get_uint(env, argv[0], &buf)) Badarg(5627,"buf");
8230 if(!enif_get_uint(env, argv[1], &srcRGB)) Badarg(5627,"srcRGB");
8231 if(!enif_get_uint(env, argv[2], &dstRGB)) Badarg(5627,"dstRGB");
8232 if(!enif_get_uint(env, argv[3], &srcAlpha)) Badarg(5627,"srcAlpha");
8233 if(!enif_get_uint(env, argv[4], &dstAlpha)) Badarg(5627,"dstAlpha");
8234 weglBlendFuncSeparatei(buf,srcRGB,dstRGB,srcAlpha,dstAlpha);
8235 }
8236
ecb_glDrawArraysIndirect(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8237 void ecb_glDrawArraysIndirect(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8238 {
8239 GLenum mode;
8240 ErlNifBinary indirect;
8241 void *indirect_idx;
8242 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5628,"mode");
8243 if(!egl_get_ptr(env, argv[1], (void **) &indirect_idx)) {
8244 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[1], &indirect))
8245 indirect_idx = (void *) indirect.data;
8246 else Badarg(5628,"indirect");
8247 }
8248 weglDrawArraysIndirect(mode,indirect_idx);
8249 }
8250
ecb_glDrawElementsIndirect(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8251 void ecb_glDrawElementsIndirect(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8252 {
8253 GLenum mode;
8254 GLenum type;
8255 ErlNifBinary indirect;
8256 void *indirect_idx;
8257 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5630,"mode");
8258 if(!enif_get_uint(env, argv[1], &type)) Badarg(5630,"type");
8259 if(!egl_get_ptr(env, argv[2], (void **) &indirect_idx)) {
8260 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[2], &indirect))
8261 indirect_idx = (void *) indirect.data;
8262 else Badarg(5630,"indirect");
8263 }
8264 weglDrawElementsIndirect(mode,type,indirect_idx);
8265 }
8266
ecb_glUniform1d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8267 void ecb_glUniform1d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8268 {
8269 GLint location;
8270 GLdouble x;
8271 if(!enif_get_int(env, argv[0], &location)) Badarg(5632,"location");
8272 if(!enif_get_double(env, argv[1], &x)) Badarg(5632,"x");
8273 weglUniform1d(location,x);
8274 }
8275
ecb_glUniform2d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8276 void ecb_glUniform2d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8277 {
8278 GLint location;
8279 GLdouble x;
8280 GLdouble y;
8281 if(!enif_get_int(env, argv[0], &location)) Badarg(5633,"location");
8282 if(!enif_get_double(env, argv[1], &x)) Badarg(5633,"x");
8283 if(!enif_get_double(env, argv[2], &y)) Badarg(5633,"y");
8284 weglUniform2d(location,x,y);
8285 }
8286
ecb_glUniform3d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8287 void ecb_glUniform3d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8288 {
8289 GLint location;
8290 GLdouble x;
8291 GLdouble y;
8292 GLdouble z;
8293 if(!enif_get_int(env, argv[0], &location)) Badarg(5634,"location");
8294 if(!enif_get_double(env, argv[1], &x)) Badarg(5634,"x");
8295 if(!enif_get_double(env, argv[2], &y)) Badarg(5634,"y");
8296 if(!enif_get_double(env, argv[3], &z)) Badarg(5634,"z");
8297 weglUniform3d(location,x,y,z);
8298 }
8299
ecb_glUniform4d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8300 void ecb_glUniform4d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8301 {
8302 GLint location;
8303 GLdouble x;
8304 GLdouble y;
8305 GLdouble z;
8306 GLdouble w;
8307 if(!enif_get_int(env, argv[0], &location)) Badarg(5635,"location");
8308 if(!enif_get_double(env, argv[1], &x)) Badarg(5635,"x");
8309 if(!enif_get_double(env, argv[2], &y)) Badarg(5635,"y");
8310 if(!enif_get_double(env, argv[3], &z)) Badarg(5635,"z");
8311 if(!enif_get_double(env, argv[4], &w)) Badarg(5635,"w");
8312 weglUniform4d(location,x,y,z,w);
8313 }
8314
ecb_glUniform1dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8315 void ecb_glUniform1dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8316 {
8317 GLint location;
8318 GLsizei count;
8319 GLdouble *value;
8320 if(!enif_get_int(env, argv[0], &location)) Badarg(5636,"location");
8321 if(!enif_get_int(env, argv[1], &count)) Badarg(5636,"count");
8322 if(!enif_is_list(env, argv[2])) Badarg(5636, "value")
8323 else {
8324 ERL_NIF_TERM value_l, value_h, value_t;
8325 std::vector <GLdouble> value_vec;
8326 GLdouble value_tmp;
8327 value_l = argv[2];
8328 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
8329 if(!enif_get_double(env, value_h, &value_tmp)) Badarg(5636,"value");
8330 value_vec.push_back(value_tmp);
8331 value_l = value_t;
8332 };
8333 value = value_vec.data();
8334 }
8335 weglUniform1dv(location,count,value);
8336 }
8337
ecb_glUniform2dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8338 void ecb_glUniform2dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8339 {
8340 GLint location;
8341 GLsizei count;
8342 GLdouble *value;
8343 if(!enif_get_int(env, argv[0], &location)) Badarg(5637,"location");
8344 if(!enif_get_int(env, argv[1], &count)) Badarg(5637,"count");
8345 if(!enif_is_list(env, argv[2])) { Badarg(5637,"value")}
8346 int value_a;
8347 const ERL_NIF_TERM *value_tpl;
8348 ERL_NIF_TERM value_l, value_h, value_t;
8349 std::vector <GLdouble> value_vec (2*count);
8350 GLdouble *value_ptr = value_vec.data();
8351 value_l = argv[2];
8352 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
8353 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 2) Badarg(5637,"value");
8354 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5637,"value");
8355 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5637,"value");
8356 value_l = value_t;
8357 };
8358 value = value_vec.data();
8359 weglUniform2dv(location,count,value);
8360 }
8361
ecb_glUniform3dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8362 void ecb_glUniform3dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8363 {
8364 GLint location;
8365 GLsizei count;
8366 GLdouble *value;
8367 if(!enif_get_int(env, argv[0], &location)) Badarg(5638,"location");
8368 if(!enif_get_int(env, argv[1], &count)) Badarg(5638,"count");
8369 if(!enif_is_list(env, argv[2])) { Badarg(5638,"value")}
8370 int value_a;
8371 const ERL_NIF_TERM *value_tpl;
8372 ERL_NIF_TERM value_l, value_h, value_t;
8373 std::vector <GLdouble> value_vec (3*count);
8374 GLdouble *value_ptr = value_vec.data();
8375 value_l = argv[2];
8376 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
8377 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 3) Badarg(5638,"value");
8378 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5638,"value");
8379 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5638,"value");
8380 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5638,"value");
8381 value_l = value_t;
8382 };
8383 value = value_vec.data();
8384 weglUniform3dv(location,count,value);
8385 }
8386
ecb_glUniform4dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8387 void ecb_glUniform4dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8388 {
8389 GLint location;
8390 GLsizei count;
8391 GLdouble *value;
8392 if(!enif_get_int(env, argv[0], &location)) Badarg(5639,"location");
8393 if(!enif_get_int(env, argv[1], &count)) Badarg(5639,"count");
8394 if(!enif_is_list(env, argv[2])) { Badarg(5639,"value")}
8395 int value_a;
8396 const ERL_NIF_TERM *value_tpl;
8397 ERL_NIF_TERM value_l, value_h, value_t;
8398 std::vector <GLdouble> value_vec (4*count);
8399 GLdouble *value_ptr = value_vec.data();
8400 value_l = argv[2];
8401 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
8402 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5639,"value");
8403 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5639,"value");
8404 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5639,"value");
8405 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5639,"value");
8406 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5639,"value");
8407 value_l = value_t;
8408 };
8409 value = value_vec.data();
8410 weglUniform4dv(location,count,value);
8411 }
8412
ecb_glUniformMatrix2dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8413 void ecb_glUniformMatrix2dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8414 {
8415 GLint location;
8416 GLsizei count;
8417 GLboolean transpose;
8418 GLdouble *value;
8419 if(!enif_get_int(env, argv[0], &location)) Badarg(5640,"location");
8420 if(!enif_get_int(env, argv[1], &count)) Badarg(5640,"count");
8421 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5640,"transpose");
8422 if(!enif_is_list(env, argv[3])) { Badarg(5640,"value")}
8423 int value_a;
8424 const ERL_NIF_TERM *value_tpl;
8425 ERL_NIF_TERM value_l, value_h, value_t;
8426 std::vector <GLdouble> value_vec (4*count);
8427 GLdouble *value_ptr = value_vec.data();
8428 value_l = argv[3];
8429 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
8430 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5640,"value");
8431 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5640,"value");
8432 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5640,"value");
8433 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5640,"value");
8434 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5640,"value");
8435 value_l = value_t;
8436 };
8437 value = value_vec.data();
8438 weglUniformMatrix2dv(location,count,transpose,value);
8439 }
8440
ecb_glUniformMatrix3dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8441 void ecb_glUniformMatrix3dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8442 {
8443 GLint location;
8444 GLsizei count;
8445 GLboolean transpose;
8446 GLdouble *value;
8447 if(!enif_get_int(env, argv[0], &location)) Badarg(5641,"location");
8448 if(!enif_get_int(env, argv[1], &count)) Badarg(5641,"count");
8449 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5641,"transpose");
8450 if(!enif_is_list(env, argv[3])) { Badarg(5641,"value")}
8451 int value_a;
8452 const ERL_NIF_TERM *value_tpl;
8453 ERL_NIF_TERM value_l, value_h, value_t;
8454 std::vector <GLdouble> value_vec (9*count);
8455 GLdouble *value_ptr = value_vec.data();
8456 value_l = argv[3];
8457 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
8458 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 9) Badarg(5641,"value");
8459 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5641,"value");
8460 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5641,"value");
8461 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5641,"value");
8462 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5641,"value");
8463 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5641,"value");
8464 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5641,"value");
8465 if(!enif_get_double(env, value_tpl[6], value_ptr++)) Badarg(5641,"value");
8466 if(!enif_get_double(env, value_tpl[7], value_ptr++)) Badarg(5641,"value");
8467 if(!enif_get_double(env, value_tpl[8], value_ptr++)) Badarg(5641,"value");
8468 value_l = value_t;
8469 };
8470 value = value_vec.data();
8471 weglUniformMatrix3dv(location,count,transpose,value);
8472 }
8473
ecb_glUniformMatrix4dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8474 void ecb_glUniformMatrix4dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8475 {
8476 GLint location;
8477 GLsizei count;
8478 GLboolean transpose;
8479 GLdouble *value;
8480 if(!enif_get_int(env, argv[0], &location)) Badarg(5642,"location");
8481 if(!enif_get_int(env, argv[1], &count)) Badarg(5642,"count");
8482 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5642,"transpose");
8483 if(!enif_is_list(env, argv[3])) { Badarg(5642,"value")}
8484 int value_a;
8485 const ERL_NIF_TERM *value_tpl;
8486 ERL_NIF_TERM value_l, value_h, value_t;
8487 std::vector <GLdouble> value_vec (16*count);
8488 GLdouble *value_ptr = value_vec.data();
8489 value_l = argv[3];
8490 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
8491 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 16) Badarg(5642,"value");
8492 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5642,"value");
8493 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5642,"value");
8494 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5642,"value");
8495 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5642,"value");
8496 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5642,"value");
8497 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5642,"value");
8498 if(!enif_get_double(env, value_tpl[6], value_ptr++)) Badarg(5642,"value");
8499 if(!enif_get_double(env, value_tpl[7], value_ptr++)) Badarg(5642,"value");
8500 if(!enif_get_double(env, value_tpl[8], value_ptr++)) Badarg(5642,"value");
8501 if(!enif_get_double(env, value_tpl[9], value_ptr++)) Badarg(5642,"value");
8502 if(!enif_get_double(env, value_tpl[10], value_ptr++)) Badarg(5642,"value");
8503 if(!enif_get_double(env, value_tpl[11], value_ptr++)) Badarg(5642,"value");
8504 if(!enif_get_double(env, value_tpl[12], value_ptr++)) Badarg(5642,"value");
8505 if(!enif_get_double(env, value_tpl[13], value_ptr++)) Badarg(5642,"value");
8506 if(!enif_get_double(env, value_tpl[14], value_ptr++)) Badarg(5642,"value");
8507 if(!enif_get_double(env, value_tpl[15], value_ptr++)) Badarg(5642,"value");
8508 value_l = value_t;
8509 };
8510 value = value_vec.data();
8511 weglUniformMatrix4dv(location,count,transpose,value);
8512 }
8513
ecb_glUniformMatrix2x3dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8514 void ecb_glUniformMatrix2x3dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8515 {
8516 GLint location;
8517 GLsizei count;
8518 GLboolean transpose;
8519 GLdouble *value;
8520 if(!enif_get_int(env, argv[0], &location)) Badarg(5643,"location");
8521 if(!enif_get_int(env, argv[1], &count)) Badarg(5643,"count");
8522 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5643,"transpose");
8523 if(!enif_is_list(env, argv[3])) { Badarg(5643,"value")}
8524 int value_a;
8525 const ERL_NIF_TERM *value_tpl;
8526 ERL_NIF_TERM value_l, value_h, value_t;
8527 std::vector <GLdouble> value_vec (6*count);
8528 GLdouble *value_ptr = value_vec.data();
8529 value_l = argv[3];
8530 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
8531 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 6) Badarg(5643,"value");
8532 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5643,"value");
8533 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5643,"value");
8534 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5643,"value");
8535 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5643,"value");
8536 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5643,"value");
8537 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5643,"value");
8538 value_l = value_t;
8539 };
8540 value = value_vec.data();
8541 weglUniformMatrix2x3dv(location,count,transpose,value);
8542 }
8543
ecb_glUniformMatrix2x4dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8544 void ecb_glUniformMatrix2x4dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8545 {
8546 GLint location;
8547 GLsizei count;
8548 GLboolean transpose;
8549 GLdouble *value;
8550 if(!enif_get_int(env, argv[0], &location)) Badarg(5644,"location");
8551 if(!enif_get_int(env, argv[1], &count)) Badarg(5644,"count");
8552 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5644,"transpose");
8553 if(!enif_is_list(env, argv[3])) { Badarg(5644,"value")}
8554 int value_a;
8555 const ERL_NIF_TERM *value_tpl;
8556 ERL_NIF_TERM value_l, value_h, value_t;
8557 std::vector <GLdouble> value_vec (8*count);
8558 GLdouble *value_ptr = value_vec.data();
8559 value_l = argv[3];
8560 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
8561 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 8) Badarg(5644,"value");
8562 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5644,"value");
8563 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5644,"value");
8564 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5644,"value");
8565 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5644,"value");
8566 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5644,"value");
8567 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5644,"value");
8568 if(!enif_get_double(env, value_tpl[6], value_ptr++)) Badarg(5644,"value");
8569 if(!enif_get_double(env, value_tpl[7], value_ptr++)) Badarg(5644,"value");
8570 value_l = value_t;
8571 };
8572 value = value_vec.data();
8573 weglUniformMatrix2x4dv(location,count,transpose,value);
8574 }
8575
ecb_glUniformMatrix3x2dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8576 void ecb_glUniformMatrix3x2dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8577 {
8578 GLint location;
8579 GLsizei count;
8580 GLboolean transpose;
8581 GLdouble *value;
8582 if(!enif_get_int(env, argv[0], &location)) Badarg(5645,"location");
8583 if(!enif_get_int(env, argv[1], &count)) Badarg(5645,"count");
8584 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5645,"transpose");
8585 if(!enif_is_list(env, argv[3])) { Badarg(5645,"value")}
8586 int value_a;
8587 const ERL_NIF_TERM *value_tpl;
8588 ERL_NIF_TERM value_l, value_h, value_t;
8589 std::vector <GLdouble> value_vec (6*count);
8590 GLdouble *value_ptr = value_vec.data();
8591 value_l = argv[3];
8592 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
8593 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 6) Badarg(5645,"value");
8594 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5645,"value");
8595 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5645,"value");
8596 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5645,"value");
8597 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5645,"value");
8598 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5645,"value");
8599 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5645,"value");
8600 value_l = value_t;
8601 };
8602 value = value_vec.data();
8603 weglUniformMatrix3x2dv(location,count,transpose,value);
8604 }
8605
ecb_glUniformMatrix3x4dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8606 void ecb_glUniformMatrix3x4dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8607 {
8608 GLint location;
8609 GLsizei count;
8610 GLboolean transpose;
8611 GLdouble *value;
8612 if(!enif_get_int(env, argv[0], &location)) Badarg(5646,"location");
8613 if(!enif_get_int(env, argv[1], &count)) Badarg(5646,"count");
8614 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5646,"transpose");
8615 if(!enif_is_list(env, argv[3])) { Badarg(5646,"value")}
8616 int value_a;
8617 const ERL_NIF_TERM *value_tpl;
8618 ERL_NIF_TERM value_l, value_h, value_t;
8619 std::vector <GLdouble> value_vec (12*count);
8620 GLdouble *value_ptr = value_vec.data();
8621 value_l = argv[3];
8622 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
8623 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 12) Badarg(5646,"value");
8624 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5646,"value");
8625 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5646,"value");
8626 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5646,"value");
8627 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5646,"value");
8628 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5646,"value");
8629 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5646,"value");
8630 if(!enif_get_double(env, value_tpl[6], value_ptr++)) Badarg(5646,"value");
8631 if(!enif_get_double(env, value_tpl[7], value_ptr++)) Badarg(5646,"value");
8632 if(!enif_get_double(env, value_tpl[8], value_ptr++)) Badarg(5646,"value");
8633 if(!enif_get_double(env, value_tpl[9], value_ptr++)) Badarg(5646,"value");
8634 if(!enif_get_double(env, value_tpl[10], value_ptr++)) Badarg(5646,"value");
8635 if(!enif_get_double(env, value_tpl[11], value_ptr++)) Badarg(5646,"value");
8636 value_l = value_t;
8637 };
8638 value = value_vec.data();
8639 weglUniformMatrix3x4dv(location,count,transpose,value);
8640 }
8641
ecb_glUniformMatrix4x2dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8642 void ecb_glUniformMatrix4x2dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8643 {
8644 GLint location;
8645 GLsizei count;
8646 GLboolean transpose;
8647 GLdouble *value;
8648 if(!enif_get_int(env, argv[0], &location)) Badarg(5647,"location");
8649 if(!enif_get_int(env, argv[1], &count)) Badarg(5647,"count");
8650 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5647,"transpose");
8651 if(!enif_is_list(env, argv[3])) { Badarg(5647,"value")}
8652 int value_a;
8653 const ERL_NIF_TERM *value_tpl;
8654 ERL_NIF_TERM value_l, value_h, value_t;
8655 std::vector <GLdouble> value_vec (8*count);
8656 GLdouble *value_ptr = value_vec.data();
8657 value_l = argv[3];
8658 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
8659 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 8) Badarg(5647,"value");
8660 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5647,"value");
8661 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5647,"value");
8662 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5647,"value");
8663 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5647,"value");
8664 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5647,"value");
8665 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5647,"value");
8666 if(!enif_get_double(env, value_tpl[6], value_ptr++)) Badarg(5647,"value");
8667 if(!enif_get_double(env, value_tpl[7], value_ptr++)) Badarg(5647,"value");
8668 value_l = value_t;
8669 };
8670 value = value_vec.data();
8671 weglUniformMatrix4x2dv(location,count,transpose,value);
8672 }
8673
ecb_glUniformMatrix4x3dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8674 void ecb_glUniformMatrix4x3dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8675 {
8676 GLint location;
8677 GLsizei count;
8678 GLboolean transpose;
8679 GLdouble *value;
8680 if(!enif_get_int(env, argv[0], &location)) Badarg(5648,"location");
8681 if(!enif_get_int(env, argv[1], &count)) Badarg(5648,"count");
8682 if(!egl_get_ubyte(env, argv[2], &transpose)) Badarg(5648,"transpose");
8683 if(!enif_is_list(env, argv[3])) { Badarg(5648,"value")}
8684 int value_a;
8685 const ERL_NIF_TERM *value_tpl;
8686 ERL_NIF_TERM value_l, value_h, value_t;
8687 std::vector <GLdouble> value_vec (12*count);
8688 GLdouble *value_ptr = value_vec.data();
8689 value_l = argv[3];
8690 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
8691 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 12) Badarg(5648,"value");
8692 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5648,"value");
8693 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5648,"value");
8694 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5648,"value");
8695 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5648,"value");
8696 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5648,"value");
8697 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5648,"value");
8698 if(!enif_get_double(env, value_tpl[6], value_ptr++)) Badarg(5648,"value");
8699 if(!enif_get_double(env, value_tpl[7], value_ptr++)) Badarg(5648,"value");
8700 if(!enif_get_double(env, value_tpl[8], value_ptr++)) Badarg(5648,"value");
8701 if(!enif_get_double(env, value_tpl[9], value_ptr++)) Badarg(5648,"value");
8702 if(!enif_get_double(env, value_tpl[10], value_ptr++)) Badarg(5648,"value");
8703 if(!enif_get_double(env, value_tpl[11], value_ptr++)) Badarg(5648,"value");
8704 value_l = value_t;
8705 };
8706 value = value_vec.data();
8707 weglUniformMatrix4x3dv(location,count,transpose,value);
8708 }
8709
ecb_glGetUniformdv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8710 void ecb_glGetUniformdv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8711 {
8712 ERL_NIF_TERM reply;
8713 GLuint program;
8714 GLint location;
8715 GLdouble params[16];
8716 ERL_NIF_TERM params_ts[16];
8717 if(!enif_get_uint(env, argv[0], &program)) Badarg(5649,"program");
8718 if(!enif_get_int(env, argv[1], &location)) Badarg(5649,"location");
8719 weglGetUniformdv(program,location,params);
8720 for(int ri=0; ri < (int) 16; ri++)
8721 params_ts[ri] = enif_make_double(env, params[ri]);
8722 reply = enif_make_tuple_from_array(env, params_ts, 16);
8723 enif_send(NULL, self, env,
8724 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8725 }
8726
ecb_glGetSubroutineUniformLocation(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8727 void ecb_glGetSubroutineUniformLocation(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8728 {
8729 GLint result;
8730 ERL_NIF_TERM reply;
8731 GLuint program;
8732 GLenum shadertype;
8733 ErlNifBinary name;
8734 if(!enif_get_uint(env, argv[0], &program)) Badarg(5650,"program");
8735 if(!enif_get_uint(env, argv[1], &shadertype)) Badarg(5650,"shadertype");
8736 if(!enif_inspect_binary(env, argv[2], &name)) Badarg(5650,"name");
8737 result = weglGetSubroutineUniformLocation(program,shadertype,(GLchar *) name.data);
8738 reply = enif_make_int(env, result);
8739 enif_send(NULL, self, env,
8740 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8741 }
8742
ecb_glGetSubroutineIndex(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8743 void ecb_glGetSubroutineIndex(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8744 {
8745 GLuint result;
8746 ERL_NIF_TERM reply;
8747 GLuint program;
8748 GLenum shadertype;
8749 ErlNifBinary name;
8750 if(!enif_get_uint(env, argv[0], &program)) Badarg(5651,"program");
8751 if(!enif_get_uint(env, argv[1], &shadertype)) Badarg(5651,"shadertype");
8752 if(!enif_inspect_binary(env, argv[2], &name)) Badarg(5651,"name");
8753 result = weglGetSubroutineIndex(program,shadertype,(GLchar *) name.data);
8754 reply = enif_make_int(env, result);
8755 enif_send(NULL, self, env,
8756 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8757 }
8758
ecb_glGetActiveSubroutineUniformName(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8759 void ecb_glGetActiveSubroutineUniformName(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8760 {
8761 ERL_NIF_TERM reply;
8762 GLuint program;
8763 GLenum shadertype;
8764 GLuint index;
8765 GLsizei bufsize;
8766 GLsizei length;
8767 unsigned char *name;
8768 if(!enif_get_uint(env, argv[0], &program)) Badarg(5652,"program");
8769 if(!enif_get_uint(env, argv[1], &shadertype)) Badarg(5652,"shadertype");
8770 if(!enif_get_uint(env, argv[2], &index)) Badarg(5652,"index");
8771 if(!enif_get_int(env, argv[3], &bufsize)) Badarg(5652,"bufsize");
8772 name = (unsigned char *) enif_alloc((int) bufsize*sizeof(GLchar));
8773 weglGetActiveSubroutineUniformName(program,shadertype,index,bufsize,&length,(GLchar *) name);
8774 reply = enif_make_string(env, (const char *) name, ERL_NIF_LATIN1);
8775 enif_send(NULL, self, env,
8776 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8777 enif_free(name);
8778 }
8779
ecb_glGetActiveSubroutineName(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8780 void ecb_glGetActiveSubroutineName(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8781 {
8782 ERL_NIF_TERM reply;
8783 GLuint program;
8784 GLenum shadertype;
8785 GLuint index;
8786 GLsizei bufsize;
8787 GLsizei length;
8788 unsigned char *name;
8789 if(!enif_get_uint(env, argv[0], &program)) Badarg(5653,"program");
8790 if(!enif_get_uint(env, argv[1], &shadertype)) Badarg(5653,"shadertype");
8791 if(!enif_get_uint(env, argv[2], &index)) Badarg(5653,"index");
8792 if(!enif_get_int(env, argv[3], &bufsize)) Badarg(5653,"bufsize");
8793 name = (unsigned char *) enif_alloc((int) bufsize*sizeof(GLchar));
8794 weglGetActiveSubroutineName(program,shadertype,index,bufsize,&length,(GLchar *) name);
8795 reply = enif_make_string(env, (const char *) name, ERL_NIF_LATIN1);
8796 enif_send(NULL, self, env,
8797 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8798 enif_free(name);
8799 }
8800
ecb_glUniformSubroutinesuiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8801 void ecb_glUniformSubroutinesuiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8802 {
8803 GLenum shadertype;
8804 GLsizei count;
8805 GLuint *indices;
8806 if(!enif_get_uint(env, argv[0], &shadertype)) Badarg(5654,"shadertype");
8807 if(!enif_get_int(env, argv[1], &count)) Badarg(5654,"count");
8808 if(!enif_is_list(env, argv[2])) Badarg(5654, "indices")
8809 else {
8810 ERL_NIF_TERM indices_l, indices_h, indices_t;
8811 std::vector <GLuint> indices_vec;
8812 GLuint indices_tmp;
8813 indices_l = argv[2];
8814 while(enif_get_list_cell(env, indices_l, &indices_h, &indices_t)) {
8815 if(!enif_get_uint(env, indices_h, &indices_tmp)) Badarg(5654,"indices");
8816 indices_vec.push_back(indices_tmp);
8817 indices_l = indices_t;
8818 };
8819 indices = indices_vec.data();
8820 }
8821 weglUniformSubroutinesuiv(shadertype,count,indices);
8822 }
8823
ecb_glGetUniformSubroutineuiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8824 void ecb_glGetUniformSubroutineuiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8825 {
8826 ERL_NIF_TERM reply;
8827 GLenum shadertype;
8828 GLint location;
8829 GLuint params[16];
8830 ERL_NIF_TERM params_ts[16];
8831 if(!enif_get_uint(env, argv[0], &shadertype)) Badarg(5655,"shadertype");
8832 if(!enif_get_int(env, argv[1], &location)) Badarg(5655,"location");
8833 weglGetUniformSubroutineuiv(shadertype,location,params);
8834 for(int ri=0; ri < (int) 16; ri++)
8835 params_ts[ri] = enif_make_int(env, params[ri]);
8836 reply = enif_make_tuple_from_array(env, params_ts, 16);
8837 enif_send(NULL, self, env,
8838 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8839 }
8840
ecb_glGetProgramStageiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8841 void ecb_glGetProgramStageiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8842 {
8843 ERL_NIF_TERM reply;
8844 GLuint program;
8845 GLenum shadertype;
8846 GLenum pname;
8847 GLint values;
8848 if(!enif_get_uint(env, argv[0], &program)) Badarg(5656,"program");
8849 if(!enif_get_uint(env, argv[1], &shadertype)) Badarg(5656,"shadertype");
8850 if(!enif_get_uint(env, argv[2], &pname)) Badarg(5656,"pname");
8851 weglGetProgramStageiv(program,shadertype,pname,&values);
8852 reply = enif_make_int(env, values);
8853 enif_send(NULL, self, env,
8854 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8855 }
8856
ecb_glPatchParameteri(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8857 void ecb_glPatchParameteri(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8858 {
8859 GLenum pname;
8860 GLint value;
8861 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5657,"pname");
8862 if(!enif_get_int(env, argv[1], &value)) Badarg(5657,"value");
8863 weglPatchParameteri(pname,value);
8864 }
8865
ecb_glPatchParameterfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8866 void ecb_glPatchParameterfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8867 {
8868 GLenum pname;
8869 GLfloat *values;
8870 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5658,"pname");
8871 if(!enif_is_list(env, argv[1])) Badarg(5658, "values")
8872 else {
8873 ERL_NIF_TERM values_l, values_h, values_t;
8874 std::vector <GLfloat> values_vec;
8875 GLfloat values_tmp;
8876 values_l = argv[1];
8877 while(enif_get_list_cell(env, values_l, &values_h, &values_t)) {
8878 if(!egl_get_float(env, values_h, &values_tmp)) Badarg(5658,"values");
8879 values_vec.push_back(values_tmp);
8880 values_l = values_t;
8881 };
8882 values = values_vec.data();
8883 }
8884 weglPatchParameterfv(pname,values);
8885 }
8886
ecb_glBindTransformFeedback(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8887 void ecb_glBindTransformFeedback(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8888 {
8889 GLenum target;
8890 GLuint id;
8891 if(!enif_get_uint(env, argv[0], &target)) Badarg(5659,"target");
8892 if(!enif_get_uint(env, argv[1], &id)) Badarg(5659,"id");
8893 weglBindTransformFeedback(target,id);
8894 }
8895
ecb_glDeleteTransformFeedbacks(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8896 void ecb_glDeleteTransformFeedbacks(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8897 {
8898 GLsizei n;
8899 GLuint *ids;
8900 if(!enif_get_int(env, argv[0], &n)) Badarg(5660,"n");
8901 if(!enif_is_list(env, argv[1])) Badarg(5660, "ids")
8902 else {
8903 ERL_NIF_TERM ids_l, ids_h, ids_t;
8904 std::vector <GLuint> ids_vec;
8905 GLuint ids_tmp;
8906 ids_l = argv[1];
8907 while(enif_get_list_cell(env, ids_l, &ids_h, &ids_t)) {
8908 if(!enif_get_uint(env, ids_h, &ids_tmp)) Badarg(5660,"ids");
8909 ids_vec.push_back(ids_tmp);
8910 ids_l = ids_t;
8911 };
8912 ids = ids_vec.data();
8913 }
8914 weglDeleteTransformFeedbacks(n,ids);
8915 }
8916
ecb_glGenTransformFeedbacks(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8917 void ecb_glGenTransformFeedbacks(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8918 {
8919 ERL_NIF_TERM reply;
8920 GLsizei n;
8921 if(!enif_get_int(env, argv[0], &n)) Badarg(5661,"n");
8922 std::vector <GLuint> ids (n);
8923 std::vector <ERL_NIF_TERM> ids_ts (n);
8924 weglGenTransformFeedbacks(n,ids.data());
8925 for(int ri=0; ri < (int) n; ri++)
8926 ids_ts[ri] = enif_make_int(env, ids[ri]);
8927 reply = enif_make_list_from_array(env, ids_ts.data(), n);
8928 enif_send(NULL, self, env,
8929 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8930 }
8931
ecb_glIsTransformFeedback(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8932 void ecb_glIsTransformFeedback(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8933 {
8934 GLboolean result;
8935 ERL_NIF_TERM reply;
8936 GLuint id;
8937 if(!enif_get_uint(env, argv[0], &id)) Badarg(5662,"id");
8938 result = weglIsTransformFeedback(id);
8939 reply = enif_make_int(env, result);
8940 enif_send(NULL, self, env,
8941 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
8942 }
8943
ecb_glPauseTransformFeedback(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8944 void ecb_glPauseTransformFeedback(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8945 {
8946 weglPauseTransformFeedback();
8947 }
8948
ecb_glResumeTransformFeedback(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8949 void ecb_glResumeTransformFeedback(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8950 {
8951 weglResumeTransformFeedback();
8952 }
8953
ecb_glDrawTransformFeedback(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8954 void ecb_glDrawTransformFeedback(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8955 {
8956 GLenum mode;
8957 GLuint id;
8958 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5665,"mode");
8959 if(!enif_get_uint(env, argv[1], &id)) Badarg(5665,"id");
8960 weglDrawTransformFeedback(mode,id);
8961 }
8962
ecb_glDrawTransformFeedbackStream(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8963 void ecb_glDrawTransformFeedbackStream(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8964 {
8965 GLenum mode;
8966 GLuint id;
8967 GLuint stream;
8968 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5666,"mode");
8969 if(!enif_get_uint(env, argv[1], &id)) Badarg(5666,"id");
8970 if(!enif_get_uint(env, argv[2], &stream)) Badarg(5666,"stream");
8971 weglDrawTransformFeedbackStream(mode,id,stream);
8972 }
8973
ecb_glBeginQueryIndexed(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8974 void ecb_glBeginQueryIndexed(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8975 {
8976 GLenum target;
8977 GLuint index;
8978 GLuint id;
8979 if(!enif_get_uint(env, argv[0], &target)) Badarg(5667,"target");
8980 if(!enif_get_uint(env, argv[1], &index)) Badarg(5667,"index");
8981 if(!enif_get_uint(env, argv[2], &id)) Badarg(5667,"id");
8982 weglBeginQueryIndexed(target,index,id);
8983 }
8984
ecb_glEndQueryIndexed(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8985 void ecb_glEndQueryIndexed(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8986 {
8987 GLenum target;
8988 GLuint index;
8989 if(!enif_get_uint(env, argv[0], &target)) Badarg(5668,"target");
8990 if(!enif_get_uint(env, argv[1], &index)) Badarg(5668,"index");
8991 weglEndQueryIndexed(target,index);
8992 }
8993
ecb_glGetQueryIndexediv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])8994 void ecb_glGetQueryIndexediv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
8995 {
8996 ERL_NIF_TERM reply;
8997 GLenum target;
8998 GLuint index;
8999 GLenum pname;
9000 GLint params;
9001 if(!enif_get_uint(env, argv[0], &target)) Badarg(5669,"target");
9002 if(!enif_get_uint(env, argv[1], &index)) Badarg(5669,"index");
9003 if(!enif_get_uint(env, argv[2], &pname)) Badarg(5669,"pname");
9004 weglGetQueryIndexediv(target,index,pname,¶ms);
9005 reply = enif_make_int(env, params);
9006 enif_send(NULL, self, env,
9007 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
9008 }
9009
ecb_glReleaseShaderCompiler(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9010 void ecb_glReleaseShaderCompiler(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9011 {
9012 weglReleaseShaderCompiler();
9013 }
9014
ecb_glShaderBinary(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9015 void ecb_glShaderBinary(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9016 {
9017 GLsizei count;
9018 GLuint *shaders;
9019 GLenum binaryformat;
9020 ErlNifBinary binary;
9021 if(!enif_get_int(env, argv[0], &count)) Badarg(5671,"count");
9022 if(!enif_is_list(env, argv[1])) Badarg(5671, "shaders")
9023 else {
9024 ERL_NIF_TERM shaders_l, shaders_h, shaders_t;
9025 std::vector <GLuint> shaders_vec;
9026 GLuint shaders_tmp;
9027 shaders_l = argv[1];
9028 while(enif_get_list_cell(env, shaders_l, &shaders_h, &shaders_t)) {
9029 if(!enif_get_uint(env, shaders_h, &shaders_tmp)) Badarg(5671,"shaders");
9030 shaders_vec.push_back(shaders_tmp);
9031 shaders_l = shaders_t;
9032 };
9033 shaders = shaders_vec.data();
9034 }
9035 if(!enif_get_uint(env, argv[2], &binaryformat)) Badarg(5671,"binaryformat");
9036 if(!enif_inspect_binary(env, argv[3], &binary)) Badarg(5671,"binary");
9037 weglShaderBinary(count,shaders,binaryformat,(void *) binary.data,(GLsizei) binary.size);
9038 }
9039
ecb_glGetShaderPrecisionFormat(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9040 void ecb_glGetShaderPrecisionFormat(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9041 {
9042 ERL_NIF_TERM reply;
9043 GLenum shadertype;
9044 GLenum precisiontype;
9045 GLint range[2];
9046 GLint precision;
9047 if(!enif_get_uint(env, argv[0], &shadertype)) Badarg(5672,"shadertype");
9048 if(!enif_get_uint(env, argv[1], &precisiontype)) Badarg(5672,"precisiontype");
9049 weglGetShaderPrecisionFormat(shadertype,precisiontype,range,&precision);
9050 reply = enif_make_tuple2(env,
9051 enif_make_tuple2(env,
9052 enif_make_int(env, range[0]),
9053 enif_make_int(env, range[1])),
9054 enif_make_int(env, precision) );
9055 enif_send(NULL, self, env,
9056 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
9057 }
9058
ecb_glDepthRangef(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9059 void ecb_glDepthRangef(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9060 {
9061 GLfloat n;
9062 GLfloat f;
9063 if(!egl_get_float(env, argv[0], &n)) Badarg(5673,"n");
9064 if(!egl_get_float(env, argv[1], &f)) Badarg(5673,"f");
9065 weglDepthRangef(n,f);
9066 }
9067
ecb_glClearDepthf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9068 void ecb_glClearDepthf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9069 {
9070 GLfloat d;
9071 if(!egl_get_float(env, argv[0], &d)) Badarg(5674,"d");
9072 weglClearDepthf(d);
9073 }
9074
ecb_glGetProgramBinary(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9075 void ecb_glGetProgramBinary(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9076 {
9077 ERL_NIF_TERM reply;
9078 GLuint program;
9079 GLsizei bufSize;
9080 GLsizei length;
9081 GLenum binaryFormat;
9082 ErlNifBinary binary;
9083 if(!enif_get_uint(env, argv[0], &program)) Badarg(5675,"program");
9084 if(!enif_get_int(env, argv[1], &bufSize)) Badarg(5675,"bufSize");
9085 enif_alloc_binary((int) bufSize*sizeof(char), &binary);
9086 weglGetProgramBinary(program,bufSize,&length,&binaryFormat,(void *) binary.data);
9087 reply = enif_make_tuple2(env,
9088 enif_make_int(env, binaryFormat),
9089 enif_make_binary(env, &binary) );
9090 enif_send(NULL, self, env,
9091 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
9092 }
9093
ecb_glProgramBinary(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9094 void ecb_glProgramBinary(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9095 {
9096 GLuint program;
9097 GLenum binaryFormat;
9098 ErlNifBinary binary;
9099 if(!enif_get_uint(env, argv[0], &program)) Badarg(5676,"program");
9100 if(!enif_get_uint(env, argv[1], &binaryFormat)) Badarg(5676,"binaryFormat");
9101 if(!enif_inspect_binary(env, argv[2], &binary)) Badarg(5676,"binary");
9102 weglProgramBinary(program,binaryFormat,(void *) binary.data,(GLsizei) binary.size);
9103 }
9104
ecb_glProgramParameteri(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9105 void ecb_glProgramParameteri(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9106 {
9107 GLuint program;
9108 GLenum pname;
9109 GLint value;
9110 if(!enif_get_uint(env, argv[0], &program)) Badarg(5677,"program");
9111 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5677,"pname");
9112 if(!enif_get_int(env, argv[2], &value)) Badarg(5677,"value");
9113 weglProgramParameteri(program,pname,value);
9114 }
9115
ecb_glUseProgramStages(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9116 void ecb_glUseProgramStages(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9117 {
9118 GLuint pipeline;
9119 GLbitfield stages;
9120 GLuint program;
9121 if(!enif_get_uint(env, argv[0], &pipeline)) Badarg(5678,"pipeline");
9122 if(!enif_get_uint(env, argv[1], &stages)) Badarg(5678,"stages");
9123 if(!enif_get_uint(env, argv[2], &program)) Badarg(5678,"program");
9124 weglUseProgramStages(pipeline,stages,program);
9125 }
9126
ecb_glActiveShaderProgram(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9127 void ecb_glActiveShaderProgram(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9128 {
9129 GLuint pipeline;
9130 GLuint program;
9131 if(!enif_get_uint(env, argv[0], &pipeline)) Badarg(5679,"pipeline");
9132 if(!enif_get_uint(env, argv[1], &program)) Badarg(5679,"program");
9133 weglActiveShaderProgram(pipeline,program);
9134 }
9135
ecb_glCreateShaderProgramv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9136 void ecb_glCreateShaderProgramv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9137 {
9138 GLuint result;
9139 ERL_NIF_TERM reply;
9140 GLenum type;
9141 GLsizei count;
9142 if(!enif_get_uint(env, argv[0], &type)) Badarg(5680,"type");
9143 if(!enif_get_int(env, argv[1], &count)) Badarg(5680,"count");
9144 ERL_NIF_TERM strings_l, strings_h, strings_t;
9145 ErlNifBinary strings_tmp;
9146 std::vector <GLchar *> strings;
9147 strings_l = argv[2];
9148 while(enif_get_list_cell(env, strings_l, &strings_h, &strings_t)) {
9149 if(!enif_inspect_binary(env, strings_h, &strings_tmp)) Badarg(5680,"strings");
9150 strings.push_back((GLchar *) strings_tmp.data);
9151 strings_l = strings_t;
9152 }
9153 result = weglCreateShaderProgramv(type,count,(const GLchar **) strings.data());
9154 reply = enif_make_int(env, result);
9155 enif_send(NULL, self, env,
9156 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
9157 }
9158
ecb_glBindProgramPipeline(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9159 void ecb_glBindProgramPipeline(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9160 {
9161 GLuint pipeline;
9162 if(!enif_get_uint(env, argv[0], &pipeline)) Badarg(5681,"pipeline");
9163 weglBindProgramPipeline(pipeline);
9164 }
9165
ecb_glDeleteProgramPipelines(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9166 void ecb_glDeleteProgramPipelines(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9167 {
9168 GLsizei n;
9169 GLuint *pipelines;
9170 if(!enif_get_int(env, argv[0], &n)) Badarg(5682,"n");
9171 if(!enif_is_list(env, argv[1])) Badarg(5682, "pipelines")
9172 else {
9173 ERL_NIF_TERM pipelines_l, pipelines_h, pipelines_t;
9174 std::vector <GLuint> pipelines_vec;
9175 GLuint pipelines_tmp;
9176 pipelines_l = argv[1];
9177 while(enif_get_list_cell(env, pipelines_l, &pipelines_h, &pipelines_t)) {
9178 if(!enif_get_uint(env, pipelines_h, &pipelines_tmp)) Badarg(5682,"pipelines");
9179 pipelines_vec.push_back(pipelines_tmp);
9180 pipelines_l = pipelines_t;
9181 };
9182 pipelines = pipelines_vec.data();
9183 }
9184 weglDeleteProgramPipelines(n,pipelines);
9185 }
9186
ecb_glGenProgramPipelines(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9187 void ecb_glGenProgramPipelines(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9188 {
9189 ERL_NIF_TERM reply;
9190 GLsizei n;
9191 if(!enif_get_int(env, argv[0], &n)) Badarg(5683,"n");
9192 std::vector <GLuint> pipelines (n);
9193 std::vector <ERL_NIF_TERM> pipelines_ts (n);
9194 weglGenProgramPipelines(n,pipelines.data());
9195 for(int ri=0; ri < (int) n; ri++)
9196 pipelines_ts[ri] = enif_make_int(env, pipelines[ri]);
9197 reply = enif_make_list_from_array(env, pipelines_ts.data(), n);
9198 enif_send(NULL, self, env,
9199 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
9200 }
9201
ecb_glIsProgramPipeline(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9202 void ecb_glIsProgramPipeline(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9203 {
9204 GLboolean result;
9205 ERL_NIF_TERM reply;
9206 GLuint pipeline;
9207 if(!enif_get_uint(env, argv[0], &pipeline)) Badarg(5684,"pipeline");
9208 result = weglIsProgramPipeline(pipeline);
9209 reply = enif_make_int(env, result);
9210 enif_send(NULL, self, env,
9211 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
9212 }
9213
ecb_glGetProgramPipelineiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9214 void ecb_glGetProgramPipelineiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9215 {
9216 ERL_NIF_TERM reply;
9217 GLuint pipeline;
9218 GLenum pname;
9219 GLint params;
9220 if(!enif_get_uint(env, argv[0], &pipeline)) Badarg(5685,"pipeline");
9221 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5685,"pname");
9222 weglGetProgramPipelineiv(pipeline,pname,¶ms);
9223 reply = enif_make_int(env, params);
9224 enif_send(NULL, self, env,
9225 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
9226 }
9227
ecb_glProgramUniform1i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9228 void ecb_glProgramUniform1i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9229 {
9230 GLuint program;
9231 GLint location;
9232 GLint v0;
9233 if(!enif_get_uint(env, argv[0], &program)) Badarg(5686,"program");
9234 if(!enif_get_int(env, argv[1], &location)) Badarg(5686,"location");
9235 if(!enif_get_int(env, argv[2], &v0)) Badarg(5686,"v0");
9236 weglProgramUniform1i(program,location,v0);
9237 }
9238
ecb_glProgramUniform1iv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9239 void ecb_glProgramUniform1iv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9240 {
9241 GLuint program;
9242 GLint location;
9243 GLsizei count;
9244 GLint *value;
9245 if(!enif_get_uint(env, argv[0], &program)) Badarg(5687,"program");
9246 if(!enif_get_int(env, argv[1], &location)) Badarg(5687,"location");
9247 if(!enif_get_int(env, argv[2], &count)) Badarg(5687,"count");
9248 if(!enif_is_list(env, argv[3])) Badarg(5687, "value")
9249 else {
9250 ERL_NIF_TERM value_l, value_h, value_t;
9251 std::vector <GLint> value_vec;
9252 GLint value_tmp;
9253 value_l = argv[3];
9254 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9255 if(!enif_get_int(env, value_h, &value_tmp)) Badarg(5687,"value");
9256 value_vec.push_back(value_tmp);
9257 value_l = value_t;
9258 };
9259 value = value_vec.data();
9260 }
9261 weglProgramUniform1iv(program,location,count,value);
9262 }
9263
ecb_glProgramUniform1f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9264 void ecb_glProgramUniform1f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9265 {
9266 GLuint program;
9267 GLint location;
9268 GLfloat v0;
9269 if(!enif_get_uint(env, argv[0], &program)) Badarg(5688,"program");
9270 if(!enif_get_int(env, argv[1], &location)) Badarg(5688,"location");
9271 if(!egl_get_float(env, argv[2], &v0)) Badarg(5688,"v0");
9272 weglProgramUniform1f(program,location,v0);
9273 }
9274
ecb_glProgramUniform1fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9275 void ecb_glProgramUniform1fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9276 {
9277 GLuint program;
9278 GLint location;
9279 GLsizei count;
9280 GLfloat *value;
9281 if(!enif_get_uint(env, argv[0], &program)) Badarg(5689,"program");
9282 if(!enif_get_int(env, argv[1], &location)) Badarg(5689,"location");
9283 if(!enif_get_int(env, argv[2], &count)) Badarg(5689,"count");
9284 if(!enif_is_list(env, argv[3])) Badarg(5689, "value")
9285 else {
9286 ERL_NIF_TERM value_l, value_h, value_t;
9287 std::vector <GLfloat> value_vec;
9288 GLfloat value_tmp;
9289 value_l = argv[3];
9290 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9291 if(!egl_get_float(env, value_h, &value_tmp)) Badarg(5689,"value");
9292 value_vec.push_back(value_tmp);
9293 value_l = value_t;
9294 };
9295 value = value_vec.data();
9296 }
9297 weglProgramUniform1fv(program,location,count,value);
9298 }
9299
ecb_glProgramUniform1d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9300 void ecb_glProgramUniform1d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9301 {
9302 GLuint program;
9303 GLint location;
9304 GLdouble v0;
9305 if(!enif_get_uint(env, argv[0], &program)) Badarg(5690,"program");
9306 if(!enif_get_int(env, argv[1], &location)) Badarg(5690,"location");
9307 if(!enif_get_double(env, argv[2], &v0)) Badarg(5690,"v0");
9308 weglProgramUniform1d(program,location,v0);
9309 }
9310
ecb_glProgramUniform1dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9311 void ecb_glProgramUniform1dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9312 {
9313 GLuint program;
9314 GLint location;
9315 GLsizei count;
9316 GLdouble *value;
9317 if(!enif_get_uint(env, argv[0], &program)) Badarg(5691,"program");
9318 if(!enif_get_int(env, argv[1], &location)) Badarg(5691,"location");
9319 if(!enif_get_int(env, argv[2], &count)) Badarg(5691,"count");
9320 if(!enif_is_list(env, argv[3])) Badarg(5691, "value")
9321 else {
9322 ERL_NIF_TERM value_l, value_h, value_t;
9323 std::vector <GLdouble> value_vec;
9324 GLdouble value_tmp;
9325 value_l = argv[3];
9326 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9327 if(!enif_get_double(env, value_h, &value_tmp)) Badarg(5691,"value");
9328 value_vec.push_back(value_tmp);
9329 value_l = value_t;
9330 };
9331 value = value_vec.data();
9332 }
9333 weglProgramUniform1dv(program,location,count,value);
9334 }
9335
ecb_glProgramUniform1ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9336 void ecb_glProgramUniform1ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9337 {
9338 GLuint program;
9339 GLint location;
9340 GLuint v0;
9341 if(!enif_get_uint(env, argv[0], &program)) Badarg(5692,"program");
9342 if(!enif_get_int(env, argv[1], &location)) Badarg(5692,"location");
9343 if(!enif_get_uint(env, argv[2], &v0)) Badarg(5692,"v0");
9344 weglProgramUniform1ui(program,location,v0);
9345 }
9346
ecb_glProgramUniform1uiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9347 void ecb_glProgramUniform1uiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9348 {
9349 GLuint program;
9350 GLint location;
9351 GLsizei count;
9352 GLuint *value;
9353 if(!enif_get_uint(env, argv[0], &program)) Badarg(5693,"program");
9354 if(!enif_get_int(env, argv[1], &location)) Badarg(5693,"location");
9355 if(!enif_get_int(env, argv[2], &count)) Badarg(5693,"count");
9356 if(!enif_is_list(env, argv[3])) Badarg(5693, "value")
9357 else {
9358 ERL_NIF_TERM value_l, value_h, value_t;
9359 std::vector <GLuint> value_vec;
9360 GLuint value_tmp;
9361 value_l = argv[3];
9362 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9363 if(!enif_get_uint(env, value_h, &value_tmp)) Badarg(5693,"value");
9364 value_vec.push_back(value_tmp);
9365 value_l = value_t;
9366 };
9367 value = value_vec.data();
9368 }
9369 weglProgramUniform1uiv(program,location,count,value);
9370 }
9371
ecb_glProgramUniform2i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9372 void ecb_glProgramUniform2i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9373 {
9374 GLuint program;
9375 GLint location;
9376 GLint v0;
9377 GLint v1;
9378 if(!enif_get_uint(env, argv[0], &program)) Badarg(5694,"program");
9379 if(!enif_get_int(env, argv[1], &location)) Badarg(5694,"location");
9380 if(!enif_get_int(env, argv[2], &v0)) Badarg(5694,"v0");
9381 if(!enif_get_int(env, argv[3], &v1)) Badarg(5694,"v1");
9382 weglProgramUniform2i(program,location,v0,v1);
9383 }
9384
ecb_glProgramUniform2iv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9385 void ecb_glProgramUniform2iv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9386 {
9387 GLuint program;
9388 GLint location;
9389 GLsizei count;
9390 GLint *value;
9391 if(!enif_get_uint(env, argv[0], &program)) Badarg(5695,"program");
9392 if(!enif_get_int(env, argv[1], &location)) Badarg(5695,"location");
9393 if(!enif_get_int(env, argv[2], &count)) Badarg(5695,"count");
9394 if(!enif_is_list(env, argv[3])) { Badarg(5695,"value")}
9395 int value_a;
9396 const ERL_NIF_TERM *value_tpl;
9397 ERL_NIF_TERM value_l, value_h, value_t;
9398 std::vector <GLint> value_vec (2*count);
9399 GLint *value_ptr = value_vec.data();
9400 value_l = argv[3];
9401 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9402 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 2) Badarg(5695,"value");
9403 if(!enif_get_int(env, value_tpl[0], value_ptr++)) Badarg(5695,"value");
9404 if(!enif_get_int(env, value_tpl[1], value_ptr++)) Badarg(5695,"value");
9405 value_l = value_t;
9406 };
9407 value = value_vec.data();
9408 weglProgramUniform2iv(program,location,count,value);
9409 }
9410
ecb_glProgramUniform2f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9411 void ecb_glProgramUniform2f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9412 {
9413 GLuint program;
9414 GLint location;
9415 GLfloat v0;
9416 GLfloat v1;
9417 if(!enif_get_uint(env, argv[0], &program)) Badarg(5696,"program");
9418 if(!enif_get_int(env, argv[1], &location)) Badarg(5696,"location");
9419 if(!egl_get_float(env, argv[2], &v0)) Badarg(5696,"v0");
9420 if(!egl_get_float(env, argv[3], &v1)) Badarg(5696,"v1");
9421 weglProgramUniform2f(program,location,v0,v1);
9422 }
9423
ecb_glProgramUniform2fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9424 void ecb_glProgramUniform2fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9425 {
9426 GLuint program;
9427 GLint location;
9428 GLsizei count;
9429 GLfloat *value;
9430 if(!enif_get_uint(env, argv[0], &program)) Badarg(5697,"program");
9431 if(!enif_get_int(env, argv[1], &location)) Badarg(5697,"location");
9432 if(!enif_get_int(env, argv[2], &count)) Badarg(5697,"count");
9433 if(!enif_is_list(env, argv[3])) { Badarg(5697,"value")}
9434 int value_a;
9435 const ERL_NIF_TERM *value_tpl;
9436 ERL_NIF_TERM value_l, value_h, value_t;
9437 std::vector <GLfloat> value_vec (2*count);
9438 GLfloat *value_ptr = value_vec.data();
9439 value_l = argv[3];
9440 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9441 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 2) Badarg(5697,"value");
9442 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5697,"value");
9443 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5697,"value");
9444 value_l = value_t;
9445 };
9446 value = value_vec.data();
9447 weglProgramUniform2fv(program,location,count,value);
9448 }
9449
ecb_glProgramUniform2d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9450 void ecb_glProgramUniform2d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9451 {
9452 GLuint program;
9453 GLint location;
9454 GLdouble v0;
9455 GLdouble v1;
9456 if(!enif_get_uint(env, argv[0], &program)) Badarg(5698,"program");
9457 if(!enif_get_int(env, argv[1], &location)) Badarg(5698,"location");
9458 if(!enif_get_double(env, argv[2], &v0)) Badarg(5698,"v0");
9459 if(!enif_get_double(env, argv[3], &v1)) Badarg(5698,"v1");
9460 weglProgramUniform2d(program,location,v0,v1);
9461 }
9462
ecb_glProgramUniform2dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9463 void ecb_glProgramUniform2dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9464 {
9465 GLuint program;
9466 GLint location;
9467 GLsizei count;
9468 GLdouble *value;
9469 if(!enif_get_uint(env, argv[0], &program)) Badarg(5699,"program");
9470 if(!enif_get_int(env, argv[1], &location)) Badarg(5699,"location");
9471 if(!enif_get_int(env, argv[2], &count)) Badarg(5699,"count");
9472 if(!enif_is_list(env, argv[3])) { Badarg(5699,"value")}
9473 int value_a;
9474 const ERL_NIF_TERM *value_tpl;
9475 ERL_NIF_TERM value_l, value_h, value_t;
9476 std::vector <GLdouble> value_vec (2*count);
9477 GLdouble *value_ptr = value_vec.data();
9478 value_l = argv[3];
9479 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9480 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 2) Badarg(5699,"value");
9481 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5699,"value");
9482 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5699,"value");
9483 value_l = value_t;
9484 };
9485 value = value_vec.data();
9486 weglProgramUniform2dv(program,location,count,value);
9487 }
9488
ecb_glProgramUniform2ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9489 void ecb_glProgramUniform2ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9490 {
9491 GLuint program;
9492 GLint location;
9493 GLuint v0;
9494 GLuint v1;
9495 if(!enif_get_uint(env, argv[0], &program)) Badarg(5700,"program");
9496 if(!enif_get_int(env, argv[1], &location)) Badarg(5700,"location");
9497 if(!enif_get_uint(env, argv[2], &v0)) Badarg(5700,"v0");
9498 if(!enif_get_uint(env, argv[3], &v1)) Badarg(5700,"v1");
9499 weglProgramUniform2ui(program,location,v0,v1);
9500 }
9501
ecb_glProgramUniform2uiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9502 void ecb_glProgramUniform2uiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9503 {
9504 GLuint program;
9505 GLint location;
9506 GLsizei count;
9507 GLuint *value;
9508 if(!enif_get_uint(env, argv[0], &program)) Badarg(5701,"program");
9509 if(!enif_get_int(env, argv[1], &location)) Badarg(5701,"location");
9510 if(!enif_get_int(env, argv[2], &count)) Badarg(5701,"count");
9511 if(!enif_is_list(env, argv[3])) { Badarg(5701,"value")}
9512 int value_a;
9513 const ERL_NIF_TERM *value_tpl;
9514 ERL_NIF_TERM value_l, value_h, value_t;
9515 std::vector <GLuint> value_vec (2*count);
9516 GLuint *value_ptr = value_vec.data();
9517 value_l = argv[3];
9518 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9519 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 2) Badarg(5701,"value");
9520 if(!enif_get_uint(env, value_tpl[0], value_ptr++)) Badarg(5701,"value");
9521 if(!enif_get_uint(env, value_tpl[1], value_ptr++)) Badarg(5701,"value");
9522 value_l = value_t;
9523 };
9524 value = value_vec.data();
9525 weglProgramUniform2uiv(program,location,count,value);
9526 }
9527
ecb_glProgramUniform3i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9528 void ecb_glProgramUniform3i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9529 {
9530 GLuint program;
9531 GLint location;
9532 GLint v0;
9533 GLint v1;
9534 GLint v2;
9535 if(!enif_get_uint(env, argv[0], &program)) Badarg(5702,"program");
9536 if(!enif_get_int(env, argv[1], &location)) Badarg(5702,"location");
9537 if(!enif_get_int(env, argv[2], &v0)) Badarg(5702,"v0");
9538 if(!enif_get_int(env, argv[3], &v1)) Badarg(5702,"v1");
9539 if(!enif_get_int(env, argv[4], &v2)) Badarg(5702,"v2");
9540 weglProgramUniform3i(program,location,v0,v1,v2);
9541 }
9542
ecb_glProgramUniform3iv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9543 void ecb_glProgramUniform3iv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9544 {
9545 GLuint program;
9546 GLint location;
9547 GLsizei count;
9548 GLint *value;
9549 if(!enif_get_uint(env, argv[0], &program)) Badarg(5703,"program");
9550 if(!enif_get_int(env, argv[1], &location)) Badarg(5703,"location");
9551 if(!enif_get_int(env, argv[2], &count)) Badarg(5703,"count");
9552 if(!enif_is_list(env, argv[3])) { Badarg(5703,"value")}
9553 int value_a;
9554 const ERL_NIF_TERM *value_tpl;
9555 ERL_NIF_TERM value_l, value_h, value_t;
9556 std::vector <GLint> value_vec (3*count);
9557 GLint *value_ptr = value_vec.data();
9558 value_l = argv[3];
9559 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9560 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 3) Badarg(5703,"value");
9561 if(!enif_get_int(env, value_tpl[0], value_ptr++)) Badarg(5703,"value");
9562 if(!enif_get_int(env, value_tpl[1], value_ptr++)) Badarg(5703,"value");
9563 if(!enif_get_int(env, value_tpl[2], value_ptr++)) Badarg(5703,"value");
9564 value_l = value_t;
9565 };
9566 value = value_vec.data();
9567 weglProgramUniform3iv(program,location,count,value);
9568 }
9569
ecb_glProgramUniform3f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9570 void ecb_glProgramUniform3f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9571 {
9572 GLuint program;
9573 GLint location;
9574 GLfloat v0;
9575 GLfloat v1;
9576 GLfloat v2;
9577 if(!enif_get_uint(env, argv[0], &program)) Badarg(5704,"program");
9578 if(!enif_get_int(env, argv[1], &location)) Badarg(5704,"location");
9579 if(!egl_get_float(env, argv[2], &v0)) Badarg(5704,"v0");
9580 if(!egl_get_float(env, argv[3], &v1)) Badarg(5704,"v1");
9581 if(!egl_get_float(env, argv[4], &v2)) Badarg(5704,"v2");
9582 weglProgramUniform3f(program,location,v0,v1,v2);
9583 }
9584
ecb_glProgramUniform3fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9585 void ecb_glProgramUniform3fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9586 {
9587 GLuint program;
9588 GLint location;
9589 GLsizei count;
9590 GLfloat *value;
9591 if(!enif_get_uint(env, argv[0], &program)) Badarg(5705,"program");
9592 if(!enif_get_int(env, argv[1], &location)) Badarg(5705,"location");
9593 if(!enif_get_int(env, argv[2], &count)) Badarg(5705,"count");
9594 if(!enif_is_list(env, argv[3])) { Badarg(5705,"value")}
9595 int value_a;
9596 const ERL_NIF_TERM *value_tpl;
9597 ERL_NIF_TERM value_l, value_h, value_t;
9598 std::vector <GLfloat> value_vec (3*count);
9599 GLfloat *value_ptr = value_vec.data();
9600 value_l = argv[3];
9601 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9602 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 3) Badarg(5705,"value");
9603 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5705,"value");
9604 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5705,"value");
9605 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5705,"value");
9606 value_l = value_t;
9607 };
9608 value = value_vec.data();
9609 weglProgramUniform3fv(program,location,count,value);
9610 }
9611
ecb_glProgramUniform3d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9612 void ecb_glProgramUniform3d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9613 {
9614 GLuint program;
9615 GLint location;
9616 GLdouble v0;
9617 GLdouble v1;
9618 GLdouble v2;
9619 if(!enif_get_uint(env, argv[0], &program)) Badarg(5706,"program");
9620 if(!enif_get_int(env, argv[1], &location)) Badarg(5706,"location");
9621 if(!enif_get_double(env, argv[2], &v0)) Badarg(5706,"v0");
9622 if(!enif_get_double(env, argv[3], &v1)) Badarg(5706,"v1");
9623 if(!enif_get_double(env, argv[4], &v2)) Badarg(5706,"v2");
9624 weglProgramUniform3d(program,location,v0,v1,v2);
9625 }
9626
ecb_glProgramUniform3dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9627 void ecb_glProgramUniform3dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9628 {
9629 GLuint program;
9630 GLint location;
9631 GLsizei count;
9632 GLdouble *value;
9633 if(!enif_get_uint(env, argv[0], &program)) Badarg(5707,"program");
9634 if(!enif_get_int(env, argv[1], &location)) Badarg(5707,"location");
9635 if(!enif_get_int(env, argv[2], &count)) Badarg(5707,"count");
9636 if(!enif_is_list(env, argv[3])) { Badarg(5707,"value")}
9637 int value_a;
9638 const ERL_NIF_TERM *value_tpl;
9639 ERL_NIF_TERM value_l, value_h, value_t;
9640 std::vector <GLdouble> value_vec (3*count);
9641 GLdouble *value_ptr = value_vec.data();
9642 value_l = argv[3];
9643 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9644 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 3) Badarg(5707,"value");
9645 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5707,"value");
9646 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5707,"value");
9647 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5707,"value");
9648 value_l = value_t;
9649 };
9650 value = value_vec.data();
9651 weglProgramUniform3dv(program,location,count,value);
9652 }
9653
ecb_glProgramUniform3ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9654 void ecb_glProgramUniform3ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9655 {
9656 GLuint program;
9657 GLint location;
9658 GLuint v0;
9659 GLuint v1;
9660 GLuint v2;
9661 if(!enif_get_uint(env, argv[0], &program)) Badarg(5708,"program");
9662 if(!enif_get_int(env, argv[1], &location)) Badarg(5708,"location");
9663 if(!enif_get_uint(env, argv[2], &v0)) Badarg(5708,"v0");
9664 if(!enif_get_uint(env, argv[3], &v1)) Badarg(5708,"v1");
9665 if(!enif_get_uint(env, argv[4], &v2)) Badarg(5708,"v2");
9666 weglProgramUniform3ui(program,location,v0,v1,v2);
9667 }
9668
ecb_glProgramUniform3uiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9669 void ecb_glProgramUniform3uiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9670 {
9671 GLuint program;
9672 GLint location;
9673 GLsizei count;
9674 GLuint *value;
9675 if(!enif_get_uint(env, argv[0], &program)) Badarg(5709,"program");
9676 if(!enif_get_int(env, argv[1], &location)) Badarg(5709,"location");
9677 if(!enif_get_int(env, argv[2], &count)) Badarg(5709,"count");
9678 if(!enif_is_list(env, argv[3])) { Badarg(5709,"value")}
9679 int value_a;
9680 const ERL_NIF_TERM *value_tpl;
9681 ERL_NIF_TERM value_l, value_h, value_t;
9682 std::vector <GLuint> value_vec (3*count);
9683 GLuint *value_ptr = value_vec.data();
9684 value_l = argv[3];
9685 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9686 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 3) Badarg(5709,"value");
9687 if(!enif_get_uint(env, value_tpl[0], value_ptr++)) Badarg(5709,"value");
9688 if(!enif_get_uint(env, value_tpl[1], value_ptr++)) Badarg(5709,"value");
9689 if(!enif_get_uint(env, value_tpl[2], value_ptr++)) Badarg(5709,"value");
9690 value_l = value_t;
9691 };
9692 value = value_vec.data();
9693 weglProgramUniform3uiv(program,location,count,value);
9694 }
9695
ecb_glProgramUniform4i(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9696 void ecb_glProgramUniform4i(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9697 {
9698 GLuint program;
9699 GLint location;
9700 GLint v0;
9701 GLint v1;
9702 GLint v2;
9703 GLint v3;
9704 if(!enif_get_uint(env, argv[0], &program)) Badarg(5710,"program");
9705 if(!enif_get_int(env, argv[1], &location)) Badarg(5710,"location");
9706 if(!enif_get_int(env, argv[2], &v0)) Badarg(5710,"v0");
9707 if(!enif_get_int(env, argv[3], &v1)) Badarg(5710,"v1");
9708 if(!enif_get_int(env, argv[4], &v2)) Badarg(5710,"v2");
9709 if(!enif_get_int(env, argv[5], &v3)) Badarg(5710,"v3");
9710 weglProgramUniform4i(program,location,v0,v1,v2,v3);
9711 }
9712
ecb_glProgramUniform4iv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9713 void ecb_glProgramUniform4iv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9714 {
9715 GLuint program;
9716 GLint location;
9717 GLsizei count;
9718 GLint *value;
9719 if(!enif_get_uint(env, argv[0], &program)) Badarg(5711,"program");
9720 if(!enif_get_int(env, argv[1], &location)) Badarg(5711,"location");
9721 if(!enif_get_int(env, argv[2], &count)) Badarg(5711,"count");
9722 if(!enif_is_list(env, argv[3])) { Badarg(5711,"value")}
9723 int value_a;
9724 const ERL_NIF_TERM *value_tpl;
9725 ERL_NIF_TERM value_l, value_h, value_t;
9726 std::vector <GLint> value_vec (4*count);
9727 GLint *value_ptr = value_vec.data();
9728 value_l = argv[3];
9729 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9730 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5711,"value");
9731 if(!enif_get_int(env, value_tpl[0], value_ptr++)) Badarg(5711,"value");
9732 if(!enif_get_int(env, value_tpl[1], value_ptr++)) Badarg(5711,"value");
9733 if(!enif_get_int(env, value_tpl[2], value_ptr++)) Badarg(5711,"value");
9734 if(!enif_get_int(env, value_tpl[3], value_ptr++)) Badarg(5711,"value");
9735 value_l = value_t;
9736 };
9737 value = value_vec.data();
9738 weglProgramUniform4iv(program,location,count,value);
9739 }
9740
ecb_glProgramUniform4f(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9741 void ecb_glProgramUniform4f(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9742 {
9743 GLuint program;
9744 GLint location;
9745 GLfloat v0;
9746 GLfloat v1;
9747 GLfloat v2;
9748 GLfloat v3;
9749 if(!enif_get_uint(env, argv[0], &program)) Badarg(5712,"program");
9750 if(!enif_get_int(env, argv[1], &location)) Badarg(5712,"location");
9751 if(!egl_get_float(env, argv[2], &v0)) Badarg(5712,"v0");
9752 if(!egl_get_float(env, argv[3], &v1)) Badarg(5712,"v1");
9753 if(!egl_get_float(env, argv[4], &v2)) Badarg(5712,"v2");
9754 if(!egl_get_float(env, argv[5], &v3)) Badarg(5712,"v3");
9755 weglProgramUniform4f(program,location,v0,v1,v2,v3);
9756 }
9757
ecb_glProgramUniform4fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9758 void ecb_glProgramUniform4fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9759 {
9760 GLuint program;
9761 GLint location;
9762 GLsizei count;
9763 GLfloat *value;
9764 if(!enif_get_uint(env, argv[0], &program)) Badarg(5713,"program");
9765 if(!enif_get_int(env, argv[1], &location)) Badarg(5713,"location");
9766 if(!enif_get_int(env, argv[2], &count)) Badarg(5713,"count");
9767 if(!enif_is_list(env, argv[3])) { Badarg(5713,"value")}
9768 int value_a;
9769 const ERL_NIF_TERM *value_tpl;
9770 ERL_NIF_TERM value_l, value_h, value_t;
9771 std::vector <GLfloat> value_vec (4*count);
9772 GLfloat *value_ptr = value_vec.data();
9773 value_l = argv[3];
9774 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9775 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5713,"value");
9776 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5713,"value");
9777 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5713,"value");
9778 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5713,"value");
9779 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5713,"value");
9780 value_l = value_t;
9781 };
9782 value = value_vec.data();
9783 weglProgramUniform4fv(program,location,count,value);
9784 }
9785
ecb_glProgramUniform4d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9786 void ecb_glProgramUniform4d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9787 {
9788 GLuint program;
9789 GLint location;
9790 GLdouble v0;
9791 GLdouble v1;
9792 GLdouble v2;
9793 GLdouble v3;
9794 if(!enif_get_uint(env, argv[0], &program)) Badarg(5714,"program");
9795 if(!enif_get_int(env, argv[1], &location)) Badarg(5714,"location");
9796 if(!enif_get_double(env, argv[2], &v0)) Badarg(5714,"v0");
9797 if(!enif_get_double(env, argv[3], &v1)) Badarg(5714,"v1");
9798 if(!enif_get_double(env, argv[4], &v2)) Badarg(5714,"v2");
9799 if(!enif_get_double(env, argv[5], &v3)) Badarg(5714,"v3");
9800 weglProgramUniform4d(program,location,v0,v1,v2,v3);
9801 }
9802
ecb_glProgramUniform4dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9803 void ecb_glProgramUniform4dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9804 {
9805 GLuint program;
9806 GLint location;
9807 GLsizei count;
9808 GLdouble *value;
9809 if(!enif_get_uint(env, argv[0], &program)) Badarg(5715,"program");
9810 if(!enif_get_int(env, argv[1], &location)) Badarg(5715,"location");
9811 if(!enif_get_int(env, argv[2], &count)) Badarg(5715,"count");
9812 if(!enif_is_list(env, argv[3])) { Badarg(5715,"value")}
9813 int value_a;
9814 const ERL_NIF_TERM *value_tpl;
9815 ERL_NIF_TERM value_l, value_h, value_t;
9816 std::vector <GLdouble> value_vec (4*count);
9817 GLdouble *value_ptr = value_vec.data();
9818 value_l = argv[3];
9819 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9820 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5715,"value");
9821 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5715,"value");
9822 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5715,"value");
9823 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5715,"value");
9824 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5715,"value");
9825 value_l = value_t;
9826 };
9827 value = value_vec.data();
9828 weglProgramUniform4dv(program,location,count,value);
9829 }
9830
ecb_glProgramUniform4ui(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9831 void ecb_glProgramUniform4ui(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9832 {
9833 GLuint program;
9834 GLint location;
9835 GLuint v0;
9836 GLuint v1;
9837 GLuint v2;
9838 GLuint v3;
9839 if(!enif_get_uint(env, argv[0], &program)) Badarg(5716,"program");
9840 if(!enif_get_int(env, argv[1], &location)) Badarg(5716,"location");
9841 if(!enif_get_uint(env, argv[2], &v0)) Badarg(5716,"v0");
9842 if(!enif_get_uint(env, argv[3], &v1)) Badarg(5716,"v1");
9843 if(!enif_get_uint(env, argv[4], &v2)) Badarg(5716,"v2");
9844 if(!enif_get_uint(env, argv[5], &v3)) Badarg(5716,"v3");
9845 weglProgramUniform4ui(program,location,v0,v1,v2,v3);
9846 }
9847
ecb_glProgramUniform4uiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9848 void ecb_glProgramUniform4uiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9849 {
9850 GLuint program;
9851 GLint location;
9852 GLsizei count;
9853 GLuint *value;
9854 if(!enif_get_uint(env, argv[0], &program)) Badarg(5717,"program");
9855 if(!enif_get_int(env, argv[1], &location)) Badarg(5717,"location");
9856 if(!enif_get_int(env, argv[2], &count)) Badarg(5717,"count");
9857 if(!enif_is_list(env, argv[3])) { Badarg(5717,"value")}
9858 int value_a;
9859 const ERL_NIF_TERM *value_tpl;
9860 ERL_NIF_TERM value_l, value_h, value_t;
9861 std::vector <GLuint> value_vec (4*count);
9862 GLuint *value_ptr = value_vec.data();
9863 value_l = argv[3];
9864 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9865 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5717,"value");
9866 if(!enif_get_uint(env, value_tpl[0], value_ptr++)) Badarg(5717,"value");
9867 if(!enif_get_uint(env, value_tpl[1], value_ptr++)) Badarg(5717,"value");
9868 if(!enif_get_uint(env, value_tpl[2], value_ptr++)) Badarg(5717,"value");
9869 if(!enif_get_uint(env, value_tpl[3], value_ptr++)) Badarg(5717,"value");
9870 value_l = value_t;
9871 };
9872 value = value_vec.data();
9873 weglProgramUniform4uiv(program,location,count,value);
9874 }
9875
ecb_glProgramUniformMatrix2fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9876 void ecb_glProgramUniformMatrix2fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9877 {
9878 GLuint program;
9879 GLint location;
9880 GLsizei count;
9881 GLboolean transpose;
9882 GLfloat *value;
9883 if(!enif_get_uint(env, argv[0], &program)) Badarg(5718,"program");
9884 if(!enif_get_int(env, argv[1], &location)) Badarg(5718,"location");
9885 if(!enif_get_int(env, argv[2], &count)) Badarg(5718,"count");
9886 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5718,"transpose");
9887 if(!enif_is_list(env, argv[4])) { Badarg(5718,"value")}
9888 int value_a;
9889 const ERL_NIF_TERM *value_tpl;
9890 ERL_NIF_TERM value_l, value_h, value_t;
9891 std::vector <GLfloat> value_vec (4*count);
9892 GLfloat *value_ptr = value_vec.data();
9893 value_l = argv[4];
9894 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9895 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5718,"value");
9896 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5718,"value");
9897 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5718,"value");
9898 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5718,"value");
9899 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5718,"value");
9900 value_l = value_t;
9901 };
9902 value = value_vec.data();
9903 weglProgramUniformMatrix2fv(program,location,count,transpose,value);
9904 }
9905
ecb_glProgramUniformMatrix3fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9906 void ecb_glProgramUniformMatrix3fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9907 {
9908 GLuint program;
9909 GLint location;
9910 GLsizei count;
9911 GLboolean transpose;
9912 GLfloat *value;
9913 if(!enif_get_uint(env, argv[0], &program)) Badarg(5719,"program");
9914 if(!enif_get_int(env, argv[1], &location)) Badarg(5719,"location");
9915 if(!enif_get_int(env, argv[2], &count)) Badarg(5719,"count");
9916 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5719,"transpose");
9917 if(!enif_is_list(env, argv[4])) { Badarg(5719,"value")}
9918 int value_a;
9919 const ERL_NIF_TERM *value_tpl;
9920 ERL_NIF_TERM value_l, value_h, value_t;
9921 std::vector <GLfloat> value_vec (9*count);
9922 GLfloat *value_ptr = value_vec.data();
9923 value_l = argv[4];
9924 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9925 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 9) Badarg(5719,"value");
9926 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5719,"value");
9927 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5719,"value");
9928 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5719,"value");
9929 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5719,"value");
9930 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5719,"value");
9931 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5719,"value");
9932 if(!egl_get_float(env, value_tpl[6], value_ptr++)) Badarg(5719,"value");
9933 if(!egl_get_float(env, value_tpl[7], value_ptr++)) Badarg(5719,"value");
9934 if(!egl_get_float(env, value_tpl[8], value_ptr++)) Badarg(5719,"value");
9935 value_l = value_t;
9936 };
9937 value = value_vec.data();
9938 weglProgramUniformMatrix3fv(program,location,count,transpose,value);
9939 }
9940
ecb_glProgramUniformMatrix4fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9941 void ecb_glProgramUniformMatrix4fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9942 {
9943 GLuint program;
9944 GLint location;
9945 GLsizei count;
9946 GLboolean transpose;
9947 GLfloat *value;
9948 if(!enif_get_uint(env, argv[0], &program)) Badarg(5720,"program");
9949 if(!enif_get_int(env, argv[1], &location)) Badarg(5720,"location");
9950 if(!enif_get_int(env, argv[2], &count)) Badarg(5720,"count");
9951 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5720,"transpose");
9952 if(!enif_is_list(env, argv[4])) { Badarg(5720,"value")}
9953 int value_a;
9954 const ERL_NIF_TERM *value_tpl;
9955 ERL_NIF_TERM value_l, value_h, value_t;
9956 std::vector <GLfloat> value_vec (16*count);
9957 GLfloat *value_ptr = value_vec.data();
9958 value_l = argv[4];
9959 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
9960 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 16) Badarg(5720,"value");
9961 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5720,"value");
9962 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5720,"value");
9963 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5720,"value");
9964 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5720,"value");
9965 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5720,"value");
9966 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5720,"value");
9967 if(!egl_get_float(env, value_tpl[6], value_ptr++)) Badarg(5720,"value");
9968 if(!egl_get_float(env, value_tpl[7], value_ptr++)) Badarg(5720,"value");
9969 if(!egl_get_float(env, value_tpl[8], value_ptr++)) Badarg(5720,"value");
9970 if(!egl_get_float(env, value_tpl[9], value_ptr++)) Badarg(5720,"value");
9971 if(!egl_get_float(env, value_tpl[10], value_ptr++)) Badarg(5720,"value");
9972 if(!egl_get_float(env, value_tpl[11], value_ptr++)) Badarg(5720,"value");
9973 if(!egl_get_float(env, value_tpl[12], value_ptr++)) Badarg(5720,"value");
9974 if(!egl_get_float(env, value_tpl[13], value_ptr++)) Badarg(5720,"value");
9975 if(!egl_get_float(env, value_tpl[14], value_ptr++)) Badarg(5720,"value");
9976 if(!egl_get_float(env, value_tpl[15], value_ptr++)) Badarg(5720,"value");
9977 value_l = value_t;
9978 };
9979 value = value_vec.data();
9980 weglProgramUniformMatrix4fv(program,location,count,transpose,value);
9981 }
9982
ecb_glProgramUniformMatrix2dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])9983 void ecb_glProgramUniformMatrix2dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
9984 {
9985 GLuint program;
9986 GLint location;
9987 GLsizei count;
9988 GLboolean transpose;
9989 GLdouble *value;
9990 if(!enif_get_uint(env, argv[0], &program)) Badarg(5721,"program");
9991 if(!enif_get_int(env, argv[1], &location)) Badarg(5721,"location");
9992 if(!enif_get_int(env, argv[2], &count)) Badarg(5721,"count");
9993 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5721,"transpose");
9994 if(!enif_is_list(env, argv[4])) { Badarg(5721,"value")}
9995 int value_a;
9996 const ERL_NIF_TERM *value_tpl;
9997 ERL_NIF_TERM value_l, value_h, value_t;
9998 std::vector <GLdouble> value_vec (4*count);
9999 GLdouble *value_ptr = value_vec.data();
10000 value_l = argv[4];
10001 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10002 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5721,"value");
10003 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5721,"value");
10004 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5721,"value");
10005 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5721,"value");
10006 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5721,"value");
10007 value_l = value_t;
10008 };
10009 value = value_vec.data();
10010 weglProgramUniformMatrix2dv(program,location,count,transpose,value);
10011 }
10012
ecb_glProgramUniformMatrix3dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10013 void ecb_glProgramUniformMatrix3dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10014 {
10015 GLuint program;
10016 GLint location;
10017 GLsizei count;
10018 GLboolean transpose;
10019 GLdouble *value;
10020 if(!enif_get_uint(env, argv[0], &program)) Badarg(5722,"program");
10021 if(!enif_get_int(env, argv[1], &location)) Badarg(5722,"location");
10022 if(!enif_get_int(env, argv[2], &count)) Badarg(5722,"count");
10023 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5722,"transpose");
10024 if(!enif_is_list(env, argv[4])) { Badarg(5722,"value")}
10025 int value_a;
10026 const ERL_NIF_TERM *value_tpl;
10027 ERL_NIF_TERM value_l, value_h, value_t;
10028 std::vector <GLdouble> value_vec (9*count);
10029 GLdouble *value_ptr = value_vec.data();
10030 value_l = argv[4];
10031 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10032 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 9) Badarg(5722,"value");
10033 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5722,"value");
10034 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5722,"value");
10035 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5722,"value");
10036 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5722,"value");
10037 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5722,"value");
10038 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5722,"value");
10039 if(!enif_get_double(env, value_tpl[6], value_ptr++)) Badarg(5722,"value");
10040 if(!enif_get_double(env, value_tpl[7], value_ptr++)) Badarg(5722,"value");
10041 if(!enif_get_double(env, value_tpl[8], value_ptr++)) Badarg(5722,"value");
10042 value_l = value_t;
10043 };
10044 value = value_vec.data();
10045 weglProgramUniformMatrix3dv(program,location,count,transpose,value);
10046 }
10047
ecb_glProgramUniformMatrix4dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10048 void ecb_glProgramUniformMatrix4dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10049 {
10050 GLuint program;
10051 GLint location;
10052 GLsizei count;
10053 GLboolean transpose;
10054 GLdouble *value;
10055 if(!enif_get_uint(env, argv[0], &program)) Badarg(5723,"program");
10056 if(!enif_get_int(env, argv[1], &location)) Badarg(5723,"location");
10057 if(!enif_get_int(env, argv[2], &count)) Badarg(5723,"count");
10058 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5723,"transpose");
10059 if(!enif_is_list(env, argv[4])) { Badarg(5723,"value")}
10060 int value_a;
10061 const ERL_NIF_TERM *value_tpl;
10062 ERL_NIF_TERM value_l, value_h, value_t;
10063 std::vector <GLdouble> value_vec (16*count);
10064 GLdouble *value_ptr = value_vec.data();
10065 value_l = argv[4];
10066 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10067 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 16) Badarg(5723,"value");
10068 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5723,"value");
10069 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5723,"value");
10070 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5723,"value");
10071 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5723,"value");
10072 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5723,"value");
10073 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5723,"value");
10074 if(!enif_get_double(env, value_tpl[6], value_ptr++)) Badarg(5723,"value");
10075 if(!enif_get_double(env, value_tpl[7], value_ptr++)) Badarg(5723,"value");
10076 if(!enif_get_double(env, value_tpl[8], value_ptr++)) Badarg(5723,"value");
10077 if(!enif_get_double(env, value_tpl[9], value_ptr++)) Badarg(5723,"value");
10078 if(!enif_get_double(env, value_tpl[10], value_ptr++)) Badarg(5723,"value");
10079 if(!enif_get_double(env, value_tpl[11], value_ptr++)) Badarg(5723,"value");
10080 if(!enif_get_double(env, value_tpl[12], value_ptr++)) Badarg(5723,"value");
10081 if(!enif_get_double(env, value_tpl[13], value_ptr++)) Badarg(5723,"value");
10082 if(!enif_get_double(env, value_tpl[14], value_ptr++)) Badarg(5723,"value");
10083 if(!enif_get_double(env, value_tpl[15], value_ptr++)) Badarg(5723,"value");
10084 value_l = value_t;
10085 };
10086 value = value_vec.data();
10087 weglProgramUniformMatrix4dv(program,location,count,transpose,value);
10088 }
10089
ecb_glProgramUniformMatrix2x3fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10090 void ecb_glProgramUniformMatrix2x3fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10091 {
10092 GLuint program;
10093 GLint location;
10094 GLsizei count;
10095 GLboolean transpose;
10096 GLfloat *value;
10097 if(!enif_get_uint(env, argv[0], &program)) Badarg(5724,"program");
10098 if(!enif_get_int(env, argv[1], &location)) Badarg(5724,"location");
10099 if(!enif_get_int(env, argv[2], &count)) Badarg(5724,"count");
10100 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5724,"transpose");
10101 if(!enif_is_list(env, argv[4])) { Badarg(5724,"value")}
10102 int value_a;
10103 const ERL_NIF_TERM *value_tpl;
10104 ERL_NIF_TERM value_l, value_h, value_t;
10105 std::vector <GLfloat> value_vec (6*count);
10106 GLfloat *value_ptr = value_vec.data();
10107 value_l = argv[4];
10108 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10109 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 6) Badarg(5724,"value");
10110 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5724,"value");
10111 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5724,"value");
10112 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5724,"value");
10113 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5724,"value");
10114 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5724,"value");
10115 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5724,"value");
10116 value_l = value_t;
10117 };
10118 value = value_vec.data();
10119 weglProgramUniformMatrix2x3fv(program,location,count,transpose,value);
10120 }
10121
ecb_glProgramUniformMatrix3x2fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10122 void ecb_glProgramUniformMatrix3x2fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10123 {
10124 GLuint program;
10125 GLint location;
10126 GLsizei count;
10127 GLboolean transpose;
10128 GLfloat *value;
10129 if(!enif_get_uint(env, argv[0], &program)) Badarg(5725,"program");
10130 if(!enif_get_int(env, argv[1], &location)) Badarg(5725,"location");
10131 if(!enif_get_int(env, argv[2], &count)) Badarg(5725,"count");
10132 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5725,"transpose");
10133 if(!enif_is_list(env, argv[4])) { Badarg(5725,"value")}
10134 int value_a;
10135 const ERL_NIF_TERM *value_tpl;
10136 ERL_NIF_TERM value_l, value_h, value_t;
10137 std::vector <GLfloat> value_vec (6*count);
10138 GLfloat *value_ptr = value_vec.data();
10139 value_l = argv[4];
10140 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10141 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 6) Badarg(5725,"value");
10142 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5725,"value");
10143 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5725,"value");
10144 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5725,"value");
10145 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5725,"value");
10146 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5725,"value");
10147 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5725,"value");
10148 value_l = value_t;
10149 };
10150 value = value_vec.data();
10151 weglProgramUniformMatrix3x2fv(program,location,count,transpose,value);
10152 }
10153
ecb_glProgramUniformMatrix2x4fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10154 void ecb_glProgramUniformMatrix2x4fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10155 {
10156 GLuint program;
10157 GLint location;
10158 GLsizei count;
10159 GLboolean transpose;
10160 GLfloat *value;
10161 if(!enif_get_uint(env, argv[0], &program)) Badarg(5726,"program");
10162 if(!enif_get_int(env, argv[1], &location)) Badarg(5726,"location");
10163 if(!enif_get_int(env, argv[2], &count)) Badarg(5726,"count");
10164 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5726,"transpose");
10165 if(!enif_is_list(env, argv[4])) { Badarg(5726,"value")}
10166 int value_a;
10167 const ERL_NIF_TERM *value_tpl;
10168 ERL_NIF_TERM value_l, value_h, value_t;
10169 std::vector <GLfloat> value_vec (8*count);
10170 GLfloat *value_ptr = value_vec.data();
10171 value_l = argv[4];
10172 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10173 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 8) Badarg(5726,"value");
10174 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5726,"value");
10175 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5726,"value");
10176 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5726,"value");
10177 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5726,"value");
10178 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5726,"value");
10179 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5726,"value");
10180 if(!egl_get_float(env, value_tpl[6], value_ptr++)) Badarg(5726,"value");
10181 if(!egl_get_float(env, value_tpl[7], value_ptr++)) Badarg(5726,"value");
10182 value_l = value_t;
10183 };
10184 value = value_vec.data();
10185 weglProgramUniformMatrix2x4fv(program,location,count,transpose,value);
10186 }
10187
ecb_glProgramUniformMatrix4x2fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10188 void ecb_glProgramUniformMatrix4x2fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10189 {
10190 GLuint program;
10191 GLint location;
10192 GLsizei count;
10193 GLboolean transpose;
10194 GLfloat *value;
10195 if(!enif_get_uint(env, argv[0], &program)) Badarg(5727,"program");
10196 if(!enif_get_int(env, argv[1], &location)) Badarg(5727,"location");
10197 if(!enif_get_int(env, argv[2], &count)) Badarg(5727,"count");
10198 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5727,"transpose");
10199 if(!enif_is_list(env, argv[4])) { Badarg(5727,"value")}
10200 int value_a;
10201 const ERL_NIF_TERM *value_tpl;
10202 ERL_NIF_TERM value_l, value_h, value_t;
10203 std::vector <GLfloat> value_vec (8*count);
10204 GLfloat *value_ptr = value_vec.data();
10205 value_l = argv[4];
10206 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10207 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 8) Badarg(5727,"value");
10208 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5727,"value");
10209 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5727,"value");
10210 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5727,"value");
10211 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5727,"value");
10212 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5727,"value");
10213 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5727,"value");
10214 if(!egl_get_float(env, value_tpl[6], value_ptr++)) Badarg(5727,"value");
10215 if(!egl_get_float(env, value_tpl[7], value_ptr++)) Badarg(5727,"value");
10216 value_l = value_t;
10217 };
10218 value = value_vec.data();
10219 weglProgramUniformMatrix4x2fv(program,location,count,transpose,value);
10220 }
10221
ecb_glProgramUniformMatrix3x4fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10222 void ecb_glProgramUniformMatrix3x4fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10223 {
10224 GLuint program;
10225 GLint location;
10226 GLsizei count;
10227 GLboolean transpose;
10228 GLfloat *value;
10229 if(!enif_get_uint(env, argv[0], &program)) Badarg(5728,"program");
10230 if(!enif_get_int(env, argv[1], &location)) Badarg(5728,"location");
10231 if(!enif_get_int(env, argv[2], &count)) Badarg(5728,"count");
10232 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5728,"transpose");
10233 if(!enif_is_list(env, argv[4])) { Badarg(5728,"value")}
10234 int value_a;
10235 const ERL_NIF_TERM *value_tpl;
10236 ERL_NIF_TERM value_l, value_h, value_t;
10237 std::vector <GLfloat> value_vec (12*count);
10238 GLfloat *value_ptr = value_vec.data();
10239 value_l = argv[4];
10240 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10241 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 12) Badarg(5728,"value");
10242 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5728,"value");
10243 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5728,"value");
10244 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5728,"value");
10245 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5728,"value");
10246 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5728,"value");
10247 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5728,"value");
10248 if(!egl_get_float(env, value_tpl[6], value_ptr++)) Badarg(5728,"value");
10249 if(!egl_get_float(env, value_tpl[7], value_ptr++)) Badarg(5728,"value");
10250 if(!egl_get_float(env, value_tpl[8], value_ptr++)) Badarg(5728,"value");
10251 if(!egl_get_float(env, value_tpl[9], value_ptr++)) Badarg(5728,"value");
10252 if(!egl_get_float(env, value_tpl[10], value_ptr++)) Badarg(5728,"value");
10253 if(!egl_get_float(env, value_tpl[11], value_ptr++)) Badarg(5728,"value");
10254 value_l = value_t;
10255 };
10256 value = value_vec.data();
10257 weglProgramUniformMatrix3x4fv(program,location,count,transpose,value);
10258 }
10259
ecb_glProgramUniformMatrix4x3fv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10260 void ecb_glProgramUniformMatrix4x3fv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10261 {
10262 GLuint program;
10263 GLint location;
10264 GLsizei count;
10265 GLboolean transpose;
10266 GLfloat *value;
10267 if(!enif_get_uint(env, argv[0], &program)) Badarg(5729,"program");
10268 if(!enif_get_int(env, argv[1], &location)) Badarg(5729,"location");
10269 if(!enif_get_int(env, argv[2], &count)) Badarg(5729,"count");
10270 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5729,"transpose");
10271 if(!enif_is_list(env, argv[4])) { Badarg(5729,"value")}
10272 int value_a;
10273 const ERL_NIF_TERM *value_tpl;
10274 ERL_NIF_TERM value_l, value_h, value_t;
10275 std::vector <GLfloat> value_vec (12*count);
10276 GLfloat *value_ptr = value_vec.data();
10277 value_l = argv[4];
10278 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10279 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 12) Badarg(5729,"value");
10280 if(!egl_get_float(env, value_tpl[0], value_ptr++)) Badarg(5729,"value");
10281 if(!egl_get_float(env, value_tpl[1], value_ptr++)) Badarg(5729,"value");
10282 if(!egl_get_float(env, value_tpl[2], value_ptr++)) Badarg(5729,"value");
10283 if(!egl_get_float(env, value_tpl[3], value_ptr++)) Badarg(5729,"value");
10284 if(!egl_get_float(env, value_tpl[4], value_ptr++)) Badarg(5729,"value");
10285 if(!egl_get_float(env, value_tpl[5], value_ptr++)) Badarg(5729,"value");
10286 if(!egl_get_float(env, value_tpl[6], value_ptr++)) Badarg(5729,"value");
10287 if(!egl_get_float(env, value_tpl[7], value_ptr++)) Badarg(5729,"value");
10288 if(!egl_get_float(env, value_tpl[8], value_ptr++)) Badarg(5729,"value");
10289 if(!egl_get_float(env, value_tpl[9], value_ptr++)) Badarg(5729,"value");
10290 if(!egl_get_float(env, value_tpl[10], value_ptr++)) Badarg(5729,"value");
10291 if(!egl_get_float(env, value_tpl[11], value_ptr++)) Badarg(5729,"value");
10292 value_l = value_t;
10293 };
10294 value = value_vec.data();
10295 weglProgramUniformMatrix4x3fv(program,location,count,transpose,value);
10296 }
10297
ecb_glProgramUniformMatrix2x3dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10298 void ecb_glProgramUniformMatrix2x3dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10299 {
10300 GLuint program;
10301 GLint location;
10302 GLsizei count;
10303 GLboolean transpose;
10304 GLdouble *value;
10305 if(!enif_get_uint(env, argv[0], &program)) Badarg(5730,"program");
10306 if(!enif_get_int(env, argv[1], &location)) Badarg(5730,"location");
10307 if(!enif_get_int(env, argv[2], &count)) Badarg(5730,"count");
10308 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5730,"transpose");
10309 if(!enif_is_list(env, argv[4])) { Badarg(5730,"value")}
10310 int value_a;
10311 const ERL_NIF_TERM *value_tpl;
10312 ERL_NIF_TERM value_l, value_h, value_t;
10313 std::vector <GLdouble> value_vec (6*count);
10314 GLdouble *value_ptr = value_vec.data();
10315 value_l = argv[4];
10316 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10317 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 6) Badarg(5730,"value");
10318 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5730,"value");
10319 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5730,"value");
10320 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5730,"value");
10321 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5730,"value");
10322 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5730,"value");
10323 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5730,"value");
10324 value_l = value_t;
10325 };
10326 value = value_vec.data();
10327 weglProgramUniformMatrix2x3dv(program,location,count,transpose,value);
10328 }
10329
ecb_glProgramUniformMatrix3x2dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10330 void ecb_glProgramUniformMatrix3x2dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10331 {
10332 GLuint program;
10333 GLint location;
10334 GLsizei count;
10335 GLboolean transpose;
10336 GLdouble *value;
10337 if(!enif_get_uint(env, argv[0], &program)) Badarg(5731,"program");
10338 if(!enif_get_int(env, argv[1], &location)) Badarg(5731,"location");
10339 if(!enif_get_int(env, argv[2], &count)) Badarg(5731,"count");
10340 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5731,"transpose");
10341 if(!enif_is_list(env, argv[4])) { Badarg(5731,"value")}
10342 int value_a;
10343 const ERL_NIF_TERM *value_tpl;
10344 ERL_NIF_TERM value_l, value_h, value_t;
10345 std::vector <GLdouble> value_vec (6*count);
10346 GLdouble *value_ptr = value_vec.data();
10347 value_l = argv[4];
10348 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10349 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 6) Badarg(5731,"value");
10350 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5731,"value");
10351 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5731,"value");
10352 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5731,"value");
10353 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5731,"value");
10354 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5731,"value");
10355 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5731,"value");
10356 value_l = value_t;
10357 };
10358 value = value_vec.data();
10359 weglProgramUniformMatrix3x2dv(program,location,count,transpose,value);
10360 }
10361
ecb_glProgramUniformMatrix2x4dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10362 void ecb_glProgramUniformMatrix2x4dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10363 {
10364 GLuint program;
10365 GLint location;
10366 GLsizei count;
10367 GLboolean transpose;
10368 GLdouble *value;
10369 if(!enif_get_uint(env, argv[0], &program)) Badarg(5732,"program");
10370 if(!enif_get_int(env, argv[1], &location)) Badarg(5732,"location");
10371 if(!enif_get_int(env, argv[2], &count)) Badarg(5732,"count");
10372 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5732,"transpose");
10373 if(!enif_is_list(env, argv[4])) { Badarg(5732,"value")}
10374 int value_a;
10375 const ERL_NIF_TERM *value_tpl;
10376 ERL_NIF_TERM value_l, value_h, value_t;
10377 std::vector <GLdouble> value_vec (8*count);
10378 GLdouble *value_ptr = value_vec.data();
10379 value_l = argv[4];
10380 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10381 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 8) Badarg(5732,"value");
10382 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5732,"value");
10383 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5732,"value");
10384 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5732,"value");
10385 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5732,"value");
10386 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5732,"value");
10387 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5732,"value");
10388 if(!enif_get_double(env, value_tpl[6], value_ptr++)) Badarg(5732,"value");
10389 if(!enif_get_double(env, value_tpl[7], value_ptr++)) Badarg(5732,"value");
10390 value_l = value_t;
10391 };
10392 value = value_vec.data();
10393 weglProgramUniformMatrix2x4dv(program,location,count,transpose,value);
10394 }
10395
ecb_glProgramUniformMatrix4x2dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10396 void ecb_glProgramUniformMatrix4x2dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10397 {
10398 GLuint program;
10399 GLint location;
10400 GLsizei count;
10401 GLboolean transpose;
10402 GLdouble *value;
10403 if(!enif_get_uint(env, argv[0], &program)) Badarg(5733,"program");
10404 if(!enif_get_int(env, argv[1], &location)) Badarg(5733,"location");
10405 if(!enif_get_int(env, argv[2], &count)) Badarg(5733,"count");
10406 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5733,"transpose");
10407 if(!enif_is_list(env, argv[4])) { Badarg(5733,"value")}
10408 int value_a;
10409 const ERL_NIF_TERM *value_tpl;
10410 ERL_NIF_TERM value_l, value_h, value_t;
10411 std::vector <GLdouble> value_vec (8*count);
10412 GLdouble *value_ptr = value_vec.data();
10413 value_l = argv[4];
10414 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10415 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 8) Badarg(5733,"value");
10416 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5733,"value");
10417 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5733,"value");
10418 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5733,"value");
10419 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5733,"value");
10420 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5733,"value");
10421 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5733,"value");
10422 if(!enif_get_double(env, value_tpl[6], value_ptr++)) Badarg(5733,"value");
10423 if(!enif_get_double(env, value_tpl[7], value_ptr++)) Badarg(5733,"value");
10424 value_l = value_t;
10425 };
10426 value = value_vec.data();
10427 weglProgramUniformMatrix4x2dv(program,location,count,transpose,value);
10428 }
10429
ecb_glProgramUniformMatrix3x4dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10430 void ecb_glProgramUniformMatrix3x4dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10431 {
10432 GLuint program;
10433 GLint location;
10434 GLsizei count;
10435 GLboolean transpose;
10436 GLdouble *value;
10437 if(!enif_get_uint(env, argv[0], &program)) Badarg(5734,"program");
10438 if(!enif_get_int(env, argv[1], &location)) Badarg(5734,"location");
10439 if(!enif_get_int(env, argv[2], &count)) Badarg(5734,"count");
10440 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5734,"transpose");
10441 if(!enif_is_list(env, argv[4])) { Badarg(5734,"value")}
10442 int value_a;
10443 const ERL_NIF_TERM *value_tpl;
10444 ERL_NIF_TERM value_l, value_h, value_t;
10445 std::vector <GLdouble> value_vec (12*count);
10446 GLdouble *value_ptr = value_vec.data();
10447 value_l = argv[4];
10448 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10449 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 12) Badarg(5734,"value");
10450 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5734,"value");
10451 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5734,"value");
10452 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5734,"value");
10453 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5734,"value");
10454 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5734,"value");
10455 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5734,"value");
10456 if(!enif_get_double(env, value_tpl[6], value_ptr++)) Badarg(5734,"value");
10457 if(!enif_get_double(env, value_tpl[7], value_ptr++)) Badarg(5734,"value");
10458 if(!enif_get_double(env, value_tpl[8], value_ptr++)) Badarg(5734,"value");
10459 if(!enif_get_double(env, value_tpl[9], value_ptr++)) Badarg(5734,"value");
10460 if(!enif_get_double(env, value_tpl[10], value_ptr++)) Badarg(5734,"value");
10461 if(!enif_get_double(env, value_tpl[11], value_ptr++)) Badarg(5734,"value");
10462 value_l = value_t;
10463 };
10464 value = value_vec.data();
10465 weglProgramUniformMatrix3x4dv(program,location,count,transpose,value);
10466 }
10467
ecb_glProgramUniformMatrix4x3dv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10468 void ecb_glProgramUniformMatrix4x3dv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10469 {
10470 GLuint program;
10471 GLint location;
10472 GLsizei count;
10473 GLboolean transpose;
10474 GLdouble *value;
10475 if(!enif_get_uint(env, argv[0], &program)) Badarg(5735,"program");
10476 if(!enif_get_int(env, argv[1], &location)) Badarg(5735,"location");
10477 if(!enif_get_int(env, argv[2], &count)) Badarg(5735,"count");
10478 if(!egl_get_ubyte(env, argv[3], &transpose)) Badarg(5735,"transpose");
10479 if(!enif_is_list(env, argv[4])) { Badarg(5735,"value")}
10480 int value_a;
10481 const ERL_NIF_TERM *value_tpl;
10482 ERL_NIF_TERM value_l, value_h, value_t;
10483 std::vector <GLdouble> value_vec (12*count);
10484 GLdouble *value_ptr = value_vec.data();
10485 value_l = argv[4];
10486 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
10487 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 12) Badarg(5735,"value");
10488 if(!enif_get_double(env, value_tpl[0], value_ptr++)) Badarg(5735,"value");
10489 if(!enif_get_double(env, value_tpl[1], value_ptr++)) Badarg(5735,"value");
10490 if(!enif_get_double(env, value_tpl[2], value_ptr++)) Badarg(5735,"value");
10491 if(!enif_get_double(env, value_tpl[3], value_ptr++)) Badarg(5735,"value");
10492 if(!enif_get_double(env, value_tpl[4], value_ptr++)) Badarg(5735,"value");
10493 if(!enif_get_double(env, value_tpl[5], value_ptr++)) Badarg(5735,"value");
10494 if(!enif_get_double(env, value_tpl[6], value_ptr++)) Badarg(5735,"value");
10495 if(!enif_get_double(env, value_tpl[7], value_ptr++)) Badarg(5735,"value");
10496 if(!enif_get_double(env, value_tpl[8], value_ptr++)) Badarg(5735,"value");
10497 if(!enif_get_double(env, value_tpl[9], value_ptr++)) Badarg(5735,"value");
10498 if(!enif_get_double(env, value_tpl[10], value_ptr++)) Badarg(5735,"value");
10499 if(!enif_get_double(env, value_tpl[11], value_ptr++)) Badarg(5735,"value");
10500 value_l = value_t;
10501 };
10502 value = value_vec.data();
10503 weglProgramUniformMatrix4x3dv(program,location,count,transpose,value);
10504 }
10505
ecb_glValidateProgramPipeline(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10506 void ecb_glValidateProgramPipeline(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10507 {
10508 GLuint pipeline;
10509 if(!enif_get_uint(env, argv[0], &pipeline)) Badarg(5736,"pipeline");
10510 weglValidateProgramPipeline(pipeline);
10511 }
10512
ecb_glGetProgramPipelineInfoLog(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10513 void ecb_glGetProgramPipelineInfoLog(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10514 {
10515 ERL_NIF_TERM reply;
10516 GLuint pipeline;
10517 GLsizei bufSize;
10518 GLsizei length;
10519 unsigned char *infoLog;
10520 if(!enif_get_uint(env, argv[0], &pipeline)) Badarg(5737,"pipeline");
10521 if(!enif_get_int(env, argv[1], &bufSize)) Badarg(5737,"bufSize");
10522 infoLog = (unsigned char *) enif_alloc((int) bufSize*sizeof(GLchar));
10523 weglGetProgramPipelineInfoLog(pipeline,bufSize,&length,(GLchar *) infoLog);
10524 reply = enif_make_string(env, (const char *) infoLog, ERL_NIF_LATIN1);
10525 enif_send(NULL, self, env,
10526 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
10527 enif_free(infoLog);
10528 }
10529
ecb_glVertexAttribL1d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10530 void ecb_glVertexAttribL1d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10531 {
10532 GLuint index;
10533 GLdouble x;
10534 if(!enif_get_uint(env, argv[0], &index)) Badarg(5738,"index");
10535 if(!enif_get_double(env, argv[1], &x)) Badarg(5738,"x");
10536 weglVertexAttribL1d(index,x);
10537 }
10538
ecb_glVertexAttribL2d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10539 void ecb_glVertexAttribL2d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10540 {
10541 GLuint index;
10542 GLdouble x;
10543 GLdouble y;
10544 if(!enif_get_uint(env, argv[0], &index)) Badarg(5739,"index");
10545 if(!enif_get_double(env, argv[1], &x)) Badarg(5739,"x");
10546 if(!enif_get_double(env, argv[2], &y)) Badarg(5739,"y");
10547 weglVertexAttribL2d(index,x,y);
10548 }
10549
ecb_glVertexAttribL3d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10550 void ecb_glVertexAttribL3d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10551 {
10552 GLuint index;
10553 GLdouble x;
10554 GLdouble y;
10555 GLdouble z;
10556 if(!enif_get_uint(env, argv[0], &index)) Badarg(5740,"index");
10557 if(!enif_get_double(env, argv[1], &x)) Badarg(5740,"x");
10558 if(!enif_get_double(env, argv[2], &y)) Badarg(5740,"y");
10559 if(!enif_get_double(env, argv[3], &z)) Badarg(5740,"z");
10560 weglVertexAttribL3d(index,x,y,z);
10561 }
10562
ecb_glVertexAttribL4d(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10563 void ecb_glVertexAttribL4d(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10564 {
10565 GLuint index;
10566 GLdouble x;
10567 GLdouble y;
10568 GLdouble z;
10569 GLdouble w;
10570 if(!enif_get_uint(env, argv[0], &index)) Badarg(5741,"index");
10571 if(!enif_get_double(env, argv[1], &x)) Badarg(5741,"x");
10572 if(!enif_get_double(env, argv[2], &y)) Badarg(5741,"y");
10573 if(!enif_get_double(env, argv[3], &z)) Badarg(5741,"z");
10574 if(!enif_get_double(env, argv[4], &w)) Badarg(5741,"w");
10575 weglVertexAttribL4d(index,x,y,z,w);
10576 }
10577
ecb_glVertexAttribLPointer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10578 void ecb_glVertexAttribLPointer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10579 {
10580 GLuint index;
10581 GLint size;
10582 GLenum type;
10583 GLsizei stride;
10584 ErlNifBinary pointer;
10585 void *pointer_idx;
10586 if(!enif_get_uint(env, argv[0], &index)) Badarg(5742,"index");
10587 if(!enif_get_int(env, argv[1], &size)) Badarg(5742,"size");
10588 if(!enif_get_uint(env, argv[2], &type)) Badarg(5742,"type");
10589 if(!enif_get_int(env, argv[3], &stride)) Badarg(5742,"stride");
10590 if(!egl_get_ptr(env, argv[4], (void **) &pointer_idx)) {
10591 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[4], &pointer))
10592 pointer_idx = (void *) pointer.data;
10593 else Badarg(5742,"pointer");
10594 }
10595 weglVertexAttribLPointer(index,size,type,stride,pointer_idx);
10596 }
10597
ecb_glGetVertexAttribLdv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10598 void ecb_glGetVertexAttribLdv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10599 {
10600 ERL_NIF_TERM reply;
10601 GLuint index;
10602 GLenum pname;
10603 GLdouble params[4];
10604 if(!enif_get_uint(env, argv[0], &index)) Badarg(5744,"index");
10605 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5744,"pname");
10606 weglGetVertexAttribLdv(index,pname,params);
10607 reply = enif_make_tuple4(env,
10608 enif_make_double(env, params[0]),
10609 enif_make_double(env, params[1]),
10610 enif_make_double(env, params[2]),
10611 enif_make_double(env, params[3]));
10612 enif_send(NULL, self, env,
10613 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
10614 }
10615
ecb_glViewportArrayv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10616 void ecb_glViewportArrayv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10617 {
10618 GLuint first;
10619 GLsizei count;
10620 GLfloat *v;
10621 if(!enif_get_uint(env, argv[0], &first)) Badarg(5745,"first");
10622 if(!enif_get_int(env, argv[1], &count)) Badarg(5745,"count");
10623 if(!enif_is_list(env, argv[2])) { Badarg(5745,"v")}
10624 int v_a;
10625 const ERL_NIF_TERM *v_tpl;
10626 ERL_NIF_TERM v_l, v_h, v_t;
10627 std::vector <GLfloat> v_vec (4*count);
10628 GLfloat *v_ptr = v_vec.data();
10629 v_l = argv[2];
10630 while(enif_get_list_cell(env, v_l, &v_h, &v_t)) {
10631 if(!enif_get_tuple(env, v_h, &v_a, &v_tpl) || v_a != 4) Badarg(5745,"v");
10632 if(!egl_get_float(env, v_tpl[0], v_ptr++)) Badarg(5745,"v");
10633 if(!egl_get_float(env, v_tpl[1], v_ptr++)) Badarg(5745,"v");
10634 if(!egl_get_float(env, v_tpl[2], v_ptr++)) Badarg(5745,"v");
10635 if(!egl_get_float(env, v_tpl[3], v_ptr++)) Badarg(5745,"v");
10636 v_l = v_t;
10637 };
10638 v = v_vec.data();
10639 weglViewportArrayv(first,count,v);
10640 }
10641
ecb_glViewportIndexedf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10642 void ecb_glViewportIndexedf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10643 {
10644 GLuint index;
10645 GLfloat x;
10646 GLfloat y;
10647 GLfloat w;
10648 GLfloat h;
10649 if(!enif_get_uint(env, argv[0], &index)) Badarg(5746,"index");
10650 if(!egl_get_float(env, argv[1], &x)) Badarg(5746,"x");
10651 if(!egl_get_float(env, argv[2], &y)) Badarg(5746,"y");
10652 if(!egl_get_float(env, argv[3], &w)) Badarg(5746,"w");
10653 if(!egl_get_float(env, argv[4], &h)) Badarg(5746,"h");
10654 weglViewportIndexedf(index,x,y,w,h);
10655 }
10656
ecb_glViewportIndexedfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10657 void ecb_glViewportIndexedfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10658 {
10659 GLuint index;
10660 GLfloat v[4];
10661 if(!enif_get_uint(env, argv[0], &index)) Badarg(5747,"index");
10662 {
10663 int v_a;
10664 const ERL_NIF_TERM *v_t;
10665 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
10666 Badarg(5747,"v");
10667 } else {
10668 int i1 = 0;
10669 if(!egl_get_float(env, v_t[i1++], &v[0])) Badarg(5747,"v");
10670 if(!egl_get_float(env, v_t[i1++], &v[1])) Badarg(5747,"v");
10671 if(!egl_get_float(env, v_t[i1++], &v[2])) Badarg(5747,"v");
10672 if(!egl_get_float(env, v_t[i1++], &v[3])) Badarg(5747,"v");
10673 }};
10674 weglViewportIndexedfv(index,v);
10675 }
10676
ecb_glScissorArrayv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10677 void ecb_glScissorArrayv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10678 {
10679 GLuint first;
10680 GLsizei count;
10681 GLint *v;
10682 if(!enif_get_uint(env, argv[0], &first)) Badarg(5748,"first");
10683 if(!enif_get_int(env, argv[1], &count)) Badarg(5748,"count");
10684 if(!enif_is_list(env, argv[2])) { Badarg(5748,"v")}
10685 int v_a;
10686 const ERL_NIF_TERM *v_tpl;
10687 ERL_NIF_TERM v_l, v_h, v_t;
10688 std::vector <GLint> v_vec (4*count);
10689 GLint *v_ptr = v_vec.data();
10690 v_l = argv[2];
10691 while(enif_get_list_cell(env, v_l, &v_h, &v_t)) {
10692 if(!enif_get_tuple(env, v_h, &v_a, &v_tpl) || v_a != 4) Badarg(5748,"v");
10693 if(!enif_get_int(env, v_tpl[0], v_ptr++)) Badarg(5748,"v");
10694 if(!enif_get_int(env, v_tpl[1], v_ptr++)) Badarg(5748,"v");
10695 if(!enif_get_int(env, v_tpl[2], v_ptr++)) Badarg(5748,"v");
10696 if(!enif_get_int(env, v_tpl[3], v_ptr++)) Badarg(5748,"v");
10697 v_l = v_t;
10698 };
10699 v = v_vec.data();
10700 weglScissorArrayv(first,count,v);
10701 }
10702
ecb_glScissorIndexed(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10703 void ecb_glScissorIndexed(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10704 {
10705 GLuint index;
10706 GLint left;
10707 GLint bottom;
10708 GLsizei width;
10709 GLsizei height;
10710 if(!enif_get_uint(env, argv[0], &index)) Badarg(5749,"index");
10711 if(!enif_get_int(env, argv[1], &left)) Badarg(5749,"left");
10712 if(!enif_get_int(env, argv[2], &bottom)) Badarg(5749,"bottom");
10713 if(!enif_get_int(env, argv[3], &width)) Badarg(5749,"width");
10714 if(!enif_get_int(env, argv[4], &height)) Badarg(5749,"height");
10715 weglScissorIndexed(index,left,bottom,width,height);
10716 }
10717
ecb_glScissorIndexedv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10718 void ecb_glScissorIndexedv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10719 {
10720 GLuint index;
10721 GLint v[4];
10722 if(!enif_get_uint(env, argv[0], &index)) Badarg(5750,"index");
10723 {
10724 int v_a;
10725 const ERL_NIF_TERM *v_t;
10726 if(!enif_get_tuple(env, argv[1], &v_a, &v_t) || v_a != 4) {
10727 Badarg(5750,"v");
10728 } else {
10729 int i1 = 0;
10730 if(!enif_get_int(env, v_t[i1++], &v[0])) Badarg(5750,"v");
10731 if(!enif_get_int(env, v_t[i1++], &v[1])) Badarg(5750,"v");
10732 if(!enif_get_int(env, v_t[i1++], &v[2])) Badarg(5750,"v");
10733 if(!enif_get_int(env, v_t[i1++], &v[3])) Badarg(5750,"v");
10734 }};
10735 weglScissorIndexedv(index,v);
10736 }
10737
ecb_glDepthRangeArrayv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10738 void ecb_glDepthRangeArrayv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10739 {
10740 GLuint first;
10741 GLsizei count;
10742 GLdouble *v;
10743 if(!enif_get_uint(env, argv[0], &first)) Badarg(5751,"first");
10744 if(!enif_get_int(env, argv[1], &count)) Badarg(5751,"count");
10745 if(!enif_is_list(env, argv[2])) { Badarg(5751,"v")}
10746 int v_a;
10747 const ERL_NIF_TERM *v_tpl;
10748 ERL_NIF_TERM v_l, v_h, v_t;
10749 std::vector <GLdouble> v_vec (2*count);
10750 GLdouble *v_ptr = v_vec.data();
10751 v_l = argv[2];
10752 while(enif_get_list_cell(env, v_l, &v_h, &v_t)) {
10753 if(!enif_get_tuple(env, v_h, &v_a, &v_tpl) || v_a != 2) Badarg(5751,"v");
10754 if(!enif_get_double(env, v_tpl[0], v_ptr++)) Badarg(5751,"v");
10755 if(!enif_get_double(env, v_tpl[1], v_ptr++)) Badarg(5751,"v");
10756 v_l = v_t;
10757 };
10758 v = v_vec.data();
10759 weglDepthRangeArrayv(first,count,v);
10760 }
10761
ecb_glDepthRangeIndexed(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10762 void ecb_glDepthRangeIndexed(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10763 {
10764 GLuint index;
10765 GLdouble n;
10766 GLdouble f;
10767 if(!enif_get_uint(env, argv[0], &index)) Badarg(5752,"index");
10768 if(!enif_get_double(env, argv[1], &n)) Badarg(5752,"n");
10769 if(!enif_get_double(env, argv[2], &f)) Badarg(5752,"f");
10770 weglDepthRangeIndexed(index,n,f);
10771 }
10772
ecb_glGetFloati_v(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10773 void ecb_glGetFloati_v(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10774 {
10775 ERL_NIF_TERM reply;
10776 GLenum target;
10777 GLuint index;
10778 GLfloat data[16];
10779 ERL_NIF_TERM data_ts[16];
10780 if(!enif_get_uint(env, argv[0], &target)) Badarg(5753,"target");
10781 if(!enif_get_uint(env, argv[1], &index)) Badarg(5753,"index");
10782 weglGetFloati_v(target,index,data);
10783 for(int ri=0; ri < (int) 16; ri++)
10784 data_ts[ri] = enif_make_double(env, (double) data[ri]);
10785 reply = enif_make_list_from_array(env, data_ts, 16);
10786 enif_send(NULL, self, env,
10787 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
10788 }
10789
ecb_glGetDoublei_v(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10790 void ecb_glGetDoublei_v(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10791 {
10792 ERL_NIF_TERM reply;
10793 GLenum target;
10794 GLuint index;
10795 GLdouble data[16];
10796 ERL_NIF_TERM data_ts[16];
10797 if(!enif_get_uint(env, argv[0], &target)) Badarg(5754,"target");
10798 if(!enif_get_uint(env, argv[1], &index)) Badarg(5754,"index");
10799 weglGetDoublei_v(target,index,data);
10800 for(int ri=0; ri < (int) 16; ri++)
10801 data_ts[ri] = enif_make_double(env, data[ri]);
10802 reply = enif_make_list_from_array(env, data_ts, 16);
10803 enif_send(NULL, self, env,
10804 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
10805 }
10806
ecb_glDrawArraysInstancedBaseInstance(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10807 void ecb_glDrawArraysInstancedBaseInstance(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10808 {
10809 GLenum mode;
10810 GLint first;
10811 GLsizei count;
10812 GLsizei instancecount;
10813 GLuint baseinstance;
10814 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5755,"mode");
10815 if(!enif_get_int(env, argv[1], &first)) Badarg(5755,"first");
10816 if(!enif_get_int(env, argv[2], &count)) Badarg(5755,"count");
10817 if(!enif_get_int(env, argv[3], &instancecount)) Badarg(5755,"instancecount");
10818 if(!enif_get_uint(env, argv[4], &baseinstance)) Badarg(5755,"baseinstance");
10819 weglDrawArraysInstancedBaseInstance(mode,first,count,instancecount,baseinstance);
10820 }
10821
ecb_glDrawElementsInstancedBaseInstance(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10822 void ecb_glDrawElementsInstancedBaseInstance(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10823 {
10824 GLenum mode;
10825 GLsizei count;
10826 GLenum type;
10827 ErlNifBinary indices;
10828 void *indices_idx;
10829 GLsizei instancecount;
10830 GLuint baseinstance;
10831 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5756,"mode");
10832 if(!enif_get_int(env, argv[1], &count)) Badarg(5756,"count");
10833 if(!enif_get_uint(env, argv[2], &type)) Badarg(5756,"type");
10834 if(!egl_get_ptr(env, argv[3], (void **) &indices_idx)) {
10835 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[3], &indices))
10836 indices_idx = (void *) indices.data;
10837 else Badarg(5756,"indices");
10838 }
10839 if(!enif_get_int(env, argv[4], &instancecount)) Badarg(5756,"instancecount");
10840 if(!enif_get_uint(env, argv[5], &baseinstance)) Badarg(5756,"baseinstance");
10841 weglDrawElementsInstancedBaseInstance(mode,count,type,indices_idx,instancecount,baseinstance);
10842 }
10843
ecb_glDrawElementsInstancedBaseVertexBaseInstance(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10844 void ecb_glDrawElementsInstancedBaseVertexBaseInstance(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10845 {
10846 GLenum mode;
10847 GLsizei count;
10848 GLenum type;
10849 ErlNifBinary indices;
10850 void *indices_idx;
10851 GLsizei instancecount;
10852 GLint basevertex;
10853 GLuint baseinstance;
10854 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5758,"mode");
10855 if(!enif_get_int(env, argv[1], &count)) Badarg(5758,"count");
10856 if(!enif_get_uint(env, argv[2], &type)) Badarg(5758,"type");
10857 if(!egl_get_ptr(env, argv[3], (void **) &indices_idx)) {
10858 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[3], &indices))
10859 indices_idx = (void *) indices.data;
10860 else Badarg(5758,"indices");
10861 }
10862 if(!enif_get_int(env, argv[4], &instancecount)) Badarg(5758,"instancecount");
10863 if(!enif_get_int(env, argv[5], &basevertex)) Badarg(5758,"basevertex");
10864 if(!enif_get_uint(env, argv[6], &baseinstance)) Badarg(5758,"baseinstance");
10865 weglDrawElementsInstancedBaseVertexBaseInstance(mode,count,type,indices_idx,instancecount,basevertex,baseinstance);
10866 }
10867
ecb_glGetInternalformativ(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10868 void ecb_glGetInternalformativ(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10869 {
10870 ERL_NIF_TERM reply;
10871 GLenum target;
10872 GLenum internalformat;
10873 GLenum pname;
10874 GLsizei bufSize;
10875 if(!enif_get_uint(env, argv[0], &target)) Badarg(5760,"target");
10876 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5760,"internalformat");
10877 if(!enif_get_uint(env, argv[2], &pname)) Badarg(5760,"pname");
10878 if(!enif_get_int(env, argv[3], &bufSize)) Badarg(5760,"bufSize");
10879 std::vector <GLint> params (bufSize);
10880 std::vector <ERL_NIF_TERM> params_ts (bufSize);
10881 weglGetInternalformativ(target,internalformat,pname,bufSize,params.data());
10882 for(int ri=0; ri < (int) bufSize; ri++)
10883 params_ts[ri] = enif_make_int(env, params[ri]);
10884 reply = enif_make_list_from_array(env, params_ts.data(), bufSize);
10885 enif_send(NULL, self, env,
10886 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
10887 }
10888
ecb_glBindImageTexture(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10889 void ecb_glBindImageTexture(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10890 {
10891 GLuint unit;
10892 GLuint texture;
10893 GLint level;
10894 GLboolean layered;
10895 GLint layer;
10896 GLenum access;
10897 GLenum format;
10898 if(!enif_get_uint(env, argv[0], &unit)) Badarg(5761,"unit");
10899 if(!enif_get_uint(env, argv[1], &texture)) Badarg(5761,"texture");
10900 if(!enif_get_int(env, argv[2], &level)) Badarg(5761,"level");
10901 if(!egl_get_ubyte(env, argv[3], &layered)) Badarg(5761,"layered");
10902 if(!enif_get_int(env, argv[4], &layer)) Badarg(5761,"layer");
10903 if(!enif_get_uint(env, argv[5], &access)) Badarg(5761,"access");
10904 if(!enif_get_uint(env, argv[6], &format)) Badarg(5761,"format");
10905 weglBindImageTexture(unit,texture,level,layered,layer,access,format);
10906 }
10907
ecb_glMemoryBarrier(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10908 void ecb_glMemoryBarrier(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10909 {
10910 GLbitfield barriers;
10911 if(!enif_get_uint(env, argv[0], &barriers)) Badarg(5762,"barriers");
10912 weglMemoryBarrier(barriers);
10913 }
10914
ecb_glTexStorage1D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10915 void ecb_glTexStorage1D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10916 {
10917 GLenum target;
10918 GLsizei levels;
10919 GLenum internalformat;
10920 GLsizei width;
10921 if(!enif_get_uint(env, argv[0], &target)) Badarg(5763,"target");
10922 if(!enif_get_int(env, argv[1], &levels)) Badarg(5763,"levels");
10923 if(!enif_get_uint(env, argv[2], &internalformat)) Badarg(5763,"internalformat");
10924 if(!enif_get_int(env, argv[3], &width)) Badarg(5763,"width");
10925 weglTexStorage1D(target,levels,internalformat,width);
10926 }
10927
ecb_glTexStorage2D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10928 void ecb_glTexStorage2D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10929 {
10930 GLenum target;
10931 GLsizei levels;
10932 GLenum internalformat;
10933 GLsizei width;
10934 GLsizei height;
10935 if(!enif_get_uint(env, argv[0], &target)) Badarg(5764,"target");
10936 if(!enif_get_int(env, argv[1], &levels)) Badarg(5764,"levels");
10937 if(!enif_get_uint(env, argv[2], &internalformat)) Badarg(5764,"internalformat");
10938 if(!enif_get_int(env, argv[3], &width)) Badarg(5764,"width");
10939 if(!enif_get_int(env, argv[4], &height)) Badarg(5764,"height");
10940 weglTexStorage2D(target,levels,internalformat,width,height);
10941 }
10942
ecb_glTexStorage3D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10943 void ecb_glTexStorage3D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10944 {
10945 GLenum target;
10946 GLsizei levels;
10947 GLenum internalformat;
10948 GLsizei width;
10949 GLsizei height;
10950 GLsizei depth;
10951 if(!enif_get_uint(env, argv[0], &target)) Badarg(5765,"target");
10952 if(!enif_get_int(env, argv[1], &levels)) Badarg(5765,"levels");
10953 if(!enif_get_uint(env, argv[2], &internalformat)) Badarg(5765,"internalformat");
10954 if(!enif_get_int(env, argv[3], &width)) Badarg(5765,"width");
10955 if(!enif_get_int(env, argv[4], &height)) Badarg(5765,"height");
10956 if(!enif_get_int(env, argv[5], &depth)) Badarg(5765,"depth");
10957 weglTexStorage3D(target,levels,internalformat,width,height,depth);
10958 }
10959
ecb_glDrawTransformFeedbackInstanced(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10960 void ecb_glDrawTransformFeedbackInstanced(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10961 {
10962 GLenum mode;
10963 GLuint id;
10964 GLsizei instancecount;
10965 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5766,"mode");
10966 if(!enif_get_uint(env, argv[1], &id)) Badarg(5766,"id");
10967 if(!enif_get_int(env, argv[2], &instancecount)) Badarg(5766,"instancecount");
10968 weglDrawTransformFeedbackInstanced(mode,id,instancecount);
10969 }
10970
ecb_glDrawTransformFeedbackStreamInstanced(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10971 void ecb_glDrawTransformFeedbackStreamInstanced(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10972 {
10973 GLenum mode;
10974 GLuint id;
10975 GLuint stream;
10976 GLsizei instancecount;
10977 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5767,"mode");
10978 if(!enif_get_uint(env, argv[1], &id)) Badarg(5767,"id");
10979 if(!enif_get_uint(env, argv[2], &stream)) Badarg(5767,"stream");
10980 if(!enif_get_int(env, argv[3], &instancecount)) Badarg(5767,"instancecount");
10981 weglDrawTransformFeedbackStreamInstanced(mode,id,stream,instancecount);
10982 }
10983
ecb_glClearBufferData(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])10984 void ecb_glClearBufferData(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
10985 {
10986 GLenum target;
10987 GLenum internalformat;
10988 GLenum format;
10989 GLenum type;
10990 ErlNifBinary data;
10991 void *data_idx;
10992 if(!enif_get_uint(env, argv[0], &target)) Badarg(5768,"target");
10993 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5768,"internalformat");
10994 if(!enif_get_uint(env, argv[2], &format)) Badarg(5768,"format");
10995 if(!enif_get_uint(env, argv[3], &type)) Badarg(5768,"type");
10996 if(!egl_get_ptr(env, argv[4], (void **) &data_idx)) {
10997 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[4], &data))
10998 data_idx = (void *) data.data;
10999 else Badarg(5768,"data");
11000 }
11001 weglClearBufferData(target,internalformat,format,type,data_idx);
11002 }
11003
ecb_glClearBufferSubData(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11004 void ecb_glClearBufferSubData(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11005 {
11006 GLenum target;
11007 GLenum internalformat;
11008 GLintptr offset;
11009 GLsizeiptr size;
11010 GLenum format;
11011 GLenum type;
11012 ErlNifBinary data;
11013 void *data_idx;
11014 if(!enif_get_uint(env, argv[0], &target)) Badarg(5770,"target");
11015 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5770,"internalformat");
11016 if(!egl_get_word(env, argv[2], (egl_word *) &offset)) Badarg(5770,"offset");
11017 if(!egl_get_word(env, argv[3], (egl_word *) &size)) Badarg(5770,"size");
11018 if(!enif_get_uint(env, argv[4], &format)) Badarg(5770,"format");
11019 if(!enif_get_uint(env, argv[5], &type)) Badarg(5770,"type");
11020 if(!egl_get_ptr(env, argv[6], (void **) &data_idx)) {
11021 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[6], &data))
11022 data_idx = (void *) data.data;
11023 else Badarg(5770,"data");
11024 }
11025 weglClearBufferSubData(target,internalformat,offset,size,format,type,data_idx);
11026 }
11027
ecb_glDispatchCompute(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11028 void ecb_glDispatchCompute(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11029 {
11030 GLuint num_groups_x;
11031 GLuint num_groups_y;
11032 GLuint num_groups_z;
11033 if(!enif_get_uint(env, argv[0], &num_groups_x)) Badarg(5772,"num_groups_x");
11034 if(!enif_get_uint(env, argv[1], &num_groups_y)) Badarg(5772,"num_groups_y");
11035 if(!enif_get_uint(env, argv[2], &num_groups_z)) Badarg(5772,"num_groups_z");
11036 weglDispatchCompute(num_groups_x,num_groups_y,num_groups_z);
11037 }
11038
ecb_glDispatchComputeIndirect(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11039 void ecb_glDispatchComputeIndirect(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11040 {
11041 GLintptr indirect;
11042 if(!egl_get_word(env, argv[0], (egl_word *) &indirect)) Badarg(5773,"indirect");
11043 weglDispatchComputeIndirect(indirect);
11044 }
11045
ecb_glCopyImageSubData(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11046 void ecb_glCopyImageSubData(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11047 {
11048 GLuint srcName;
11049 GLenum srcTarget;
11050 GLint srcLevel;
11051 GLint srcX;
11052 GLint srcY;
11053 GLint srcZ;
11054 GLuint dstName;
11055 GLenum dstTarget;
11056 GLint dstLevel;
11057 GLint dstX;
11058 GLint dstY;
11059 GLint dstZ;
11060 GLsizei srcWidth;
11061 GLsizei srcHeight;
11062 GLsizei srcDepth;
11063 if(!enif_get_uint(env, argv[0], &srcName)) Badarg(5774,"srcName");
11064 if(!enif_get_uint(env, argv[1], &srcTarget)) Badarg(5774,"srcTarget");
11065 if(!enif_get_int(env, argv[2], &srcLevel)) Badarg(5774,"srcLevel");
11066 if(!enif_get_int(env, argv[3], &srcX)) Badarg(5774,"srcX");
11067 if(!enif_get_int(env, argv[4], &srcY)) Badarg(5774,"srcY");
11068 if(!enif_get_int(env, argv[5], &srcZ)) Badarg(5774,"srcZ");
11069 if(!enif_get_uint(env, argv[6], &dstName)) Badarg(5774,"dstName");
11070 if(!enif_get_uint(env, argv[7], &dstTarget)) Badarg(5774,"dstTarget");
11071 if(!enif_get_int(env, argv[8], &dstLevel)) Badarg(5774,"dstLevel");
11072 if(!enif_get_int(env, argv[9], &dstX)) Badarg(5774,"dstX");
11073 if(!enif_get_int(env, argv[10], &dstY)) Badarg(5774,"dstY");
11074 if(!enif_get_int(env, argv[11], &dstZ)) Badarg(5774,"dstZ");
11075 if(!enif_get_int(env, argv[12], &srcWidth)) Badarg(5774,"srcWidth");
11076 if(!enif_get_int(env, argv[13], &srcHeight)) Badarg(5774,"srcHeight");
11077 if(!enif_get_int(env, argv[14], &srcDepth)) Badarg(5774,"srcDepth");
11078 weglCopyImageSubData(srcName,srcTarget,srcLevel,srcX,srcY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,srcWidth,srcHeight,srcDepth);
11079 }
11080
ecb_glFramebufferParameteri(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11081 void ecb_glFramebufferParameteri(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11082 {
11083 GLenum target;
11084 GLenum pname;
11085 GLint param;
11086 if(!enif_get_uint(env, argv[0], &target)) Badarg(5775,"target");
11087 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5775,"pname");
11088 if(!enif_get_int(env, argv[2], ¶m)) Badarg(5775,"param");
11089 weglFramebufferParameteri(target,pname,param);
11090 }
11091
ecb_glGetFramebufferParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11092 void ecb_glGetFramebufferParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11093 {
11094 ERL_NIF_TERM reply;
11095 GLenum target;
11096 GLenum pname;
11097 GLint params;
11098 if(!enif_get_uint(env, argv[0], &target)) Badarg(5776,"target");
11099 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5776,"pname");
11100 weglGetFramebufferParameteriv(target,pname,¶ms);
11101 reply = enif_make_int(env, params);
11102 enif_send(NULL, self, env,
11103 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
11104 }
11105
ecb_glGetInternalformati64v(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11106 void ecb_glGetInternalformati64v(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11107 {
11108 ERL_NIF_TERM reply;
11109 GLenum target;
11110 GLenum internalformat;
11111 GLenum pname;
11112 GLsizei bufSize;
11113 if(!enif_get_uint(env, argv[0], &target)) Badarg(5777,"target");
11114 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5777,"internalformat");
11115 if(!enif_get_uint(env, argv[2], &pname)) Badarg(5777,"pname");
11116 if(!enif_get_int(env, argv[3], &bufSize)) Badarg(5777,"bufSize");
11117 std::vector <GLint64> params (bufSize);
11118 std::vector <ERL_NIF_TERM> params_ts (bufSize);
11119 weglGetInternalformati64v(target,internalformat,pname,bufSize,params.data());
11120 for(int ri=0; ri < (int) bufSize; ri++)
11121 params_ts[ri] = enif_make_int64(env, (egl_int64_t) params[ri]);
11122 reply = enif_make_list_from_array(env, params_ts.data(), bufSize);
11123 enif_send(NULL, self, env,
11124 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
11125 }
11126
ecb_glInvalidateTexSubImage(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11127 void ecb_glInvalidateTexSubImage(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11128 {
11129 GLuint texture;
11130 GLint level;
11131 GLint xoffset;
11132 GLint yoffset;
11133 GLint zoffset;
11134 GLsizei width;
11135 GLsizei height;
11136 GLsizei depth;
11137 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5778,"texture");
11138 if(!enif_get_int(env, argv[1], &level)) Badarg(5778,"level");
11139 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5778,"xoffset");
11140 if(!enif_get_int(env, argv[3], &yoffset)) Badarg(5778,"yoffset");
11141 if(!enif_get_int(env, argv[4], &zoffset)) Badarg(5778,"zoffset");
11142 if(!enif_get_int(env, argv[5], &width)) Badarg(5778,"width");
11143 if(!enif_get_int(env, argv[6], &height)) Badarg(5778,"height");
11144 if(!enif_get_int(env, argv[7], &depth)) Badarg(5778,"depth");
11145 weglInvalidateTexSubImage(texture,level,xoffset,yoffset,zoffset,width,height,depth);
11146 }
11147
ecb_glInvalidateTexImage(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11148 void ecb_glInvalidateTexImage(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11149 {
11150 GLuint texture;
11151 GLint level;
11152 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5779,"texture");
11153 if(!enif_get_int(env, argv[1], &level)) Badarg(5779,"level");
11154 weglInvalidateTexImage(texture,level);
11155 }
11156
ecb_glInvalidateBufferSubData(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11157 void ecb_glInvalidateBufferSubData(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11158 {
11159 GLuint buffer;
11160 GLintptr offset;
11161 GLsizeiptr length;
11162 if(!enif_get_uint(env, argv[0], &buffer)) Badarg(5780,"buffer");
11163 if(!egl_get_word(env, argv[1], (egl_word *) &offset)) Badarg(5780,"offset");
11164 if(!egl_get_word(env, argv[2], (egl_word *) &length)) Badarg(5780,"length");
11165 weglInvalidateBufferSubData(buffer,offset,length);
11166 }
11167
ecb_glInvalidateBufferData(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11168 void ecb_glInvalidateBufferData(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11169 {
11170 GLuint buffer;
11171 if(!enif_get_uint(env, argv[0], &buffer)) Badarg(5781,"buffer");
11172 weglInvalidateBufferData(buffer);
11173 }
11174
ecb_glInvalidateFramebuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11175 void ecb_glInvalidateFramebuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11176 {
11177 GLenum target;
11178 GLsizei numAttachments;
11179 GLenum *attachments;
11180 if(!enif_get_uint(env, argv[0], &target)) Badarg(5782,"target");
11181 if(!enif_get_int(env, argv[1], &numAttachments)) Badarg(5782,"numAttachments");
11182 if(!enif_is_list(env, argv[2])) Badarg(5782, "attachments")
11183 else {
11184 ERL_NIF_TERM attachments_l, attachments_h, attachments_t;
11185 std::vector <GLenum> attachments_vec;
11186 GLenum attachments_tmp;
11187 attachments_l = argv[2];
11188 while(enif_get_list_cell(env, attachments_l, &attachments_h, &attachments_t)) {
11189 if(!enif_get_uint(env, attachments_h, &attachments_tmp)) Badarg(5782,"attachments");
11190 attachments_vec.push_back(attachments_tmp);
11191 attachments_l = attachments_t;
11192 };
11193 attachments = attachments_vec.data();
11194 }
11195 weglInvalidateFramebuffer(target,numAttachments,attachments);
11196 }
11197
ecb_glInvalidateSubFramebuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11198 void ecb_glInvalidateSubFramebuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11199 {
11200 GLenum target;
11201 GLsizei numAttachments;
11202 GLenum *attachments;
11203 GLint x;
11204 GLint y;
11205 GLsizei width;
11206 GLsizei height;
11207 if(!enif_get_uint(env, argv[0], &target)) Badarg(5783,"target");
11208 if(!enif_get_int(env, argv[1], &numAttachments)) Badarg(5783,"numAttachments");
11209 if(!enif_is_list(env, argv[2])) Badarg(5783, "attachments")
11210 else {
11211 ERL_NIF_TERM attachments_l, attachments_h, attachments_t;
11212 std::vector <GLenum> attachments_vec;
11213 GLenum attachments_tmp;
11214 attachments_l = argv[2];
11215 while(enif_get_list_cell(env, attachments_l, &attachments_h, &attachments_t)) {
11216 if(!enif_get_uint(env, attachments_h, &attachments_tmp)) Badarg(5783,"attachments");
11217 attachments_vec.push_back(attachments_tmp);
11218 attachments_l = attachments_t;
11219 };
11220 attachments = attachments_vec.data();
11221 }
11222 if(!enif_get_int(env, argv[3], &x)) Badarg(5783,"x");
11223 if(!enif_get_int(env, argv[4], &y)) Badarg(5783,"y");
11224 if(!enif_get_int(env, argv[5], &width)) Badarg(5783,"width");
11225 if(!enif_get_int(env, argv[6], &height)) Badarg(5783,"height");
11226 weglInvalidateSubFramebuffer(target,numAttachments,attachments,x,y,width,height);
11227 }
11228
ecb_glMultiDrawArraysIndirect(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11229 void ecb_glMultiDrawArraysIndirect(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11230 {
11231 GLenum mode;
11232 ErlNifBinary indirect;
11233 void *indirect_idx;
11234 GLsizei drawcount;
11235 GLsizei stride;
11236 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5784,"mode");
11237 if(!egl_get_ptr(env, argv[1], (void **) &indirect_idx)) {
11238 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[1], &indirect))
11239 indirect_idx = (void *) indirect.data;
11240 else Badarg(5784,"indirect");
11241 }
11242 if(!enif_get_int(env, argv[2], &drawcount)) Badarg(5784,"drawcount");
11243 if(!enif_get_int(env, argv[3], &stride)) Badarg(5784,"stride");
11244 weglMultiDrawArraysIndirect(mode,indirect_idx,drawcount,stride);
11245 }
11246
ecb_glGetProgramInterfaceiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11247 void ecb_glGetProgramInterfaceiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11248 {
11249 ERL_NIF_TERM reply;
11250 GLuint program;
11251 GLenum programInterface;
11252 GLenum pname;
11253 GLint params;
11254 if(!enif_get_uint(env, argv[0], &program)) Badarg(5786,"program");
11255 if(!enif_get_uint(env, argv[1], &programInterface)) Badarg(5786,"programInterface");
11256 if(!enif_get_uint(env, argv[2], &pname)) Badarg(5786,"pname");
11257 weglGetProgramInterfaceiv(program,programInterface,pname,¶ms);
11258 reply = enif_make_int(env, params);
11259 enif_send(NULL, self, env,
11260 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
11261 }
11262
ecb_glGetProgramResourceIndex(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11263 void ecb_glGetProgramResourceIndex(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11264 {
11265 GLuint result;
11266 ERL_NIF_TERM reply;
11267 GLuint program;
11268 GLenum programInterface;
11269 ErlNifBinary name;
11270 if(!enif_get_uint(env, argv[0], &program)) Badarg(5787,"program");
11271 if(!enif_get_uint(env, argv[1], &programInterface)) Badarg(5787,"programInterface");
11272 if(!enif_inspect_binary(env, argv[2], &name)) Badarg(5787,"name");
11273 result = weglGetProgramResourceIndex(program,programInterface,(GLchar *) name.data);
11274 reply = enif_make_int(env, result);
11275 enif_send(NULL, self, env,
11276 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
11277 }
11278
ecb_glGetProgramResourceName(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11279 void ecb_glGetProgramResourceName(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11280 {
11281 ERL_NIF_TERM reply;
11282 GLuint program;
11283 GLenum programInterface;
11284 GLuint index;
11285 GLsizei bufSize;
11286 unsigned char *name;
11287 if(!enif_get_uint(env, argv[0], &program)) Badarg(5788,"program");
11288 if(!enif_get_uint(env, argv[1], &programInterface)) Badarg(5788,"programInterface");
11289 if(!enif_get_uint(env, argv[2], &index)) Badarg(5788,"index");
11290 if(!enif_get_int(env, argv[3], &bufSize)) Badarg(5788,"bufSize");
11291 name = (unsigned char *) enif_alloc((int) bufSize*sizeof(GLchar));
11292 weglGetProgramResourceName(program,programInterface,index,bufSize,NULL,(GLchar *) name);
11293 reply = enif_make_string(env, (const char *) name, ERL_NIF_LATIN1);
11294 enif_send(NULL, self, env,
11295 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
11296 enif_free(name);
11297 }
11298
ecb_glGetProgramResourceLocation(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11299 void ecb_glGetProgramResourceLocation(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11300 {
11301 GLint result;
11302 ERL_NIF_TERM reply;
11303 GLuint program;
11304 GLenum programInterface;
11305 ErlNifBinary name;
11306 if(!enif_get_uint(env, argv[0], &program)) Badarg(5789,"program");
11307 if(!enif_get_uint(env, argv[1], &programInterface)) Badarg(5789,"programInterface");
11308 if(!enif_inspect_binary(env, argv[2], &name)) Badarg(5789,"name");
11309 result = weglGetProgramResourceLocation(program,programInterface,(GLchar *) name.data);
11310 reply = enif_make_int(env, result);
11311 enif_send(NULL, self, env,
11312 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
11313 }
11314
ecb_glGetProgramResourceLocationIndex(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11315 void ecb_glGetProgramResourceLocationIndex(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11316 {
11317 GLint result;
11318 ERL_NIF_TERM reply;
11319 GLuint program;
11320 GLenum programInterface;
11321 ErlNifBinary name;
11322 if(!enif_get_uint(env, argv[0], &program)) Badarg(5790,"program");
11323 if(!enif_get_uint(env, argv[1], &programInterface)) Badarg(5790,"programInterface");
11324 if(!enif_inspect_binary(env, argv[2], &name)) Badarg(5790,"name");
11325 result = weglGetProgramResourceLocationIndex(program,programInterface,(GLchar *) name.data);
11326 reply = enif_make_int(env, result);
11327 enif_send(NULL, self, env,
11328 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
11329 }
11330
ecb_glShaderStorageBlockBinding(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11331 void ecb_glShaderStorageBlockBinding(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11332 {
11333 GLuint program;
11334 GLuint storageBlockIndex;
11335 GLuint storageBlockBinding;
11336 if(!enif_get_uint(env, argv[0], &program)) Badarg(5791,"program");
11337 if(!enif_get_uint(env, argv[1], &storageBlockIndex)) Badarg(5791,"storageBlockIndex");
11338 if(!enif_get_uint(env, argv[2], &storageBlockBinding)) Badarg(5791,"storageBlockBinding");
11339 weglShaderStorageBlockBinding(program,storageBlockIndex,storageBlockBinding);
11340 }
11341
ecb_glTexBufferRange(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11342 void ecb_glTexBufferRange(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11343 {
11344 GLenum target;
11345 GLenum internalformat;
11346 GLuint buffer;
11347 GLintptr offset;
11348 GLsizeiptr size;
11349 if(!enif_get_uint(env, argv[0], &target)) Badarg(5792,"target");
11350 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5792,"internalformat");
11351 if(!enif_get_uint(env, argv[2], &buffer)) Badarg(5792,"buffer");
11352 if(!egl_get_word(env, argv[3], (egl_word *) &offset)) Badarg(5792,"offset");
11353 if(!egl_get_word(env, argv[4], (egl_word *) &size)) Badarg(5792,"size");
11354 weglTexBufferRange(target,internalformat,buffer,offset,size);
11355 }
11356
ecb_glTexStorage2DMultisample(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11357 void ecb_glTexStorage2DMultisample(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11358 {
11359 GLenum target;
11360 GLsizei samples;
11361 GLenum internalformat;
11362 GLsizei width;
11363 GLsizei height;
11364 GLboolean fixedsamplelocations;
11365 if(!enif_get_uint(env, argv[0], &target)) Badarg(5793,"target");
11366 if(!enif_get_int(env, argv[1], &samples)) Badarg(5793,"samples");
11367 if(!enif_get_uint(env, argv[2], &internalformat)) Badarg(5793,"internalformat");
11368 if(!enif_get_int(env, argv[3], &width)) Badarg(5793,"width");
11369 if(!enif_get_int(env, argv[4], &height)) Badarg(5793,"height");
11370 if(!egl_get_ubyte(env, argv[5], &fixedsamplelocations)) Badarg(5793,"fixedsamplelocations");
11371 weglTexStorage2DMultisample(target,samples,internalformat,width,height,fixedsamplelocations);
11372 }
11373
ecb_glTexStorage3DMultisample(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11374 void ecb_glTexStorage3DMultisample(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11375 {
11376 GLenum target;
11377 GLsizei samples;
11378 GLenum internalformat;
11379 GLsizei width;
11380 GLsizei height;
11381 GLsizei depth;
11382 GLboolean fixedsamplelocations;
11383 if(!enif_get_uint(env, argv[0], &target)) Badarg(5794,"target");
11384 if(!enif_get_int(env, argv[1], &samples)) Badarg(5794,"samples");
11385 if(!enif_get_uint(env, argv[2], &internalformat)) Badarg(5794,"internalformat");
11386 if(!enif_get_int(env, argv[3], &width)) Badarg(5794,"width");
11387 if(!enif_get_int(env, argv[4], &height)) Badarg(5794,"height");
11388 if(!enif_get_int(env, argv[5], &depth)) Badarg(5794,"depth");
11389 if(!egl_get_ubyte(env, argv[6], &fixedsamplelocations)) Badarg(5794,"fixedsamplelocations");
11390 weglTexStorage3DMultisample(target,samples,internalformat,width,height,depth,fixedsamplelocations);
11391 }
11392
ecb_glTextureView(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11393 void ecb_glTextureView(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11394 {
11395 GLuint texture;
11396 GLenum target;
11397 GLuint origtexture;
11398 GLenum internalformat;
11399 GLuint minlevel;
11400 GLuint numlevels;
11401 GLuint minlayer;
11402 GLuint numlayers;
11403 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5795,"texture");
11404 if(!enif_get_uint(env, argv[1], &target)) Badarg(5795,"target");
11405 if(!enif_get_uint(env, argv[2], &origtexture)) Badarg(5795,"origtexture");
11406 if(!enif_get_uint(env, argv[3], &internalformat)) Badarg(5795,"internalformat");
11407 if(!enif_get_uint(env, argv[4], &minlevel)) Badarg(5795,"minlevel");
11408 if(!enif_get_uint(env, argv[5], &numlevels)) Badarg(5795,"numlevels");
11409 if(!enif_get_uint(env, argv[6], &minlayer)) Badarg(5795,"minlayer");
11410 if(!enif_get_uint(env, argv[7], &numlayers)) Badarg(5795,"numlayers");
11411 weglTextureView(texture,target,origtexture,internalformat,minlevel,numlevels,minlayer,numlayers);
11412 }
11413
ecb_glBindVertexBuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11414 void ecb_glBindVertexBuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11415 {
11416 GLuint bindingindex;
11417 GLuint buffer;
11418 GLintptr offset;
11419 GLsizei stride;
11420 if(!enif_get_uint(env, argv[0], &bindingindex)) Badarg(5796,"bindingindex");
11421 if(!enif_get_uint(env, argv[1], &buffer)) Badarg(5796,"buffer");
11422 if(!egl_get_word(env, argv[2], (egl_word *) &offset)) Badarg(5796,"offset");
11423 if(!enif_get_int(env, argv[3], &stride)) Badarg(5796,"stride");
11424 weglBindVertexBuffer(bindingindex,buffer,offset,stride);
11425 }
11426
ecb_glVertexAttribFormat(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11427 void ecb_glVertexAttribFormat(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11428 {
11429 GLuint attribindex;
11430 GLint size;
11431 GLenum type;
11432 GLboolean normalized;
11433 GLuint relativeoffset;
11434 if(!enif_get_uint(env, argv[0], &attribindex)) Badarg(5797,"attribindex");
11435 if(!enif_get_int(env, argv[1], &size)) Badarg(5797,"size");
11436 if(!enif_get_uint(env, argv[2], &type)) Badarg(5797,"type");
11437 if(!egl_get_ubyte(env, argv[3], &normalized)) Badarg(5797,"normalized");
11438 if(!enif_get_uint(env, argv[4], &relativeoffset)) Badarg(5797,"relativeoffset");
11439 weglVertexAttribFormat(attribindex,size,type,normalized,relativeoffset);
11440 }
11441
ecb_glVertexAttribIFormat(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11442 void ecb_glVertexAttribIFormat(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11443 {
11444 GLuint attribindex;
11445 GLint size;
11446 GLenum type;
11447 GLuint relativeoffset;
11448 if(!enif_get_uint(env, argv[0], &attribindex)) Badarg(5798,"attribindex");
11449 if(!enif_get_int(env, argv[1], &size)) Badarg(5798,"size");
11450 if(!enif_get_uint(env, argv[2], &type)) Badarg(5798,"type");
11451 if(!enif_get_uint(env, argv[3], &relativeoffset)) Badarg(5798,"relativeoffset");
11452 weglVertexAttribIFormat(attribindex,size,type,relativeoffset);
11453 }
11454
ecb_glVertexAttribLFormat(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11455 void ecb_glVertexAttribLFormat(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11456 {
11457 GLuint attribindex;
11458 GLint size;
11459 GLenum type;
11460 GLuint relativeoffset;
11461 if(!enif_get_uint(env, argv[0], &attribindex)) Badarg(5799,"attribindex");
11462 if(!enif_get_int(env, argv[1], &size)) Badarg(5799,"size");
11463 if(!enif_get_uint(env, argv[2], &type)) Badarg(5799,"type");
11464 if(!enif_get_uint(env, argv[3], &relativeoffset)) Badarg(5799,"relativeoffset");
11465 weglVertexAttribLFormat(attribindex,size,type,relativeoffset);
11466 }
11467
ecb_glVertexAttribBinding(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11468 void ecb_glVertexAttribBinding(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11469 {
11470 GLuint attribindex;
11471 GLuint bindingindex;
11472 if(!enif_get_uint(env, argv[0], &attribindex)) Badarg(5800,"attribindex");
11473 if(!enif_get_uint(env, argv[1], &bindingindex)) Badarg(5800,"bindingindex");
11474 weglVertexAttribBinding(attribindex,bindingindex);
11475 }
11476
ecb_glVertexBindingDivisor(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11477 void ecb_glVertexBindingDivisor(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11478 {
11479 GLuint bindingindex;
11480 GLuint divisor;
11481 if(!enif_get_uint(env, argv[0], &bindingindex)) Badarg(5801,"bindingindex");
11482 if(!enif_get_uint(env, argv[1], &divisor)) Badarg(5801,"divisor");
11483 weglVertexBindingDivisor(bindingindex,divisor);
11484 }
11485
ecb_glDebugMessageControl(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11486 void ecb_glDebugMessageControl(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11487 {
11488 GLenum source;
11489 GLenum type;
11490 GLenum severity;
11491 GLsizei count;
11492 GLuint *ids;
11493 GLboolean enabled;
11494 if(!enif_get_uint(env, argv[0], &source)) Badarg(5802,"source");
11495 if(!enif_get_uint(env, argv[1], &type)) Badarg(5802,"type");
11496 if(!enif_get_uint(env, argv[2], &severity)) Badarg(5802,"severity");
11497 if(!enif_get_int(env, argv[3], &count)) Badarg(5802,"count");
11498 if(!enif_is_list(env, argv[4])) Badarg(5802, "ids")
11499 else {
11500 ERL_NIF_TERM ids_l, ids_h, ids_t;
11501 std::vector <GLuint> ids_vec;
11502 GLuint ids_tmp;
11503 ids_l = argv[4];
11504 while(enif_get_list_cell(env, ids_l, &ids_h, &ids_t)) {
11505 if(!enif_get_uint(env, ids_h, &ids_tmp)) Badarg(5802,"ids");
11506 ids_vec.push_back(ids_tmp);
11507 ids_l = ids_t;
11508 };
11509 ids = ids_vec.data();
11510 }
11511 if(!egl_get_ubyte(env, argv[5], &enabled)) Badarg(5802,"enabled");
11512 weglDebugMessageControl(source,type,severity,count,ids,enabled);
11513 }
11514
ecb_glDebugMessageInsert(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11515 void ecb_glDebugMessageInsert(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11516 {
11517 GLenum source;
11518 GLenum type;
11519 GLuint id;
11520 GLenum severity;
11521 GLsizei length;
11522 ErlNifBinary buf;
11523 if(!enif_get_uint(env, argv[0], &source)) Badarg(5803,"source");
11524 if(!enif_get_uint(env, argv[1], &type)) Badarg(5803,"type");
11525 if(!enif_get_uint(env, argv[2], &id)) Badarg(5803,"id");
11526 if(!enif_get_uint(env, argv[3], &severity)) Badarg(5803,"severity");
11527 if(!enif_get_int(env, argv[4], &length)) Badarg(5803,"length");
11528 if(!enif_inspect_binary(env, argv[5], &buf)) Badarg(5803,"buf");
11529 weglDebugMessageInsert(source,type,id,severity,length,(GLchar *) buf.data);
11530 }
11531
ecb_glGetDebugMessageLog(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11532 void ecb_glGetDebugMessageLog(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11533 {
11534 GLuint result;
11535 ERL_NIF_TERM reply;
11536 GLuint count;
11537 GLsizei bufSize;
11538 unsigned char *messageLog;
11539 if(!enif_get_uint(env, argv[0], &count)) Badarg(5804,"count");
11540 if(!enif_get_int(env, argv[1], &bufSize)) Badarg(5804,"bufSize");
11541 std::vector <GLenum> sources (count);
11542 std::vector <ERL_NIF_TERM> sources_ts (count);
11543 std::vector <GLenum> types (count);
11544 std::vector <ERL_NIF_TERM> types_ts (count);
11545 std::vector <GLuint> ids (count);
11546 std::vector <ERL_NIF_TERM> ids_ts (count);
11547 std::vector <GLenum> severities (count);
11548 std::vector <ERL_NIF_TERM> severities_ts (count);
11549 std::vector <GLsizei> lengths (count);
11550 std::vector <ERL_NIF_TERM> lengths_ts (count);
11551 messageLog = (unsigned char *) enif_alloc((int) bufSize*sizeof(GLchar));
11552 result = weglGetDebugMessageLog(count,bufSize,sources.data(),types.data(),ids.data(),severities.data(),lengths.data(),(GLchar *) messageLog);
11553 for(int ri=0; ri < (int) result; ri++)
11554 sources_ts[ri] = enif_make_int(env, sources[ri]);
11555 for(int ri=0; ri < (int) result; ri++)
11556 types_ts[ri] = enif_make_int(env, types[ri]);
11557 for(int ri=0; ri < (int) result; ri++)
11558 ids_ts[ri] = enif_make_int(env, ids[ri]);
11559 for(int ri=0; ri < (int) result; ri++)
11560 severities_ts[ri] = enif_make_int(env, severities[ri]);
11561 reply = enif_make_tuple6(env,
11562 enif_make_int(env, result),
11563 enif_make_list_from_array(env, sources_ts.data(), result),
11564 enif_make_list_from_array(env, types_ts.data(), result),
11565 enif_make_list_from_array(env, ids_ts.data(), result),
11566 enif_make_list_from_array(env, severities_ts.data(), result),
11567 enif_make_string(env, (const char *) messageLog, ERL_NIF_LATIN1) );
11568 enif_send(NULL, self, env,
11569 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
11570 enif_free(messageLog);
11571 }
11572
ecb_glPushDebugGroup(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11573 void ecb_glPushDebugGroup(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11574 {
11575 GLenum source;
11576 GLuint id;
11577 GLsizei length;
11578 ErlNifBinary message;
11579 if(!enif_get_uint(env, argv[0], &source)) Badarg(5805,"source");
11580 if(!enif_get_uint(env, argv[1], &id)) Badarg(5805,"id");
11581 if(!enif_get_int(env, argv[2], &length)) Badarg(5805,"length");
11582 if(!enif_inspect_binary(env, argv[3], &message)) Badarg(5805,"message");
11583 weglPushDebugGroup(source,id,length,(GLchar *) message.data);
11584 }
11585
ecb_glPopDebugGroup(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11586 void ecb_glPopDebugGroup(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11587 {
11588 weglPopDebugGroup();
11589 }
11590
ecb_glObjectPtrLabel(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11591 void ecb_glObjectPtrLabel(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11592 {
11593 ErlNifBinary ptr;
11594 void *ptr_idx;
11595 GLsizei length;
11596 ErlNifBinary label;
11597 if(!egl_get_ptr(env, argv[0], (void **) &ptr_idx)) {
11598 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[0], &ptr))
11599 ptr_idx = (void *) ptr.data;
11600 else Badarg(5807,"ptr");
11601 }
11602 if(!enif_get_int(env, argv[1], &length)) Badarg(5807,"length");
11603 if(!enif_inspect_binary(env, argv[2], &label)) Badarg(5807,"label");
11604 weglObjectPtrLabel(ptr_idx,length,(GLchar *) label.data);
11605 }
11606
ecb_glBufferStorage(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11607 void ecb_glBufferStorage(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11608 {
11609 GLenum target;
11610 GLsizeiptr size;
11611 ErlNifBinary data;
11612 void *data_idx;
11613 GLbitfield flags;
11614 if(!enif_get_uint(env, argv[0], &target)) Badarg(5809,"target");
11615 if(!egl_get_word(env, argv[1], (egl_word *) &size)) Badarg(5809,"size");
11616 if(!egl_get_ptr(env, argv[2], (void **) &data_idx)) {
11617 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[2], &data))
11618 data_idx = (void *) data.data;
11619 else Badarg(5809,"data");
11620 }
11621 if(!enif_get_uint(env, argv[3], &flags)) Badarg(5809,"flags");
11622 weglBufferStorage(target,size,data_idx,flags);
11623 }
11624
ecb_glClearTexImage(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11625 void ecb_glClearTexImage(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11626 {
11627 GLuint texture;
11628 GLint level;
11629 GLenum format;
11630 GLenum type;
11631 ErlNifBinary data;
11632 void *data_idx;
11633 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5811,"texture");
11634 if(!enif_get_int(env, argv[1], &level)) Badarg(5811,"level");
11635 if(!enif_get_uint(env, argv[2], &format)) Badarg(5811,"format");
11636 if(!enif_get_uint(env, argv[3], &type)) Badarg(5811,"type");
11637 if(!egl_get_ptr(env, argv[4], (void **) &data_idx)) {
11638 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[4], &data))
11639 data_idx = (void *) data.data;
11640 else Badarg(5811,"data");
11641 }
11642 weglClearTexImage(texture,level,format,type,data_idx);
11643 }
11644
ecb_glClearTexSubImage(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11645 void ecb_glClearTexSubImage(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11646 {
11647 GLuint texture;
11648 GLint level;
11649 GLint xoffset;
11650 GLint yoffset;
11651 GLint zoffset;
11652 GLsizei width;
11653 GLsizei height;
11654 GLsizei depth;
11655 GLenum format;
11656 GLenum type;
11657 ErlNifBinary data;
11658 void *data_idx;
11659 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5813,"texture");
11660 if(!enif_get_int(env, argv[1], &level)) Badarg(5813,"level");
11661 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5813,"xoffset");
11662 if(!enif_get_int(env, argv[3], &yoffset)) Badarg(5813,"yoffset");
11663 if(!enif_get_int(env, argv[4], &zoffset)) Badarg(5813,"zoffset");
11664 if(!enif_get_int(env, argv[5], &width)) Badarg(5813,"width");
11665 if(!enif_get_int(env, argv[6], &height)) Badarg(5813,"height");
11666 if(!enif_get_int(env, argv[7], &depth)) Badarg(5813,"depth");
11667 if(!enif_get_uint(env, argv[8], &format)) Badarg(5813,"format");
11668 if(!enif_get_uint(env, argv[9], &type)) Badarg(5813,"type");
11669 if(!egl_get_ptr(env, argv[10], (void **) &data_idx)) {
11670 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[10], &data))
11671 data_idx = (void *) data.data;
11672 else Badarg(5813,"data");
11673 }
11674 weglClearTexSubImage(texture,level,xoffset,yoffset,zoffset,width,height,depth,format,type,data_idx);
11675 }
11676
ecb_glBindBuffersBase(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11677 void ecb_glBindBuffersBase(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11678 {
11679 GLenum target;
11680 GLuint first;
11681 GLsizei count;
11682 GLuint *buffers;
11683 if(!enif_get_uint(env, argv[0], &target)) Badarg(5815,"target");
11684 if(!enif_get_uint(env, argv[1], &first)) Badarg(5815,"first");
11685 if(!enif_get_int(env, argv[2], &count)) Badarg(5815,"count");
11686 if(!enif_is_list(env, argv[3])) Badarg(5815, "buffers")
11687 else {
11688 ERL_NIF_TERM buffers_l, buffers_h, buffers_t;
11689 std::vector <GLuint> buffers_vec;
11690 GLuint buffers_tmp;
11691 buffers_l = argv[3];
11692 while(enif_get_list_cell(env, buffers_l, &buffers_h, &buffers_t)) {
11693 if(!enif_get_uint(env, buffers_h, &buffers_tmp)) Badarg(5815,"buffers");
11694 buffers_vec.push_back(buffers_tmp);
11695 buffers_l = buffers_t;
11696 };
11697 buffers = buffers_vec.data();
11698 }
11699 weglBindBuffersBase(target,first,count,buffers);
11700 }
11701
ecb_glBindBuffersRange(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11702 void ecb_glBindBuffersRange(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11703 {
11704 GLenum target;
11705 GLuint first;
11706 GLsizei count;
11707 GLuint *buffers;
11708 GLintptr *offsets;
11709 GLsizeiptr *sizes;
11710 if(!enif_get_uint(env, argv[0], &target)) Badarg(5816,"target");
11711 if(!enif_get_uint(env, argv[1], &first)) Badarg(5816,"first");
11712 if(!enif_get_int(env, argv[2], &count)) Badarg(5816,"count");
11713 if(!enif_is_list(env, argv[3])) Badarg(5816, "buffers")
11714 else {
11715 ERL_NIF_TERM buffers_l, buffers_h, buffers_t;
11716 std::vector <GLuint> buffers_vec;
11717 GLuint buffers_tmp;
11718 buffers_l = argv[3];
11719 while(enif_get_list_cell(env, buffers_l, &buffers_h, &buffers_t)) {
11720 if(!enif_get_uint(env, buffers_h, &buffers_tmp)) Badarg(5816,"buffers");
11721 buffers_vec.push_back(buffers_tmp);
11722 buffers_l = buffers_t;
11723 };
11724 buffers = buffers_vec.data();
11725 }
11726 if(!enif_is_list(env, argv[4])) Badarg(5816, "offsets")
11727 else {
11728 ERL_NIF_TERM offsets_l, offsets_h, offsets_t;
11729 std::vector <GLintptr> offsets_vec;
11730 GLintptr offsets_tmp;
11731 offsets_l = argv[4];
11732 while(enif_get_list_cell(env, offsets_l, &offsets_h, &offsets_t)) {
11733 if(!egl_get_word(env, offsets_h,(egl_word *) &offsets_tmp)) Badarg(5816,"offsets");
11734 offsets_vec.push_back(offsets_tmp);
11735 offsets_l = offsets_t;
11736 };
11737 offsets = offsets_vec.data();
11738 }
11739 if(!enif_is_list(env, argv[5])) Badarg(5816, "sizes")
11740 else {
11741 ERL_NIF_TERM sizes_l, sizes_h, sizes_t;
11742 std::vector <GLsizeiptr> sizes_vec;
11743 GLsizeiptr sizes_tmp;
11744 sizes_l = argv[5];
11745 while(enif_get_list_cell(env, sizes_l, &sizes_h, &sizes_t)) {
11746 if(!egl_get_word(env, sizes_h,(egl_word *) &sizes_tmp)) Badarg(5816,"sizes");
11747 sizes_vec.push_back(sizes_tmp);
11748 sizes_l = sizes_t;
11749 };
11750 sizes = sizes_vec.data();
11751 }
11752 weglBindBuffersRange(target,first,count,buffers,offsets,sizes);
11753 }
11754
ecb_glBindTextures(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11755 void ecb_glBindTextures(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11756 {
11757 GLuint first;
11758 GLsizei count;
11759 GLuint *textures;
11760 if(!enif_get_uint(env, argv[0], &first)) Badarg(5817,"first");
11761 if(!enif_get_int(env, argv[1], &count)) Badarg(5817,"count");
11762 if(!enif_is_list(env, argv[2])) Badarg(5817, "textures")
11763 else {
11764 ERL_NIF_TERM textures_l, textures_h, textures_t;
11765 std::vector <GLuint> textures_vec;
11766 GLuint textures_tmp;
11767 textures_l = argv[2];
11768 while(enif_get_list_cell(env, textures_l, &textures_h, &textures_t)) {
11769 if(!enif_get_uint(env, textures_h, &textures_tmp)) Badarg(5817,"textures");
11770 textures_vec.push_back(textures_tmp);
11771 textures_l = textures_t;
11772 };
11773 textures = textures_vec.data();
11774 }
11775 weglBindTextures(first,count,textures);
11776 }
11777
ecb_glBindSamplers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11778 void ecb_glBindSamplers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11779 {
11780 GLuint first;
11781 GLsizei count;
11782 GLuint *samplers;
11783 if(!enif_get_uint(env, argv[0], &first)) Badarg(5818,"first");
11784 if(!enif_get_int(env, argv[1], &count)) Badarg(5818,"count");
11785 if(!enif_is_list(env, argv[2])) Badarg(5818, "samplers")
11786 else {
11787 ERL_NIF_TERM samplers_l, samplers_h, samplers_t;
11788 std::vector <GLuint> samplers_vec;
11789 GLuint samplers_tmp;
11790 samplers_l = argv[2];
11791 while(enif_get_list_cell(env, samplers_l, &samplers_h, &samplers_t)) {
11792 if(!enif_get_uint(env, samplers_h, &samplers_tmp)) Badarg(5818,"samplers");
11793 samplers_vec.push_back(samplers_tmp);
11794 samplers_l = samplers_t;
11795 };
11796 samplers = samplers_vec.data();
11797 }
11798 weglBindSamplers(first,count,samplers);
11799 }
11800
ecb_glBindImageTextures(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11801 void ecb_glBindImageTextures(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11802 {
11803 GLuint first;
11804 GLsizei count;
11805 GLuint *textures;
11806 if(!enif_get_uint(env, argv[0], &first)) Badarg(5819,"first");
11807 if(!enif_get_int(env, argv[1], &count)) Badarg(5819,"count");
11808 if(!enif_is_list(env, argv[2])) Badarg(5819, "textures")
11809 else {
11810 ERL_NIF_TERM textures_l, textures_h, textures_t;
11811 std::vector <GLuint> textures_vec;
11812 GLuint textures_tmp;
11813 textures_l = argv[2];
11814 while(enif_get_list_cell(env, textures_l, &textures_h, &textures_t)) {
11815 if(!enif_get_uint(env, textures_h, &textures_tmp)) Badarg(5819,"textures");
11816 textures_vec.push_back(textures_tmp);
11817 textures_l = textures_t;
11818 };
11819 textures = textures_vec.data();
11820 }
11821 weglBindImageTextures(first,count,textures);
11822 }
11823
ecb_glBindVertexBuffers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11824 void ecb_glBindVertexBuffers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11825 {
11826 GLuint first;
11827 GLsizei count;
11828 GLuint *buffers;
11829 GLintptr *offsets;
11830 GLsizei *strides;
11831 if(!enif_get_uint(env, argv[0], &first)) Badarg(5820,"first");
11832 if(!enif_get_int(env, argv[1], &count)) Badarg(5820,"count");
11833 if(!enif_is_list(env, argv[2])) Badarg(5820, "buffers")
11834 else {
11835 ERL_NIF_TERM buffers_l, buffers_h, buffers_t;
11836 std::vector <GLuint> buffers_vec;
11837 GLuint buffers_tmp;
11838 buffers_l = argv[2];
11839 while(enif_get_list_cell(env, buffers_l, &buffers_h, &buffers_t)) {
11840 if(!enif_get_uint(env, buffers_h, &buffers_tmp)) Badarg(5820,"buffers");
11841 buffers_vec.push_back(buffers_tmp);
11842 buffers_l = buffers_t;
11843 };
11844 buffers = buffers_vec.data();
11845 }
11846 if(!enif_is_list(env, argv[3])) Badarg(5820, "offsets")
11847 else {
11848 ERL_NIF_TERM offsets_l, offsets_h, offsets_t;
11849 std::vector <GLintptr> offsets_vec;
11850 GLintptr offsets_tmp;
11851 offsets_l = argv[3];
11852 while(enif_get_list_cell(env, offsets_l, &offsets_h, &offsets_t)) {
11853 if(!egl_get_word(env, offsets_h,(egl_word *) &offsets_tmp)) Badarg(5820,"offsets");
11854 offsets_vec.push_back(offsets_tmp);
11855 offsets_l = offsets_t;
11856 };
11857 offsets = offsets_vec.data();
11858 }
11859 if(!enif_is_list(env, argv[4])) Badarg(5820, "strides")
11860 else {
11861 ERL_NIF_TERM strides_l, strides_h, strides_t;
11862 std::vector <GLsizei> strides_vec;
11863 GLsizei strides_tmp;
11864 strides_l = argv[4];
11865 while(enif_get_list_cell(env, strides_l, &strides_h, &strides_t)) {
11866 if(!enif_get_int(env, strides_h, &strides_tmp)) Badarg(5820,"strides");
11867 strides_vec.push_back(strides_tmp);
11868 strides_l = strides_t;
11869 };
11870 strides = strides_vec.data();
11871 }
11872 weglBindVertexBuffers(first,count,buffers,offsets,strides);
11873 }
11874
ecb_glClipControl(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11875 void ecb_glClipControl(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11876 {
11877 GLenum origin;
11878 GLenum depth;
11879 if(!enif_get_uint(env, argv[0], &origin)) Badarg(5821,"origin");
11880 if(!enif_get_uint(env, argv[1], &depth)) Badarg(5821,"depth");
11881 weglClipControl(origin,depth);
11882 }
11883
ecb_glCreateTransformFeedbacks(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11884 void ecb_glCreateTransformFeedbacks(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11885 {
11886 ERL_NIF_TERM reply;
11887 GLsizei n;
11888 if(!enif_get_int(env, argv[0], &n)) Badarg(5822,"n");
11889 std::vector <GLuint> ids (n);
11890 std::vector <ERL_NIF_TERM> ids_ts (n);
11891 weglCreateTransformFeedbacks(n,ids.data());
11892 for(int ri=0; ri < (int) n; ri++)
11893 ids_ts[ri] = enif_make_int(env, ids[ri]);
11894 reply = enif_make_list_from_array(env, ids_ts.data(), n);
11895 enif_send(NULL, self, env,
11896 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
11897 }
11898
ecb_glTransformFeedbackBufferBase(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11899 void ecb_glTransformFeedbackBufferBase(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11900 {
11901 GLuint xfb;
11902 GLuint index;
11903 GLuint buffer;
11904 if(!enif_get_uint(env, argv[0], &xfb)) Badarg(5823,"xfb");
11905 if(!enif_get_uint(env, argv[1], &index)) Badarg(5823,"index");
11906 if(!enif_get_uint(env, argv[2], &buffer)) Badarg(5823,"buffer");
11907 weglTransformFeedbackBufferBase(xfb,index,buffer);
11908 }
11909
ecb_glTransformFeedbackBufferRange(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11910 void ecb_glTransformFeedbackBufferRange(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11911 {
11912 GLuint xfb;
11913 GLuint index;
11914 GLuint buffer;
11915 GLintptr offset;
11916 GLsizeiptr size;
11917 if(!enif_get_uint(env, argv[0], &xfb)) Badarg(5824,"xfb");
11918 if(!enif_get_uint(env, argv[1], &index)) Badarg(5824,"index");
11919 if(!enif_get_uint(env, argv[2], &buffer)) Badarg(5824,"buffer");
11920 if(!egl_get_word(env, argv[3], (egl_word *) &offset)) Badarg(5824,"offset");
11921 if(!egl_get_word(env, argv[4], (egl_word *) &size)) Badarg(5824,"size");
11922 weglTransformFeedbackBufferRange(xfb,index,buffer,offset,size);
11923 }
11924
ecb_glCreateBuffers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11925 void ecb_glCreateBuffers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11926 {
11927 ERL_NIF_TERM reply;
11928 GLsizei n;
11929 if(!enif_get_int(env, argv[0], &n)) Badarg(5825,"n");
11930 std::vector <GLuint> buffers (n);
11931 std::vector <ERL_NIF_TERM> buffers_ts (n);
11932 weglCreateBuffers(n,buffers.data());
11933 for(int ri=0; ri < (int) n; ri++)
11934 buffers_ts[ri] = enif_make_int(env, buffers[ri]);
11935 reply = enif_make_list_from_array(env, buffers_ts.data(), n);
11936 enif_send(NULL, self, env,
11937 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
11938 }
11939
ecb_glFlushMappedNamedBufferRange(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11940 void ecb_glFlushMappedNamedBufferRange(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11941 {
11942 GLuint buffer;
11943 GLintptr offset;
11944 GLsizeiptr length;
11945 if(!enif_get_uint(env, argv[0], &buffer)) Badarg(5826,"buffer");
11946 if(!egl_get_word(env, argv[1], (egl_word *) &offset)) Badarg(5826,"offset");
11947 if(!egl_get_word(env, argv[2], (egl_word *) &length)) Badarg(5826,"length");
11948 weglFlushMappedNamedBufferRange(buffer,offset,length);
11949 }
11950
ecb_glCreateFramebuffers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11951 void ecb_glCreateFramebuffers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11952 {
11953 ERL_NIF_TERM reply;
11954 GLsizei n;
11955 if(!enif_get_int(env, argv[0], &n)) Badarg(5827,"n");
11956 std::vector <GLuint> framebuffers (n);
11957 std::vector <ERL_NIF_TERM> framebuffers_ts (n);
11958 weglCreateFramebuffers(n,framebuffers.data());
11959 for(int ri=0; ri < (int) n; ri++)
11960 framebuffers_ts[ri] = enif_make_int(env, framebuffers[ri]);
11961 reply = enif_make_list_from_array(env, framebuffers_ts.data(), n);
11962 enif_send(NULL, self, env,
11963 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
11964 }
11965
ecb_glCreateRenderbuffers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11966 void ecb_glCreateRenderbuffers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11967 {
11968 ERL_NIF_TERM reply;
11969 GLsizei n;
11970 if(!enif_get_int(env, argv[0], &n)) Badarg(5828,"n");
11971 std::vector <GLuint> renderbuffers (n);
11972 std::vector <ERL_NIF_TERM> renderbuffers_ts (n);
11973 weglCreateRenderbuffers(n,renderbuffers.data());
11974 for(int ri=0; ri < (int) n; ri++)
11975 renderbuffers_ts[ri] = enif_make_int(env, renderbuffers[ri]);
11976 reply = enif_make_list_from_array(env, renderbuffers_ts.data(), n);
11977 enif_send(NULL, self, env,
11978 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
11979 }
11980
ecb_glCreateTextures(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11981 void ecb_glCreateTextures(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11982 {
11983 ERL_NIF_TERM reply;
11984 GLenum target;
11985 GLsizei n;
11986 if(!enif_get_uint(env, argv[0], &target)) Badarg(5829,"target");
11987 if(!enif_get_int(env, argv[1], &n)) Badarg(5829,"n");
11988 std::vector <GLuint> textures (n);
11989 std::vector <ERL_NIF_TERM> textures_ts (n);
11990 weglCreateTextures(target,n,textures.data());
11991 for(int ri=0; ri < (int) n; ri++)
11992 textures_ts[ri] = enif_make_int(env, textures[ri]);
11993 reply = enif_make_list_from_array(env, textures_ts.data(), n);
11994 enif_send(NULL, self, env,
11995 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
11996 }
11997
ecb_glTextureBuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])11998 void ecb_glTextureBuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
11999 {
12000 GLuint texture;
12001 GLenum internalformat;
12002 GLuint buffer;
12003 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5830,"texture");
12004 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5830,"internalformat");
12005 if(!enif_get_uint(env, argv[2], &buffer)) Badarg(5830,"buffer");
12006 weglTextureBuffer(texture,internalformat,buffer);
12007 }
12008
ecb_glTextureBufferRange(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12009 void ecb_glTextureBufferRange(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12010 {
12011 GLuint texture;
12012 GLenum internalformat;
12013 GLuint buffer;
12014 GLintptr offset;
12015 GLsizeiptr size;
12016 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5831,"texture");
12017 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5831,"internalformat");
12018 if(!enif_get_uint(env, argv[2], &buffer)) Badarg(5831,"buffer");
12019 if(!egl_get_word(env, argv[3], (egl_word *) &offset)) Badarg(5831,"offset");
12020 if(!egl_get_word(env, argv[4], (egl_word *) &size)) Badarg(5831,"size");
12021 weglTextureBufferRange(texture,internalformat,buffer,offset,size);
12022 }
12023
ecb_glCompressedTextureSubImage1D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12024 void ecb_glCompressedTextureSubImage1D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12025 {
12026 GLuint texture;
12027 GLint level;
12028 GLint xoffset;
12029 GLsizei width;
12030 GLenum format;
12031 GLsizei imageSize;
12032 ErlNifBinary data;
12033 void *data_idx;
12034 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5832,"texture");
12035 if(!enif_get_int(env, argv[1], &level)) Badarg(5832,"level");
12036 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5832,"xoffset");
12037 if(!enif_get_int(env, argv[3], &width)) Badarg(5832,"width");
12038 if(!enif_get_uint(env, argv[4], &format)) Badarg(5832,"format");
12039 if(!enif_get_int(env, argv[5], &imageSize)) Badarg(5832,"imageSize");
12040 if(!egl_get_ptr(env, argv[6], (void **) &data_idx)) {
12041 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[6], &data))
12042 data_idx = (void *) data.data;
12043 else Badarg(5832,"data");
12044 }
12045 weglCompressedTextureSubImage1D(texture,level,xoffset,width,format,imageSize,data_idx);
12046 }
12047
ecb_glCompressedTextureSubImage2D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12048 void ecb_glCompressedTextureSubImage2D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12049 {
12050 GLuint texture;
12051 GLint level;
12052 GLint xoffset;
12053 GLint yoffset;
12054 GLsizei width;
12055 GLsizei height;
12056 GLenum format;
12057 GLsizei imageSize;
12058 ErlNifBinary data;
12059 void *data_idx;
12060 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5834,"texture");
12061 if(!enif_get_int(env, argv[1], &level)) Badarg(5834,"level");
12062 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5834,"xoffset");
12063 if(!enif_get_int(env, argv[3], &yoffset)) Badarg(5834,"yoffset");
12064 if(!enif_get_int(env, argv[4], &width)) Badarg(5834,"width");
12065 if(!enif_get_int(env, argv[5], &height)) Badarg(5834,"height");
12066 if(!enif_get_uint(env, argv[6], &format)) Badarg(5834,"format");
12067 if(!enif_get_int(env, argv[7], &imageSize)) Badarg(5834,"imageSize");
12068 if(!egl_get_ptr(env, argv[8], (void **) &data_idx)) {
12069 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[8], &data))
12070 data_idx = (void *) data.data;
12071 else Badarg(5834,"data");
12072 }
12073 weglCompressedTextureSubImage2D(texture,level,xoffset,yoffset,width,height,format,imageSize,data_idx);
12074 }
12075
ecb_glCompressedTextureSubImage3D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12076 void ecb_glCompressedTextureSubImage3D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12077 {
12078 GLuint texture;
12079 GLint level;
12080 GLint xoffset;
12081 GLint yoffset;
12082 GLint zoffset;
12083 GLsizei width;
12084 GLsizei height;
12085 GLsizei depth;
12086 GLenum format;
12087 GLsizei imageSize;
12088 ErlNifBinary data;
12089 void *data_idx;
12090 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5836,"texture");
12091 if(!enif_get_int(env, argv[1], &level)) Badarg(5836,"level");
12092 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5836,"xoffset");
12093 if(!enif_get_int(env, argv[3], &yoffset)) Badarg(5836,"yoffset");
12094 if(!enif_get_int(env, argv[4], &zoffset)) Badarg(5836,"zoffset");
12095 if(!enif_get_int(env, argv[5], &width)) Badarg(5836,"width");
12096 if(!enif_get_int(env, argv[6], &height)) Badarg(5836,"height");
12097 if(!enif_get_int(env, argv[7], &depth)) Badarg(5836,"depth");
12098 if(!enif_get_uint(env, argv[8], &format)) Badarg(5836,"format");
12099 if(!enif_get_int(env, argv[9], &imageSize)) Badarg(5836,"imageSize");
12100 if(!egl_get_ptr(env, argv[10], (void **) &data_idx)) {
12101 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[10], &data))
12102 data_idx = (void *) data.data;
12103 else Badarg(5836,"data");
12104 }
12105 weglCompressedTextureSubImage3D(texture,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data_idx);
12106 }
12107
ecb_glGenerateTextureMipmap(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12108 void ecb_glGenerateTextureMipmap(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12109 {
12110 GLuint texture;
12111 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5838,"texture");
12112 weglGenerateTextureMipmap(texture);
12113 }
12114
ecb_glBindTextureUnit(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12115 void ecb_glBindTextureUnit(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12116 {
12117 GLuint unit;
12118 GLuint texture;
12119 if(!enif_get_uint(env, argv[0], &unit)) Badarg(5839,"unit");
12120 if(!enif_get_uint(env, argv[1], &texture)) Badarg(5839,"texture");
12121 weglBindTextureUnit(unit,texture);
12122 }
12123
ecb_glCreateVertexArrays(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12124 void ecb_glCreateVertexArrays(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12125 {
12126 ERL_NIF_TERM reply;
12127 GLsizei n;
12128 if(!enif_get_int(env, argv[0], &n)) Badarg(5840,"n");
12129 std::vector <GLuint> arrays (n);
12130 std::vector <ERL_NIF_TERM> arrays_ts (n);
12131 weglCreateVertexArrays(n,arrays.data());
12132 for(int ri=0; ri < (int) n; ri++)
12133 arrays_ts[ri] = enif_make_int(env, arrays[ri]);
12134 reply = enif_make_list_from_array(env, arrays_ts.data(), n);
12135 enif_send(NULL, self, env,
12136 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
12137 }
12138
ecb_glDisableVertexArrayAttrib(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12139 void ecb_glDisableVertexArrayAttrib(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12140 {
12141 GLuint vaobj;
12142 GLuint index;
12143 if(!enif_get_uint(env, argv[0], &vaobj)) Badarg(5841,"vaobj");
12144 if(!enif_get_uint(env, argv[1], &index)) Badarg(5841,"index");
12145 weglDisableVertexArrayAttrib(vaobj,index);
12146 }
12147
ecb_glEnableVertexArrayAttrib(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12148 void ecb_glEnableVertexArrayAttrib(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12149 {
12150 GLuint vaobj;
12151 GLuint index;
12152 if(!enif_get_uint(env, argv[0], &vaobj)) Badarg(5842,"vaobj");
12153 if(!enif_get_uint(env, argv[1], &index)) Badarg(5842,"index");
12154 weglEnableVertexArrayAttrib(vaobj,index);
12155 }
12156
ecb_glVertexArrayElementBuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12157 void ecb_glVertexArrayElementBuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12158 {
12159 GLuint vaobj;
12160 GLuint buffer;
12161 if(!enif_get_uint(env, argv[0], &vaobj)) Badarg(5843,"vaobj");
12162 if(!enif_get_uint(env, argv[1], &buffer)) Badarg(5843,"buffer");
12163 weglVertexArrayElementBuffer(vaobj,buffer);
12164 }
12165
ecb_glVertexArrayVertexBuffer(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12166 void ecb_glVertexArrayVertexBuffer(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12167 {
12168 GLuint vaobj;
12169 GLuint bindingindex;
12170 GLuint buffer;
12171 GLintptr offset;
12172 GLsizei stride;
12173 if(!enif_get_uint(env, argv[0], &vaobj)) Badarg(5844,"vaobj");
12174 if(!enif_get_uint(env, argv[1], &bindingindex)) Badarg(5844,"bindingindex");
12175 if(!enif_get_uint(env, argv[2], &buffer)) Badarg(5844,"buffer");
12176 if(!egl_get_word(env, argv[3], (egl_word *) &offset)) Badarg(5844,"offset");
12177 if(!enif_get_int(env, argv[4], &stride)) Badarg(5844,"stride");
12178 weglVertexArrayVertexBuffer(vaobj,bindingindex,buffer,offset,stride);
12179 }
12180
ecb_glVertexArrayVertexBuffers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12181 void ecb_glVertexArrayVertexBuffers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12182 {
12183 GLuint vaobj;
12184 GLuint first;
12185 GLsizei count;
12186 GLuint *buffers;
12187 GLintptr *offsets;
12188 GLsizei *strides;
12189 if(!enif_get_uint(env, argv[0], &vaobj)) Badarg(5845,"vaobj");
12190 if(!enif_get_uint(env, argv[1], &first)) Badarg(5845,"first");
12191 if(!enif_get_int(env, argv[2], &count)) Badarg(5845,"count");
12192 if(!enif_is_list(env, argv[3])) Badarg(5845, "buffers")
12193 else {
12194 ERL_NIF_TERM buffers_l, buffers_h, buffers_t;
12195 std::vector <GLuint> buffers_vec;
12196 GLuint buffers_tmp;
12197 buffers_l = argv[3];
12198 while(enif_get_list_cell(env, buffers_l, &buffers_h, &buffers_t)) {
12199 if(!enif_get_uint(env, buffers_h, &buffers_tmp)) Badarg(5845,"buffers");
12200 buffers_vec.push_back(buffers_tmp);
12201 buffers_l = buffers_t;
12202 };
12203 buffers = buffers_vec.data();
12204 }
12205 if(!enif_is_list(env, argv[4])) Badarg(5845, "offsets")
12206 else {
12207 ERL_NIF_TERM offsets_l, offsets_h, offsets_t;
12208 std::vector <GLintptr> offsets_vec;
12209 GLintptr offsets_tmp;
12210 offsets_l = argv[4];
12211 while(enif_get_list_cell(env, offsets_l, &offsets_h, &offsets_t)) {
12212 if(!egl_get_word(env, offsets_h,(egl_word *) &offsets_tmp)) Badarg(5845,"offsets");
12213 offsets_vec.push_back(offsets_tmp);
12214 offsets_l = offsets_t;
12215 };
12216 offsets = offsets_vec.data();
12217 }
12218 if(!enif_is_list(env, argv[5])) Badarg(5845, "strides")
12219 else {
12220 ERL_NIF_TERM strides_l, strides_h, strides_t;
12221 std::vector <GLsizei> strides_vec;
12222 GLsizei strides_tmp;
12223 strides_l = argv[5];
12224 while(enif_get_list_cell(env, strides_l, &strides_h, &strides_t)) {
12225 if(!enif_get_int(env, strides_h, &strides_tmp)) Badarg(5845,"strides");
12226 strides_vec.push_back(strides_tmp);
12227 strides_l = strides_t;
12228 };
12229 strides = strides_vec.data();
12230 }
12231 weglVertexArrayVertexBuffers(vaobj,first,count,buffers,offsets,strides);
12232 }
12233
ecb_glVertexArrayAttribBinding(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12234 void ecb_glVertexArrayAttribBinding(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12235 {
12236 GLuint vaobj;
12237 GLuint attribindex;
12238 GLuint bindingindex;
12239 if(!enif_get_uint(env, argv[0], &vaobj)) Badarg(5846,"vaobj");
12240 if(!enif_get_uint(env, argv[1], &attribindex)) Badarg(5846,"attribindex");
12241 if(!enif_get_uint(env, argv[2], &bindingindex)) Badarg(5846,"bindingindex");
12242 weglVertexArrayAttribBinding(vaobj,attribindex,bindingindex);
12243 }
12244
ecb_glVertexArrayAttribFormat(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12245 void ecb_glVertexArrayAttribFormat(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12246 {
12247 GLuint vaobj;
12248 GLuint attribindex;
12249 GLint size;
12250 GLenum type;
12251 GLboolean normalized;
12252 GLuint relativeoffset;
12253 if(!enif_get_uint(env, argv[0], &vaobj)) Badarg(5847,"vaobj");
12254 if(!enif_get_uint(env, argv[1], &attribindex)) Badarg(5847,"attribindex");
12255 if(!enif_get_int(env, argv[2], &size)) Badarg(5847,"size");
12256 if(!enif_get_uint(env, argv[3], &type)) Badarg(5847,"type");
12257 if(!egl_get_ubyte(env, argv[4], &normalized)) Badarg(5847,"normalized");
12258 if(!enif_get_uint(env, argv[5], &relativeoffset)) Badarg(5847,"relativeoffset");
12259 weglVertexArrayAttribFormat(vaobj,attribindex,size,type,normalized,relativeoffset);
12260 }
12261
ecb_glVertexArrayAttribIFormat(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12262 void ecb_glVertexArrayAttribIFormat(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12263 {
12264 GLuint vaobj;
12265 GLuint attribindex;
12266 GLint size;
12267 GLenum type;
12268 GLuint relativeoffset;
12269 if(!enif_get_uint(env, argv[0], &vaobj)) Badarg(5848,"vaobj");
12270 if(!enif_get_uint(env, argv[1], &attribindex)) Badarg(5848,"attribindex");
12271 if(!enif_get_int(env, argv[2], &size)) Badarg(5848,"size");
12272 if(!enif_get_uint(env, argv[3], &type)) Badarg(5848,"type");
12273 if(!enif_get_uint(env, argv[4], &relativeoffset)) Badarg(5848,"relativeoffset");
12274 weglVertexArrayAttribIFormat(vaobj,attribindex,size,type,relativeoffset);
12275 }
12276
ecb_glVertexArrayAttribLFormat(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12277 void ecb_glVertexArrayAttribLFormat(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12278 {
12279 GLuint vaobj;
12280 GLuint attribindex;
12281 GLint size;
12282 GLenum type;
12283 GLuint relativeoffset;
12284 if(!enif_get_uint(env, argv[0], &vaobj)) Badarg(5849,"vaobj");
12285 if(!enif_get_uint(env, argv[1], &attribindex)) Badarg(5849,"attribindex");
12286 if(!enif_get_int(env, argv[2], &size)) Badarg(5849,"size");
12287 if(!enif_get_uint(env, argv[3], &type)) Badarg(5849,"type");
12288 if(!enif_get_uint(env, argv[4], &relativeoffset)) Badarg(5849,"relativeoffset");
12289 weglVertexArrayAttribLFormat(vaobj,attribindex,size,type,relativeoffset);
12290 }
12291
ecb_glVertexArrayBindingDivisor(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12292 void ecb_glVertexArrayBindingDivisor(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12293 {
12294 GLuint vaobj;
12295 GLuint bindingindex;
12296 GLuint divisor;
12297 if(!enif_get_uint(env, argv[0], &vaobj)) Badarg(5850,"vaobj");
12298 if(!enif_get_uint(env, argv[1], &bindingindex)) Badarg(5850,"bindingindex");
12299 if(!enif_get_uint(env, argv[2], &divisor)) Badarg(5850,"divisor");
12300 weglVertexArrayBindingDivisor(vaobj,bindingindex,divisor);
12301 }
12302
ecb_glCreateSamplers(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12303 void ecb_glCreateSamplers(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12304 {
12305 ERL_NIF_TERM reply;
12306 GLsizei n;
12307 if(!enif_get_int(env, argv[0], &n)) Badarg(5851,"n");
12308 std::vector <GLuint> samplers (n);
12309 std::vector <ERL_NIF_TERM> samplers_ts (n);
12310 weglCreateSamplers(n,samplers.data());
12311 for(int ri=0; ri < (int) n; ri++)
12312 samplers_ts[ri] = enif_make_int(env, samplers[ri]);
12313 reply = enif_make_list_from_array(env, samplers_ts.data(), n);
12314 enif_send(NULL, self, env,
12315 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
12316 }
12317
ecb_glCreateProgramPipelines(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12318 void ecb_glCreateProgramPipelines(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12319 {
12320 ERL_NIF_TERM reply;
12321 GLsizei n;
12322 if(!enif_get_int(env, argv[0], &n)) Badarg(5852,"n");
12323 std::vector <GLuint> pipelines (n);
12324 std::vector <ERL_NIF_TERM> pipelines_ts (n);
12325 weglCreateProgramPipelines(n,pipelines.data());
12326 for(int ri=0; ri < (int) n; ri++)
12327 pipelines_ts[ri] = enif_make_int(env, pipelines[ri]);
12328 reply = enif_make_list_from_array(env, pipelines_ts.data(), n);
12329 enif_send(NULL, self, env,
12330 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
12331 }
12332
ecb_glCreateQueries(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12333 void ecb_glCreateQueries(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12334 {
12335 ERL_NIF_TERM reply;
12336 GLenum target;
12337 GLsizei n;
12338 if(!enif_get_uint(env, argv[0], &target)) Badarg(5853,"target");
12339 if(!enif_get_int(env, argv[1], &n)) Badarg(5853,"n");
12340 std::vector <GLuint> ids (n);
12341 std::vector <ERL_NIF_TERM> ids_ts (n);
12342 weglCreateQueries(target,n,ids.data());
12343 for(int ri=0; ri < (int) n; ri++)
12344 ids_ts[ri] = enif_make_int(env, ids[ri]);
12345 reply = enif_make_list_from_array(env, ids_ts.data(), n);
12346 enif_send(NULL, self, env,
12347 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
12348 }
12349
ecb_glGetQueryBufferObjecti64v(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12350 void ecb_glGetQueryBufferObjecti64v(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12351 {
12352 GLuint id;
12353 GLuint buffer;
12354 GLenum pname;
12355 GLintptr offset;
12356 if(!enif_get_uint(env, argv[0], &id)) Badarg(5854,"id");
12357 if(!enif_get_uint(env, argv[1], &buffer)) Badarg(5854,"buffer");
12358 if(!enif_get_uint(env, argv[2], &pname)) Badarg(5854,"pname");
12359 if(!egl_get_word(env, argv[3], (egl_word *) &offset)) Badarg(5854,"offset");
12360 weglGetQueryBufferObjecti64v(id,buffer,pname,offset);
12361 }
12362
ecb_glGetQueryBufferObjectiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12363 void ecb_glGetQueryBufferObjectiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12364 {
12365 GLuint id;
12366 GLuint buffer;
12367 GLenum pname;
12368 GLintptr offset;
12369 if(!enif_get_uint(env, argv[0], &id)) Badarg(5855,"id");
12370 if(!enif_get_uint(env, argv[1], &buffer)) Badarg(5855,"buffer");
12371 if(!enif_get_uint(env, argv[2], &pname)) Badarg(5855,"pname");
12372 if(!egl_get_word(env, argv[3], (egl_word *) &offset)) Badarg(5855,"offset");
12373 weglGetQueryBufferObjectiv(id,buffer,pname,offset);
12374 }
12375
ecb_glGetQueryBufferObjectui64v(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12376 void ecb_glGetQueryBufferObjectui64v(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12377 {
12378 GLuint id;
12379 GLuint buffer;
12380 GLenum pname;
12381 GLintptr offset;
12382 if(!enif_get_uint(env, argv[0], &id)) Badarg(5856,"id");
12383 if(!enif_get_uint(env, argv[1], &buffer)) Badarg(5856,"buffer");
12384 if(!enif_get_uint(env, argv[2], &pname)) Badarg(5856,"pname");
12385 if(!egl_get_word(env, argv[3], (egl_word *) &offset)) Badarg(5856,"offset");
12386 weglGetQueryBufferObjectui64v(id,buffer,pname,offset);
12387 }
12388
ecb_glGetQueryBufferObjectuiv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12389 void ecb_glGetQueryBufferObjectuiv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12390 {
12391 GLuint id;
12392 GLuint buffer;
12393 GLenum pname;
12394 GLintptr offset;
12395 if(!enif_get_uint(env, argv[0], &id)) Badarg(5857,"id");
12396 if(!enif_get_uint(env, argv[1], &buffer)) Badarg(5857,"buffer");
12397 if(!enif_get_uint(env, argv[2], &pname)) Badarg(5857,"pname");
12398 if(!egl_get_word(env, argv[3], (egl_word *) &offset)) Badarg(5857,"offset");
12399 weglGetQueryBufferObjectuiv(id,buffer,pname,offset);
12400 }
12401
ecb_glMemoryBarrierByRegion(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12402 void ecb_glMemoryBarrierByRegion(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12403 {
12404 GLbitfield barriers;
12405 if(!enif_get_uint(env, argv[0], &barriers)) Badarg(5858,"barriers");
12406 weglMemoryBarrierByRegion(barriers);
12407 }
12408
ecb_glGetGraphicsResetStatus(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12409 void ecb_glGetGraphicsResetStatus(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12410 {
12411 GLenum result;
12412 ERL_NIF_TERM reply;
12413 result = weglGetGraphicsResetStatus();
12414 reply = enif_make_int(env, result);
12415 enif_send(NULL, self, env,
12416 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
12417 }
12418
ecb_glTextureBarrier(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12419 void ecb_glTextureBarrier(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12420 {
12421 weglTextureBarrier();
12422 }
12423
ecb_glMultiDrawArraysIndirectCount(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12424 void ecb_glMultiDrawArraysIndirectCount(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12425 {
12426 GLenum mode;
12427 ErlNifBinary indirect;
12428 void *indirect_idx;
12429 GLintptr drawcount;
12430 GLsizei maxdrawcount;
12431 GLsizei stride;
12432 if(!enif_get_uint(env, argv[0], &mode)) Badarg(5861,"mode");
12433 if(!egl_get_ptr(env, argv[1], (void **) &indirect_idx)) {
12434 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[1], &indirect))
12435 indirect_idx = (void *) indirect.data;
12436 else Badarg(5861,"indirect");
12437 }
12438 if(!egl_get_word(env, argv[2], (egl_word *) &drawcount)) Badarg(5861,"drawcount");
12439 if(!enif_get_int(env, argv[3], &maxdrawcount)) Badarg(5861,"maxdrawcount");
12440 if(!enif_get_int(env, argv[4], &stride)) Badarg(5861,"stride");
12441 weglMultiDrawArraysIndirectCount(mode,indirect_idx,drawcount,maxdrawcount,stride);
12442 }
12443
ecb_glPolygonOffsetClamp(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12444 void ecb_glPolygonOffsetClamp(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12445 {
12446 GLfloat factor;
12447 GLfloat units;
12448 GLfloat clamp;
12449 if(!egl_get_float(env, argv[0], &factor)) Badarg(5863,"factor");
12450 if(!egl_get_float(env, argv[1], &units)) Badarg(5863,"units");
12451 if(!egl_get_float(env, argv[2], &clamp)) Badarg(5863,"clamp");
12452 weglPolygonOffsetClamp(factor,units,clamp);
12453 }
12454
ecb_glPrimitiveBoundingBoxARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12455 void ecb_glPrimitiveBoundingBoxARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12456 {
12457 GLfloat minX;
12458 GLfloat minY;
12459 GLfloat minZ;
12460 GLfloat minW;
12461 GLfloat maxX;
12462 GLfloat maxY;
12463 GLfloat maxZ;
12464 GLfloat maxW;
12465 if(!egl_get_float(env, argv[0], &minX)) Badarg(5864,"minX");
12466 if(!egl_get_float(env, argv[1], &minY)) Badarg(5864,"minY");
12467 if(!egl_get_float(env, argv[2], &minZ)) Badarg(5864,"minZ");
12468 if(!egl_get_float(env, argv[3], &minW)) Badarg(5864,"minW");
12469 if(!egl_get_float(env, argv[4], &maxX)) Badarg(5864,"maxX");
12470 if(!egl_get_float(env, argv[5], &maxY)) Badarg(5864,"maxY");
12471 if(!egl_get_float(env, argv[6], &maxZ)) Badarg(5864,"maxZ");
12472 if(!egl_get_float(env, argv[7], &maxW)) Badarg(5864,"maxW");
12473 weglPrimitiveBoundingBoxARB(minX,minY,minZ,minW,maxX,maxY,maxZ,maxW);
12474 }
12475
ecb_glMakeTextureHandleResidentARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12476 void ecb_glMakeTextureHandleResidentARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12477 {
12478 GLuint64 handle;
12479 if(!enif_get_uint64(env, argv[0], (egl_uint64_t *) &handle)) Badarg(5865,"handle");
12480 weglMakeTextureHandleResidentARB(handle);
12481 }
12482
ecb_glMakeTextureHandleNonResidentARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12483 void ecb_glMakeTextureHandleNonResidentARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12484 {
12485 GLuint64 handle;
12486 if(!enif_get_uint64(env, argv[0], (egl_uint64_t *) &handle)) Badarg(5866,"handle");
12487 weglMakeTextureHandleNonResidentARB(handle);
12488 }
12489
ecb_glGetImageHandleARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12490 void ecb_glGetImageHandleARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12491 {
12492 GLuint64 result;
12493 ERL_NIF_TERM reply;
12494 GLuint texture;
12495 GLint level;
12496 GLboolean layered;
12497 GLint layer;
12498 GLenum format;
12499 if(!enif_get_uint(env, argv[0], &texture)) Badarg(5867,"texture");
12500 if(!enif_get_int(env, argv[1], &level)) Badarg(5867,"level");
12501 if(!egl_get_ubyte(env, argv[2], &layered)) Badarg(5867,"layered");
12502 if(!enif_get_int(env, argv[3], &layer)) Badarg(5867,"layer");
12503 if(!enif_get_uint(env, argv[4], &format)) Badarg(5867,"format");
12504 result = weglGetImageHandleARB(texture,level,layered,layer,format);
12505 reply = enif_make_int64(env, (egl_int64_t) result);
12506 enif_send(NULL, self, env,
12507 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
12508 }
12509
ecb_glMakeImageHandleResidentARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12510 void ecb_glMakeImageHandleResidentARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12511 {
12512 GLuint64 handle;
12513 GLenum access;
12514 if(!enif_get_uint64(env, argv[0], (egl_uint64_t *) &handle)) Badarg(5868,"handle");
12515 if(!enif_get_uint(env, argv[1], &access)) Badarg(5868,"access");
12516 weglMakeImageHandleResidentARB(handle,access);
12517 }
12518
ecb_glMakeImageHandleNonResidentARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12519 void ecb_glMakeImageHandleNonResidentARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12520 {
12521 GLuint64 handle;
12522 if(!enif_get_uint64(env, argv[0], (egl_uint64_t *) &handle)) Badarg(5869,"handle");
12523 weglMakeImageHandleNonResidentARB(handle);
12524 }
12525
ecb_glUniformHandleui64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12526 void ecb_glUniformHandleui64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12527 {
12528 GLint location;
12529 GLuint64 value;
12530 if(!enif_get_int(env, argv[0], &location)) Badarg(5870,"location");
12531 if(!enif_get_uint64(env, argv[1], (egl_uint64_t *) &value)) Badarg(5870,"value");
12532 weglUniformHandleui64ARB(location,value);
12533 }
12534
ecb_glProgramUniformHandleui64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12535 void ecb_glProgramUniformHandleui64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12536 {
12537 GLuint program;
12538 GLint location;
12539 GLuint64 value;
12540 if(!enif_get_uint(env, argv[0], &program)) Badarg(5871,"program");
12541 if(!enif_get_int(env, argv[1], &location)) Badarg(5871,"location");
12542 if(!enif_get_uint64(env, argv[2], (egl_uint64_t *) &value)) Badarg(5871,"value");
12543 weglProgramUniformHandleui64ARB(program,location,value);
12544 }
12545
ecb_glIsTextureHandleResidentARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12546 void ecb_glIsTextureHandleResidentARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12547 {
12548 GLboolean result;
12549 ERL_NIF_TERM reply;
12550 GLuint64 handle;
12551 if(!enif_get_uint64(env, argv[0], (egl_uint64_t *) &handle)) Badarg(5872,"handle");
12552 result = weglIsTextureHandleResidentARB(handle);
12553 reply = enif_make_int(env, result);
12554 enif_send(NULL, self, env,
12555 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
12556 }
12557
ecb_glIsImageHandleResidentARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12558 void ecb_glIsImageHandleResidentARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12559 {
12560 GLboolean result;
12561 ERL_NIF_TERM reply;
12562 GLuint64 handle;
12563 if(!enif_get_uint64(env, argv[0], (egl_uint64_t *) &handle)) Badarg(5873,"handle");
12564 result = weglIsImageHandleResidentARB(handle);
12565 reply = enif_make_int(env, result);
12566 enif_send(NULL, self, env,
12567 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
12568 }
12569
ecb_glDispatchComputeGroupSizeARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12570 void ecb_glDispatchComputeGroupSizeARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12571 {
12572 GLuint num_groups_x;
12573 GLuint num_groups_y;
12574 GLuint num_groups_z;
12575 GLuint group_size_x;
12576 GLuint group_size_y;
12577 GLuint group_size_z;
12578 if(!enif_get_uint(env, argv[0], &num_groups_x)) Badarg(5874,"num_groups_x");
12579 if(!enif_get_uint(env, argv[1], &num_groups_y)) Badarg(5874,"num_groups_y");
12580 if(!enif_get_uint(env, argv[2], &num_groups_z)) Badarg(5874,"num_groups_z");
12581 if(!enif_get_uint(env, argv[3], &group_size_x)) Badarg(5874,"group_size_x");
12582 if(!enif_get_uint(env, argv[4], &group_size_y)) Badarg(5874,"group_size_y");
12583 if(!enif_get_uint(env, argv[5], &group_size_z)) Badarg(5874,"group_size_z");
12584 weglDispatchComputeGroupSizeARB(num_groups_x,num_groups_y,num_groups_z,group_size_x,group_size_y,group_size_z);
12585 }
12586
ecb_glProgramStringARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12587 void ecb_glProgramStringARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12588 {
12589 GLenum target;
12590 GLenum format;
12591 ErlNifBinary string;
12592 if(!enif_get_uint(env, argv[0], &target)) Badarg(5875,"target");
12593 if(!enif_get_uint(env, argv[1], &format)) Badarg(5875,"format");
12594 if(!enif_inspect_binary(env, argv[2], &string)) Badarg(5875,"string");
12595 weglProgramStringARB(target,format,(GLsizei) string.size,(void *) string.data);
12596 }
12597
ecb_glBindProgramARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12598 void ecb_glBindProgramARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12599 {
12600 GLenum target;
12601 GLuint program;
12602 if(!enif_get_uint(env, argv[0], &target)) Badarg(5876,"target");
12603 if(!enif_get_uint(env, argv[1], &program)) Badarg(5876,"program");
12604 weglBindProgramARB(target,program);
12605 }
12606
ecb_glDeleteProgramsARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12607 void ecb_glDeleteProgramsARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12608 {
12609 GLsizei n;
12610 GLuint *programs;
12611 if(!enif_get_int(env, argv[0], &n)) Badarg(5877,"n");
12612 if(!enif_is_list(env, argv[1])) Badarg(5877, "programs")
12613 else {
12614 ERL_NIF_TERM programs_l, programs_h, programs_t;
12615 std::vector <GLuint> programs_vec;
12616 GLuint programs_tmp;
12617 programs_l = argv[1];
12618 while(enif_get_list_cell(env, programs_l, &programs_h, &programs_t)) {
12619 if(!enif_get_uint(env, programs_h, &programs_tmp)) Badarg(5877,"programs");
12620 programs_vec.push_back(programs_tmp);
12621 programs_l = programs_t;
12622 };
12623 programs = programs_vec.data();
12624 }
12625 weglDeleteProgramsARB(n,programs);
12626 }
12627
ecb_glGenProgramsARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12628 void ecb_glGenProgramsARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12629 {
12630 ERL_NIF_TERM reply;
12631 GLsizei n;
12632 if(!enif_get_int(env, argv[0], &n)) Badarg(5878,"n");
12633 std::vector <GLuint> programs (n);
12634 std::vector <ERL_NIF_TERM> programs_ts (n);
12635 weglGenProgramsARB(n,programs.data());
12636 for(int ri=0; ri < (int) n; ri++)
12637 programs_ts[ri] = enif_make_int(env, programs[ri]);
12638 reply = enif_make_list_from_array(env, programs_ts.data(), n);
12639 enif_send(NULL, self, env,
12640 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
12641 }
12642
ecb_glProgramEnvParameter4dARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12643 void ecb_glProgramEnvParameter4dARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12644 {
12645 GLenum target;
12646 GLuint index;
12647 GLdouble x;
12648 GLdouble y;
12649 GLdouble z;
12650 GLdouble w;
12651 if(!enif_get_uint(env, argv[0], &target)) Badarg(5879,"target");
12652 if(!enif_get_uint(env, argv[1], &index)) Badarg(5879,"index");
12653 if(!enif_get_double(env, argv[2], &x)) Badarg(5879,"x");
12654 if(!enif_get_double(env, argv[3], &y)) Badarg(5879,"y");
12655 if(!enif_get_double(env, argv[4], &z)) Badarg(5879,"z");
12656 if(!enif_get_double(env, argv[5], &w)) Badarg(5879,"w");
12657 weglProgramEnvParameter4dARB(target,index,x,y,z,w);
12658 }
12659
ecb_glProgramEnvParameter4dvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12660 void ecb_glProgramEnvParameter4dvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12661 {
12662 GLenum target;
12663 GLuint index;
12664 GLdouble params[4];
12665 if(!enif_get_uint(env, argv[0], &target)) Badarg(5880,"target");
12666 if(!enif_get_uint(env, argv[1], &index)) Badarg(5880,"index");
12667 {
12668 int params_a;
12669 const ERL_NIF_TERM *params_t;
12670 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t) || params_a != 4) {
12671 Badarg(5880,"params");
12672 } else {
12673 int i1 = 0;
12674 if(!enif_get_double(env, params_t[i1++], ¶ms[0])) Badarg(5880,"params");
12675 if(!enif_get_double(env, params_t[i1++], ¶ms[1])) Badarg(5880,"params");
12676 if(!enif_get_double(env, params_t[i1++], ¶ms[2])) Badarg(5880,"params");
12677 if(!enif_get_double(env, params_t[i1++], ¶ms[3])) Badarg(5880,"params");
12678 }};
12679 weglProgramEnvParameter4dvARB(target,index,params);
12680 }
12681
ecb_glProgramEnvParameter4fARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12682 void ecb_glProgramEnvParameter4fARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12683 {
12684 GLenum target;
12685 GLuint index;
12686 GLfloat x;
12687 GLfloat y;
12688 GLfloat z;
12689 GLfloat w;
12690 if(!enif_get_uint(env, argv[0], &target)) Badarg(5881,"target");
12691 if(!enif_get_uint(env, argv[1], &index)) Badarg(5881,"index");
12692 if(!egl_get_float(env, argv[2], &x)) Badarg(5881,"x");
12693 if(!egl_get_float(env, argv[3], &y)) Badarg(5881,"y");
12694 if(!egl_get_float(env, argv[4], &z)) Badarg(5881,"z");
12695 if(!egl_get_float(env, argv[5], &w)) Badarg(5881,"w");
12696 weglProgramEnvParameter4fARB(target,index,x,y,z,w);
12697 }
12698
ecb_glProgramEnvParameter4fvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12699 void ecb_glProgramEnvParameter4fvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12700 {
12701 GLenum target;
12702 GLuint index;
12703 GLfloat params[4];
12704 if(!enif_get_uint(env, argv[0], &target)) Badarg(5882,"target");
12705 if(!enif_get_uint(env, argv[1], &index)) Badarg(5882,"index");
12706 {
12707 int params_a;
12708 const ERL_NIF_TERM *params_t;
12709 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t) || params_a != 4) {
12710 Badarg(5882,"params");
12711 } else {
12712 int i1 = 0;
12713 if(!egl_get_float(env, params_t[i1++], ¶ms[0])) Badarg(5882,"params");
12714 if(!egl_get_float(env, params_t[i1++], ¶ms[1])) Badarg(5882,"params");
12715 if(!egl_get_float(env, params_t[i1++], ¶ms[2])) Badarg(5882,"params");
12716 if(!egl_get_float(env, params_t[i1++], ¶ms[3])) Badarg(5882,"params");
12717 }};
12718 weglProgramEnvParameter4fvARB(target,index,params);
12719 }
12720
ecb_glProgramLocalParameter4dARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12721 void ecb_glProgramLocalParameter4dARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12722 {
12723 GLenum target;
12724 GLuint index;
12725 GLdouble x;
12726 GLdouble y;
12727 GLdouble z;
12728 GLdouble w;
12729 if(!enif_get_uint(env, argv[0], &target)) Badarg(5883,"target");
12730 if(!enif_get_uint(env, argv[1], &index)) Badarg(5883,"index");
12731 if(!enif_get_double(env, argv[2], &x)) Badarg(5883,"x");
12732 if(!enif_get_double(env, argv[3], &y)) Badarg(5883,"y");
12733 if(!enif_get_double(env, argv[4], &z)) Badarg(5883,"z");
12734 if(!enif_get_double(env, argv[5], &w)) Badarg(5883,"w");
12735 weglProgramLocalParameter4dARB(target,index,x,y,z,w);
12736 }
12737
ecb_glProgramLocalParameter4dvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12738 void ecb_glProgramLocalParameter4dvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12739 {
12740 GLenum target;
12741 GLuint index;
12742 GLdouble params[4];
12743 if(!enif_get_uint(env, argv[0], &target)) Badarg(5884,"target");
12744 if(!enif_get_uint(env, argv[1], &index)) Badarg(5884,"index");
12745 {
12746 int params_a;
12747 const ERL_NIF_TERM *params_t;
12748 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t) || params_a != 4) {
12749 Badarg(5884,"params");
12750 } else {
12751 int i1 = 0;
12752 if(!enif_get_double(env, params_t[i1++], ¶ms[0])) Badarg(5884,"params");
12753 if(!enif_get_double(env, params_t[i1++], ¶ms[1])) Badarg(5884,"params");
12754 if(!enif_get_double(env, params_t[i1++], ¶ms[2])) Badarg(5884,"params");
12755 if(!enif_get_double(env, params_t[i1++], ¶ms[3])) Badarg(5884,"params");
12756 }};
12757 weglProgramLocalParameter4dvARB(target,index,params);
12758 }
12759
ecb_glProgramLocalParameter4fARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12760 void ecb_glProgramLocalParameter4fARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12761 {
12762 GLenum target;
12763 GLuint index;
12764 GLfloat x;
12765 GLfloat y;
12766 GLfloat z;
12767 GLfloat w;
12768 if(!enif_get_uint(env, argv[0], &target)) Badarg(5885,"target");
12769 if(!enif_get_uint(env, argv[1], &index)) Badarg(5885,"index");
12770 if(!egl_get_float(env, argv[2], &x)) Badarg(5885,"x");
12771 if(!egl_get_float(env, argv[3], &y)) Badarg(5885,"y");
12772 if(!egl_get_float(env, argv[4], &z)) Badarg(5885,"z");
12773 if(!egl_get_float(env, argv[5], &w)) Badarg(5885,"w");
12774 weglProgramLocalParameter4fARB(target,index,x,y,z,w);
12775 }
12776
ecb_glProgramLocalParameter4fvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12777 void ecb_glProgramLocalParameter4fvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12778 {
12779 GLenum target;
12780 GLuint index;
12781 GLfloat params[4];
12782 if(!enif_get_uint(env, argv[0], &target)) Badarg(5886,"target");
12783 if(!enif_get_uint(env, argv[1], &index)) Badarg(5886,"index");
12784 {
12785 int params_a;
12786 const ERL_NIF_TERM *params_t;
12787 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t) || params_a != 4) {
12788 Badarg(5886,"params");
12789 } else {
12790 int i1 = 0;
12791 if(!egl_get_float(env, params_t[i1++], ¶ms[0])) Badarg(5886,"params");
12792 if(!egl_get_float(env, params_t[i1++], ¶ms[1])) Badarg(5886,"params");
12793 if(!egl_get_float(env, params_t[i1++], ¶ms[2])) Badarg(5886,"params");
12794 if(!egl_get_float(env, params_t[i1++], ¶ms[3])) Badarg(5886,"params");
12795 }};
12796 weglProgramLocalParameter4fvARB(target,index,params);
12797 }
12798
ecb_glGetProgramEnvParameterdvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12799 void ecb_glGetProgramEnvParameterdvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12800 {
12801 ERL_NIF_TERM reply;
12802 GLenum target;
12803 GLuint index;
12804 GLdouble params[4];
12805 if(!enif_get_uint(env, argv[0], &target)) Badarg(5887,"target");
12806 if(!enif_get_uint(env, argv[1], &index)) Badarg(5887,"index");
12807 weglGetProgramEnvParameterdvARB(target,index,params);
12808 reply = enif_make_tuple4(env,
12809 enif_make_double(env, params[0]),
12810 enif_make_double(env, params[1]),
12811 enif_make_double(env, params[2]),
12812 enif_make_double(env, params[3]));
12813 enif_send(NULL, self, env,
12814 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
12815 }
12816
ecb_glGetProgramEnvParameterfvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12817 void ecb_glGetProgramEnvParameterfvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12818 {
12819 ERL_NIF_TERM reply;
12820 GLenum target;
12821 GLuint index;
12822 GLfloat params[4];
12823 if(!enif_get_uint(env, argv[0], &target)) Badarg(5888,"target");
12824 if(!enif_get_uint(env, argv[1], &index)) Badarg(5888,"index");
12825 weglGetProgramEnvParameterfvARB(target,index,params);
12826 reply = enif_make_tuple4(env,
12827 enif_make_double(env, (double) params[0]),
12828 enif_make_double(env, (double) params[1]),
12829 enif_make_double(env, (double) params[2]),
12830 enif_make_double(env, (double) params[3]));
12831 enif_send(NULL, self, env,
12832 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
12833 }
12834
ecb_glGetProgramLocalParameterdvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12835 void ecb_glGetProgramLocalParameterdvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12836 {
12837 ERL_NIF_TERM reply;
12838 GLenum target;
12839 GLuint index;
12840 GLdouble params[4];
12841 if(!enif_get_uint(env, argv[0], &target)) Badarg(5889,"target");
12842 if(!enif_get_uint(env, argv[1], &index)) Badarg(5889,"index");
12843 weglGetProgramLocalParameterdvARB(target,index,params);
12844 reply = enif_make_tuple4(env,
12845 enif_make_double(env, params[0]),
12846 enif_make_double(env, params[1]),
12847 enif_make_double(env, params[2]),
12848 enif_make_double(env, params[3]));
12849 enif_send(NULL, self, env,
12850 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
12851 }
12852
ecb_glGetProgramLocalParameterfvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12853 void ecb_glGetProgramLocalParameterfvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12854 {
12855 ERL_NIF_TERM reply;
12856 GLenum target;
12857 GLuint index;
12858 GLfloat params[4];
12859 if(!enif_get_uint(env, argv[0], &target)) Badarg(5890,"target");
12860 if(!enif_get_uint(env, argv[1], &index)) Badarg(5890,"index");
12861 weglGetProgramLocalParameterfvARB(target,index,params);
12862 reply = enif_make_tuple4(env,
12863 enif_make_double(env, (double) params[0]),
12864 enif_make_double(env, (double) params[1]),
12865 enif_make_double(env, (double) params[2]),
12866 enif_make_double(env, (double) params[3]));
12867 enif_send(NULL, self, env,
12868 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
12869 }
12870
ecb_glGetProgramStringARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12871 void ecb_glGetProgramStringARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12872 {
12873 GLenum target;
12874 GLenum pname;
12875 ErlNifBinary string;
12876 if(!enif_get_uint(env, argv[0], &target)) Badarg(5891,"target");
12877 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5891,"pname");
12878 if(enif_is_binary(env, argv[2]))
12879 enif_inspect_binary(env, argv[2], &string);
12880 else if(enif_is_tuple(env, argv[2])) {
12881 int string_a;
12882 const ERL_NIF_TERM *string_t;
12883 if(enif_get_tuple(env, argv[2], &string_a, &string_t) &&
12884 enif_is_binary(env, string_t[1]))
12885 enif_inspect_binary(env, string_t[1], &string);
12886 else Badarg(5891, "string");
12887 } else Badarg(5891, "string");
12888 weglGetProgramStringARB(target,pname,(void *) string.data);
12889 enif_send(NULL, self, env,
12890 enif_make_tuple2(env,EGL_ATOM_REPLY,
12891 EGL_ATOM_OK));
12892 }
12893
ecb_glFramebufferTextureFaceARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12894 void ecb_glFramebufferTextureFaceARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12895 {
12896 GLenum target;
12897 GLenum attachment;
12898 GLuint texture;
12899 GLint level;
12900 GLenum face;
12901 if(!enif_get_uint(env, argv[0], &target)) Badarg(5892,"target");
12902 if(!enif_get_uint(env, argv[1], &attachment)) Badarg(5892,"attachment");
12903 if(!enif_get_uint(env, argv[2], &texture)) Badarg(5892,"texture");
12904 if(!enif_get_int(env, argv[3], &level)) Badarg(5892,"level");
12905 if(!enif_get_uint(env, argv[4], &face)) Badarg(5892,"face");
12906 weglFramebufferTextureFaceARB(target,attachment,texture,level,face);
12907 }
12908
ecb_glUniform1i64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12909 void ecb_glUniform1i64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12910 {
12911 GLint location;
12912 GLint64 x;
12913 if(!enif_get_int(env, argv[0], &location)) Badarg(5893,"location");
12914 if(!enif_get_int64(env, argv[1], (egl_int64_t *) &x)) Badarg(5893,"x");
12915 weglUniform1i64ARB(location,x);
12916 }
12917
ecb_glUniform2i64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12918 void ecb_glUniform2i64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12919 {
12920 GLint location;
12921 GLint64 x;
12922 GLint64 y;
12923 if(!enif_get_int(env, argv[0], &location)) Badarg(5894,"location");
12924 if(!enif_get_int64(env, argv[1], (egl_int64_t *) &x)) Badarg(5894,"x");
12925 if(!enif_get_int64(env, argv[2], (egl_int64_t *) &y)) Badarg(5894,"y");
12926 weglUniform2i64ARB(location,x,y);
12927 }
12928
ecb_glUniform3i64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12929 void ecb_glUniform3i64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12930 {
12931 GLint location;
12932 GLint64 x;
12933 GLint64 y;
12934 GLint64 z;
12935 if(!enif_get_int(env, argv[0], &location)) Badarg(5895,"location");
12936 if(!enif_get_int64(env, argv[1], (egl_int64_t *) &x)) Badarg(5895,"x");
12937 if(!enif_get_int64(env, argv[2], (egl_int64_t *) &y)) Badarg(5895,"y");
12938 if(!enif_get_int64(env, argv[3], (egl_int64_t *) &z)) Badarg(5895,"z");
12939 weglUniform3i64ARB(location,x,y,z);
12940 }
12941
ecb_glUniform4i64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12942 void ecb_glUniform4i64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12943 {
12944 GLint location;
12945 GLint64 x;
12946 GLint64 y;
12947 GLint64 z;
12948 GLint64 w;
12949 if(!enif_get_int(env, argv[0], &location)) Badarg(5896,"location");
12950 if(!enif_get_int64(env, argv[1], (egl_int64_t *) &x)) Badarg(5896,"x");
12951 if(!enif_get_int64(env, argv[2], (egl_int64_t *) &y)) Badarg(5896,"y");
12952 if(!enif_get_int64(env, argv[3], (egl_int64_t *) &z)) Badarg(5896,"z");
12953 if(!enif_get_int64(env, argv[4], (egl_int64_t *) &w)) Badarg(5896,"w");
12954 weglUniform4i64ARB(location,x,y,z,w);
12955 }
12956
ecb_glUniform1i64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12957 void ecb_glUniform1i64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12958 {
12959 GLint location;
12960 GLsizei count;
12961 GLint64 *value;
12962 if(!enif_get_int(env, argv[0], &location)) Badarg(5897,"location");
12963 if(!enif_get_int(env, argv[1], &count)) Badarg(5897,"count");
12964 if(!enif_is_list(env, argv[2])) Badarg(5897, "value")
12965 else {
12966 ERL_NIF_TERM value_l, value_h, value_t;
12967 std::vector <GLint64> value_vec;
12968 GLint64 value_tmp;
12969 value_l = argv[2];
12970 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
12971 if(!enif_get_int64(env, value_h,(egl_int64_t *) &value_tmp)) Badarg(5897,"value");
12972 value_vec.push_back(value_tmp);
12973 value_l = value_t;
12974 };
12975 value = value_vec.data();
12976 }
12977 weglUniform1i64vARB(location,count,value);
12978 }
12979
ecb_glUniform2i64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])12980 void ecb_glUniform2i64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
12981 {
12982 GLint location;
12983 GLsizei count;
12984 GLint64 *value;
12985 if(!enif_get_int(env, argv[0], &location)) Badarg(5898,"location");
12986 if(!enif_get_int(env, argv[1], &count)) Badarg(5898,"count");
12987 if(!enif_is_list(env, argv[2])) { Badarg(5898,"value")}
12988 int value_a;
12989 const ERL_NIF_TERM *value_tpl;
12990 ERL_NIF_TERM value_l, value_h, value_t;
12991 std::vector <GLint64> value_vec (2*count);
12992 GLint64 *value_ptr = value_vec.data();
12993 value_l = argv[2];
12994 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
12995 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 2) Badarg(5898,"value");
12996 if(!enif_get_int64(env, value_tpl[0],(egl_int64_t *) value_ptr++)) Badarg(5898,"value");
12997 if(!enif_get_int64(env, value_tpl[1],(egl_int64_t *) value_ptr++)) Badarg(5898,"value");
12998 value_l = value_t;
12999 };
13000 value = value_vec.data();
13001 weglUniform2i64vARB(location,count,value);
13002 }
13003
ecb_glUniform3i64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13004 void ecb_glUniform3i64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13005 {
13006 GLint location;
13007 GLsizei count;
13008 GLint64 *value;
13009 if(!enif_get_int(env, argv[0], &location)) Badarg(5899,"location");
13010 if(!enif_get_int(env, argv[1], &count)) Badarg(5899,"count");
13011 if(!enif_is_list(env, argv[2])) { Badarg(5899,"value")}
13012 int value_a;
13013 const ERL_NIF_TERM *value_tpl;
13014 ERL_NIF_TERM value_l, value_h, value_t;
13015 std::vector <GLint64> value_vec (3*count);
13016 GLint64 *value_ptr = value_vec.data();
13017 value_l = argv[2];
13018 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
13019 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 3) Badarg(5899,"value");
13020 if(!enif_get_int64(env, value_tpl[0],(egl_int64_t *) value_ptr++)) Badarg(5899,"value");
13021 if(!enif_get_int64(env, value_tpl[1],(egl_int64_t *) value_ptr++)) Badarg(5899,"value");
13022 if(!enif_get_int64(env, value_tpl[2],(egl_int64_t *) value_ptr++)) Badarg(5899,"value");
13023 value_l = value_t;
13024 };
13025 value = value_vec.data();
13026 weglUniform3i64vARB(location,count,value);
13027 }
13028
ecb_glUniform4i64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13029 void ecb_glUniform4i64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13030 {
13031 GLint location;
13032 GLsizei count;
13033 GLint64 *value;
13034 if(!enif_get_int(env, argv[0], &location)) Badarg(5900,"location");
13035 if(!enif_get_int(env, argv[1], &count)) Badarg(5900,"count");
13036 if(!enif_is_list(env, argv[2])) { Badarg(5900,"value")}
13037 int value_a;
13038 const ERL_NIF_TERM *value_tpl;
13039 ERL_NIF_TERM value_l, value_h, value_t;
13040 std::vector <GLint64> value_vec (4*count);
13041 GLint64 *value_ptr = value_vec.data();
13042 value_l = argv[2];
13043 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
13044 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5900,"value");
13045 if(!enif_get_int64(env, value_tpl[0],(egl_int64_t *) value_ptr++)) Badarg(5900,"value");
13046 if(!enif_get_int64(env, value_tpl[1],(egl_int64_t *) value_ptr++)) Badarg(5900,"value");
13047 if(!enif_get_int64(env, value_tpl[2],(egl_int64_t *) value_ptr++)) Badarg(5900,"value");
13048 if(!enif_get_int64(env, value_tpl[3],(egl_int64_t *) value_ptr++)) Badarg(5900,"value");
13049 value_l = value_t;
13050 };
13051 value = value_vec.data();
13052 weglUniform4i64vARB(location,count,value);
13053 }
13054
ecb_glUniform1ui64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13055 void ecb_glUniform1ui64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13056 {
13057 GLint location;
13058 GLuint64 x;
13059 if(!enif_get_int(env, argv[0], &location)) Badarg(5901,"location");
13060 if(!enif_get_uint64(env, argv[1], (egl_uint64_t *) &x)) Badarg(5901,"x");
13061 weglUniform1ui64ARB(location,x);
13062 }
13063
ecb_glUniform2ui64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13064 void ecb_glUniform2ui64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13065 {
13066 GLint location;
13067 GLuint64 x;
13068 GLuint64 y;
13069 if(!enif_get_int(env, argv[0], &location)) Badarg(5902,"location");
13070 if(!enif_get_uint64(env, argv[1], (egl_uint64_t *) &x)) Badarg(5902,"x");
13071 if(!enif_get_uint64(env, argv[2], (egl_uint64_t *) &y)) Badarg(5902,"y");
13072 weglUniform2ui64ARB(location,x,y);
13073 }
13074
ecb_glUniform3ui64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13075 void ecb_glUniform3ui64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13076 {
13077 GLint location;
13078 GLuint64 x;
13079 GLuint64 y;
13080 GLuint64 z;
13081 if(!enif_get_int(env, argv[0], &location)) Badarg(5903,"location");
13082 if(!enif_get_uint64(env, argv[1], (egl_uint64_t *) &x)) Badarg(5903,"x");
13083 if(!enif_get_uint64(env, argv[2], (egl_uint64_t *) &y)) Badarg(5903,"y");
13084 if(!enif_get_uint64(env, argv[3], (egl_uint64_t *) &z)) Badarg(5903,"z");
13085 weglUniform3ui64ARB(location,x,y,z);
13086 }
13087
ecb_glUniform4ui64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13088 void ecb_glUniform4ui64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13089 {
13090 GLint location;
13091 GLuint64 x;
13092 GLuint64 y;
13093 GLuint64 z;
13094 GLuint64 w;
13095 if(!enif_get_int(env, argv[0], &location)) Badarg(5904,"location");
13096 if(!enif_get_uint64(env, argv[1], (egl_uint64_t *) &x)) Badarg(5904,"x");
13097 if(!enif_get_uint64(env, argv[2], (egl_uint64_t *) &y)) Badarg(5904,"y");
13098 if(!enif_get_uint64(env, argv[3], (egl_uint64_t *) &z)) Badarg(5904,"z");
13099 if(!enif_get_uint64(env, argv[4], (egl_uint64_t *) &w)) Badarg(5904,"w");
13100 weglUniform4ui64ARB(location,x,y,z,w);
13101 }
13102
ecb_glUniform1ui64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13103 void ecb_glUniform1ui64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13104 {
13105 GLint location;
13106 GLsizei count;
13107 GLuint64 *value;
13108 if(!enif_get_int(env, argv[0], &location)) Badarg(5905,"location");
13109 if(!enif_get_int(env, argv[1], &count)) Badarg(5905,"count");
13110 if(!enif_is_list(env, argv[2])) Badarg(5905, "value")
13111 else {
13112 ERL_NIF_TERM value_l, value_h, value_t;
13113 std::vector <GLuint64> value_vec;
13114 GLuint64 value_tmp;
13115 value_l = argv[2];
13116 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
13117 if(!enif_get_uint64(env, value_h,(egl_uint64_t *) &value_tmp)) Badarg(5905,"value");
13118 value_vec.push_back(value_tmp);
13119 value_l = value_t;
13120 };
13121 value = value_vec.data();
13122 }
13123 weglUniform1ui64vARB(location,count,value);
13124 }
13125
ecb_glUniform2ui64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13126 void ecb_glUniform2ui64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13127 {
13128 GLint location;
13129 GLsizei count;
13130 GLuint64 *value;
13131 if(!enif_get_int(env, argv[0], &location)) Badarg(5906,"location");
13132 if(!enif_get_int(env, argv[1], &count)) Badarg(5906,"count");
13133 if(!enif_is_list(env, argv[2])) { Badarg(5906,"value")}
13134 int value_a;
13135 const ERL_NIF_TERM *value_tpl;
13136 ERL_NIF_TERM value_l, value_h, value_t;
13137 std::vector <GLuint64> value_vec (2*count);
13138 GLuint64 *value_ptr = value_vec.data();
13139 value_l = argv[2];
13140 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
13141 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 2) Badarg(5906,"value");
13142 if(!enif_get_uint64(env, value_tpl[0],(egl_uint64_t *) value_ptr++)) Badarg(5906,"value");
13143 if(!enif_get_uint64(env, value_tpl[1],(egl_uint64_t *) value_ptr++)) Badarg(5906,"value");
13144 value_l = value_t;
13145 };
13146 value = value_vec.data();
13147 weglUniform2ui64vARB(location,count,value);
13148 }
13149
ecb_glUniform3ui64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13150 void ecb_glUniform3ui64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13151 {
13152 GLint location;
13153 GLsizei count;
13154 GLuint64 *value;
13155 if(!enif_get_int(env, argv[0], &location)) Badarg(5907,"location");
13156 if(!enif_get_int(env, argv[1], &count)) Badarg(5907,"count");
13157 if(!enif_is_list(env, argv[2])) { Badarg(5907,"value")}
13158 int value_a;
13159 const ERL_NIF_TERM *value_tpl;
13160 ERL_NIF_TERM value_l, value_h, value_t;
13161 std::vector <GLuint64> value_vec (3*count);
13162 GLuint64 *value_ptr = value_vec.data();
13163 value_l = argv[2];
13164 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
13165 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 3) Badarg(5907,"value");
13166 if(!enif_get_uint64(env, value_tpl[0],(egl_uint64_t *) value_ptr++)) Badarg(5907,"value");
13167 if(!enif_get_uint64(env, value_tpl[1],(egl_uint64_t *) value_ptr++)) Badarg(5907,"value");
13168 if(!enif_get_uint64(env, value_tpl[2],(egl_uint64_t *) value_ptr++)) Badarg(5907,"value");
13169 value_l = value_t;
13170 };
13171 value = value_vec.data();
13172 weglUniform3ui64vARB(location,count,value);
13173 }
13174
ecb_glUniform4ui64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13175 void ecb_glUniform4ui64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13176 {
13177 GLint location;
13178 GLsizei count;
13179 GLuint64 *value;
13180 if(!enif_get_int(env, argv[0], &location)) Badarg(5908,"location");
13181 if(!enif_get_int(env, argv[1], &count)) Badarg(5908,"count");
13182 if(!enif_is_list(env, argv[2])) { Badarg(5908,"value")}
13183 int value_a;
13184 const ERL_NIF_TERM *value_tpl;
13185 ERL_NIF_TERM value_l, value_h, value_t;
13186 std::vector <GLuint64> value_vec (4*count);
13187 GLuint64 *value_ptr = value_vec.data();
13188 value_l = argv[2];
13189 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
13190 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5908,"value");
13191 if(!enif_get_uint64(env, value_tpl[0],(egl_uint64_t *) value_ptr++)) Badarg(5908,"value");
13192 if(!enif_get_uint64(env, value_tpl[1],(egl_uint64_t *) value_ptr++)) Badarg(5908,"value");
13193 if(!enif_get_uint64(env, value_tpl[2],(egl_uint64_t *) value_ptr++)) Badarg(5908,"value");
13194 if(!enif_get_uint64(env, value_tpl[3],(egl_uint64_t *) value_ptr++)) Badarg(5908,"value");
13195 value_l = value_t;
13196 };
13197 value = value_vec.data();
13198 weglUniform4ui64vARB(location,count,value);
13199 }
13200
ecb_glGetUniformi64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13201 void ecb_glGetUniformi64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13202 {
13203 ERL_NIF_TERM reply;
13204 GLuint program;
13205 GLint location;
13206 GLint64 params[16];
13207 ERL_NIF_TERM params_ts[16];
13208 if(!enif_get_uint(env, argv[0], &program)) Badarg(5909,"program");
13209 if(!enif_get_int(env, argv[1], &location)) Badarg(5909,"location");
13210 weglGetUniformi64vARB(program,location,params);
13211 for(int ri=0; ri < (int) 16; ri++)
13212 params_ts[ri] = enif_make_int64(env, (egl_int64_t) params[ri]);
13213 reply = enif_make_tuple_from_array(env, params_ts, 16);
13214 enif_send(NULL, self, env,
13215 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
13216 }
13217
ecb_glGetUniformui64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13218 void ecb_glGetUniformui64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13219 {
13220 ERL_NIF_TERM reply;
13221 GLuint program;
13222 GLint location;
13223 GLuint64 params[16];
13224 ERL_NIF_TERM params_ts[16];
13225 if(!enif_get_uint(env, argv[0], &program)) Badarg(5910,"program");
13226 if(!enif_get_int(env, argv[1], &location)) Badarg(5910,"location");
13227 weglGetUniformui64vARB(program,location,params);
13228 for(int ri=0; ri < (int) 16; ri++)
13229 params_ts[ri] = enif_make_int64(env, (egl_int64_t) params[ri]);
13230 reply = enif_make_tuple_from_array(env, params_ts, 16);
13231 enif_send(NULL, self, env,
13232 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
13233 }
13234
ecb_glProgramUniform1i64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13235 void ecb_glProgramUniform1i64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13236 {
13237 GLuint program;
13238 GLint location;
13239 GLint64 x;
13240 if(!enif_get_uint(env, argv[0], &program)) Badarg(5911,"program");
13241 if(!enif_get_int(env, argv[1], &location)) Badarg(5911,"location");
13242 if(!enif_get_int64(env, argv[2], (egl_int64_t *) &x)) Badarg(5911,"x");
13243 weglProgramUniform1i64ARB(program,location,x);
13244 }
13245
ecb_glProgramUniform2i64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13246 void ecb_glProgramUniform2i64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13247 {
13248 GLuint program;
13249 GLint location;
13250 GLint64 x;
13251 GLint64 y;
13252 if(!enif_get_uint(env, argv[0], &program)) Badarg(5912,"program");
13253 if(!enif_get_int(env, argv[1], &location)) Badarg(5912,"location");
13254 if(!enif_get_int64(env, argv[2], (egl_int64_t *) &x)) Badarg(5912,"x");
13255 if(!enif_get_int64(env, argv[3], (egl_int64_t *) &y)) Badarg(5912,"y");
13256 weglProgramUniform2i64ARB(program,location,x,y);
13257 }
13258
ecb_glProgramUniform3i64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13259 void ecb_glProgramUniform3i64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13260 {
13261 GLuint program;
13262 GLint location;
13263 GLint64 x;
13264 GLint64 y;
13265 GLint64 z;
13266 if(!enif_get_uint(env, argv[0], &program)) Badarg(5913,"program");
13267 if(!enif_get_int(env, argv[1], &location)) Badarg(5913,"location");
13268 if(!enif_get_int64(env, argv[2], (egl_int64_t *) &x)) Badarg(5913,"x");
13269 if(!enif_get_int64(env, argv[3], (egl_int64_t *) &y)) Badarg(5913,"y");
13270 if(!enif_get_int64(env, argv[4], (egl_int64_t *) &z)) Badarg(5913,"z");
13271 weglProgramUniform3i64ARB(program,location,x,y,z);
13272 }
13273
ecb_glProgramUniform4i64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13274 void ecb_glProgramUniform4i64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13275 {
13276 GLuint program;
13277 GLint location;
13278 GLint64 x;
13279 GLint64 y;
13280 GLint64 z;
13281 GLint64 w;
13282 if(!enif_get_uint(env, argv[0], &program)) Badarg(5914,"program");
13283 if(!enif_get_int(env, argv[1], &location)) Badarg(5914,"location");
13284 if(!enif_get_int64(env, argv[2], (egl_int64_t *) &x)) Badarg(5914,"x");
13285 if(!enif_get_int64(env, argv[3], (egl_int64_t *) &y)) Badarg(5914,"y");
13286 if(!enif_get_int64(env, argv[4], (egl_int64_t *) &z)) Badarg(5914,"z");
13287 if(!enif_get_int64(env, argv[5], (egl_int64_t *) &w)) Badarg(5914,"w");
13288 weglProgramUniform4i64ARB(program,location,x,y,z,w);
13289 }
13290
ecb_glProgramUniform1i64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13291 void ecb_glProgramUniform1i64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13292 {
13293 GLuint program;
13294 GLint location;
13295 GLsizei count;
13296 GLint64 *value;
13297 if(!enif_get_uint(env, argv[0], &program)) Badarg(5915,"program");
13298 if(!enif_get_int(env, argv[1], &location)) Badarg(5915,"location");
13299 if(!enif_get_int(env, argv[2], &count)) Badarg(5915,"count");
13300 if(!enif_is_list(env, argv[3])) Badarg(5915, "value")
13301 else {
13302 ERL_NIF_TERM value_l, value_h, value_t;
13303 std::vector <GLint64> value_vec;
13304 GLint64 value_tmp;
13305 value_l = argv[3];
13306 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
13307 if(!enif_get_int64(env, value_h,(egl_int64_t *) &value_tmp)) Badarg(5915,"value");
13308 value_vec.push_back(value_tmp);
13309 value_l = value_t;
13310 };
13311 value = value_vec.data();
13312 }
13313 weglProgramUniform1i64vARB(program,location,count,value);
13314 }
13315
ecb_glProgramUniform2i64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13316 void ecb_glProgramUniform2i64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13317 {
13318 GLuint program;
13319 GLint location;
13320 GLsizei count;
13321 GLint64 *value;
13322 if(!enif_get_uint(env, argv[0], &program)) Badarg(5916,"program");
13323 if(!enif_get_int(env, argv[1], &location)) Badarg(5916,"location");
13324 if(!enif_get_int(env, argv[2], &count)) Badarg(5916,"count");
13325 if(!enif_is_list(env, argv[3])) { Badarg(5916,"value")}
13326 int value_a;
13327 const ERL_NIF_TERM *value_tpl;
13328 ERL_NIF_TERM value_l, value_h, value_t;
13329 std::vector <GLint64> value_vec (2*count);
13330 GLint64 *value_ptr = value_vec.data();
13331 value_l = argv[3];
13332 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
13333 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 2) Badarg(5916,"value");
13334 if(!enif_get_int64(env, value_tpl[0],(egl_int64_t *) value_ptr++)) Badarg(5916,"value");
13335 if(!enif_get_int64(env, value_tpl[1],(egl_int64_t *) value_ptr++)) Badarg(5916,"value");
13336 value_l = value_t;
13337 };
13338 value = value_vec.data();
13339 weglProgramUniform2i64vARB(program,location,count,value);
13340 }
13341
ecb_glProgramUniform3i64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13342 void ecb_glProgramUniform3i64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13343 {
13344 GLuint program;
13345 GLint location;
13346 GLsizei count;
13347 GLint64 *value;
13348 if(!enif_get_uint(env, argv[0], &program)) Badarg(5917,"program");
13349 if(!enif_get_int(env, argv[1], &location)) Badarg(5917,"location");
13350 if(!enif_get_int(env, argv[2], &count)) Badarg(5917,"count");
13351 if(!enif_is_list(env, argv[3])) { Badarg(5917,"value")}
13352 int value_a;
13353 const ERL_NIF_TERM *value_tpl;
13354 ERL_NIF_TERM value_l, value_h, value_t;
13355 std::vector <GLint64> value_vec (3*count);
13356 GLint64 *value_ptr = value_vec.data();
13357 value_l = argv[3];
13358 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
13359 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 3) Badarg(5917,"value");
13360 if(!enif_get_int64(env, value_tpl[0],(egl_int64_t *) value_ptr++)) Badarg(5917,"value");
13361 if(!enif_get_int64(env, value_tpl[1],(egl_int64_t *) value_ptr++)) Badarg(5917,"value");
13362 if(!enif_get_int64(env, value_tpl[2],(egl_int64_t *) value_ptr++)) Badarg(5917,"value");
13363 value_l = value_t;
13364 };
13365 value = value_vec.data();
13366 weglProgramUniform3i64vARB(program,location,count,value);
13367 }
13368
ecb_glProgramUniform4i64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13369 void ecb_glProgramUniform4i64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13370 {
13371 GLuint program;
13372 GLint location;
13373 GLsizei count;
13374 GLint64 *value;
13375 if(!enif_get_uint(env, argv[0], &program)) Badarg(5918,"program");
13376 if(!enif_get_int(env, argv[1], &location)) Badarg(5918,"location");
13377 if(!enif_get_int(env, argv[2], &count)) Badarg(5918,"count");
13378 if(!enif_is_list(env, argv[3])) { Badarg(5918,"value")}
13379 int value_a;
13380 const ERL_NIF_TERM *value_tpl;
13381 ERL_NIF_TERM value_l, value_h, value_t;
13382 std::vector <GLint64> value_vec (4*count);
13383 GLint64 *value_ptr = value_vec.data();
13384 value_l = argv[3];
13385 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
13386 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5918,"value");
13387 if(!enif_get_int64(env, value_tpl[0],(egl_int64_t *) value_ptr++)) Badarg(5918,"value");
13388 if(!enif_get_int64(env, value_tpl[1],(egl_int64_t *) value_ptr++)) Badarg(5918,"value");
13389 if(!enif_get_int64(env, value_tpl[2],(egl_int64_t *) value_ptr++)) Badarg(5918,"value");
13390 if(!enif_get_int64(env, value_tpl[3],(egl_int64_t *) value_ptr++)) Badarg(5918,"value");
13391 value_l = value_t;
13392 };
13393 value = value_vec.data();
13394 weglProgramUniform4i64vARB(program,location,count,value);
13395 }
13396
ecb_glProgramUniform1ui64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13397 void ecb_glProgramUniform1ui64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13398 {
13399 GLuint program;
13400 GLint location;
13401 GLuint64 x;
13402 if(!enif_get_uint(env, argv[0], &program)) Badarg(5919,"program");
13403 if(!enif_get_int(env, argv[1], &location)) Badarg(5919,"location");
13404 if(!enif_get_uint64(env, argv[2], (egl_uint64_t *) &x)) Badarg(5919,"x");
13405 weglProgramUniform1ui64ARB(program,location,x);
13406 }
13407
ecb_glProgramUniform2ui64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13408 void ecb_glProgramUniform2ui64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13409 {
13410 GLuint program;
13411 GLint location;
13412 GLuint64 x;
13413 GLuint64 y;
13414 if(!enif_get_uint(env, argv[0], &program)) Badarg(5920,"program");
13415 if(!enif_get_int(env, argv[1], &location)) Badarg(5920,"location");
13416 if(!enif_get_uint64(env, argv[2], (egl_uint64_t *) &x)) Badarg(5920,"x");
13417 if(!enif_get_uint64(env, argv[3], (egl_uint64_t *) &y)) Badarg(5920,"y");
13418 weglProgramUniform2ui64ARB(program,location,x,y);
13419 }
13420
ecb_glProgramUniform3ui64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13421 void ecb_glProgramUniform3ui64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13422 {
13423 GLuint program;
13424 GLint location;
13425 GLuint64 x;
13426 GLuint64 y;
13427 GLuint64 z;
13428 if(!enif_get_uint(env, argv[0], &program)) Badarg(5921,"program");
13429 if(!enif_get_int(env, argv[1], &location)) Badarg(5921,"location");
13430 if(!enif_get_uint64(env, argv[2], (egl_uint64_t *) &x)) Badarg(5921,"x");
13431 if(!enif_get_uint64(env, argv[3], (egl_uint64_t *) &y)) Badarg(5921,"y");
13432 if(!enif_get_uint64(env, argv[4], (egl_uint64_t *) &z)) Badarg(5921,"z");
13433 weglProgramUniform3ui64ARB(program,location,x,y,z);
13434 }
13435
ecb_glProgramUniform4ui64ARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13436 void ecb_glProgramUniform4ui64ARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13437 {
13438 GLuint program;
13439 GLint location;
13440 GLuint64 x;
13441 GLuint64 y;
13442 GLuint64 z;
13443 GLuint64 w;
13444 if(!enif_get_uint(env, argv[0], &program)) Badarg(5922,"program");
13445 if(!enif_get_int(env, argv[1], &location)) Badarg(5922,"location");
13446 if(!enif_get_uint64(env, argv[2], (egl_uint64_t *) &x)) Badarg(5922,"x");
13447 if(!enif_get_uint64(env, argv[3], (egl_uint64_t *) &y)) Badarg(5922,"y");
13448 if(!enif_get_uint64(env, argv[4], (egl_uint64_t *) &z)) Badarg(5922,"z");
13449 if(!enif_get_uint64(env, argv[5], (egl_uint64_t *) &w)) Badarg(5922,"w");
13450 weglProgramUniform4ui64ARB(program,location,x,y,z,w);
13451 }
13452
ecb_glProgramUniform1ui64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13453 void ecb_glProgramUniform1ui64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13454 {
13455 GLuint program;
13456 GLint location;
13457 GLsizei count;
13458 GLuint64 *value;
13459 if(!enif_get_uint(env, argv[0], &program)) Badarg(5923,"program");
13460 if(!enif_get_int(env, argv[1], &location)) Badarg(5923,"location");
13461 if(!enif_get_int(env, argv[2], &count)) Badarg(5923,"count");
13462 if(!enif_is_list(env, argv[3])) Badarg(5923, "value")
13463 else {
13464 ERL_NIF_TERM value_l, value_h, value_t;
13465 std::vector <GLuint64> value_vec;
13466 GLuint64 value_tmp;
13467 value_l = argv[3];
13468 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
13469 if(!enif_get_uint64(env, value_h,(egl_uint64_t *) &value_tmp)) Badarg(5923,"value");
13470 value_vec.push_back(value_tmp);
13471 value_l = value_t;
13472 };
13473 value = value_vec.data();
13474 }
13475 weglProgramUniform1ui64vARB(program,location,count,value);
13476 }
13477
ecb_glProgramUniform2ui64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13478 void ecb_glProgramUniform2ui64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13479 {
13480 GLuint program;
13481 GLint location;
13482 GLsizei count;
13483 GLuint64 *value;
13484 if(!enif_get_uint(env, argv[0], &program)) Badarg(5924,"program");
13485 if(!enif_get_int(env, argv[1], &location)) Badarg(5924,"location");
13486 if(!enif_get_int(env, argv[2], &count)) Badarg(5924,"count");
13487 if(!enif_is_list(env, argv[3])) { Badarg(5924,"value")}
13488 int value_a;
13489 const ERL_NIF_TERM *value_tpl;
13490 ERL_NIF_TERM value_l, value_h, value_t;
13491 std::vector <GLuint64> value_vec (2*count);
13492 GLuint64 *value_ptr = value_vec.data();
13493 value_l = argv[3];
13494 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
13495 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 2) Badarg(5924,"value");
13496 if(!enif_get_uint64(env, value_tpl[0],(egl_uint64_t *) value_ptr++)) Badarg(5924,"value");
13497 if(!enif_get_uint64(env, value_tpl[1],(egl_uint64_t *) value_ptr++)) Badarg(5924,"value");
13498 value_l = value_t;
13499 };
13500 value = value_vec.data();
13501 weglProgramUniform2ui64vARB(program,location,count,value);
13502 }
13503
ecb_glProgramUniform3ui64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13504 void ecb_glProgramUniform3ui64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13505 {
13506 GLuint program;
13507 GLint location;
13508 GLsizei count;
13509 GLuint64 *value;
13510 if(!enif_get_uint(env, argv[0], &program)) Badarg(5925,"program");
13511 if(!enif_get_int(env, argv[1], &location)) Badarg(5925,"location");
13512 if(!enif_get_int(env, argv[2], &count)) Badarg(5925,"count");
13513 if(!enif_is_list(env, argv[3])) { Badarg(5925,"value")}
13514 int value_a;
13515 const ERL_NIF_TERM *value_tpl;
13516 ERL_NIF_TERM value_l, value_h, value_t;
13517 std::vector <GLuint64> value_vec (3*count);
13518 GLuint64 *value_ptr = value_vec.data();
13519 value_l = argv[3];
13520 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
13521 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 3) Badarg(5925,"value");
13522 if(!enif_get_uint64(env, value_tpl[0],(egl_uint64_t *) value_ptr++)) Badarg(5925,"value");
13523 if(!enif_get_uint64(env, value_tpl[1],(egl_uint64_t *) value_ptr++)) Badarg(5925,"value");
13524 if(!enif_get_uint64(env, value_tpl[2],(egl_uint64_t *) value_ptr++)) Badarg(5925,"value");
13525 value_l = value_t;
13526 };
13527 value = value_vec.data();
13528 weglProgramUniform3ui64vARB(program,location,count,value);
13529 }
13530
ecb_glProgramUniform4ui64vARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13531 void ecb_glProgramUniform4ui64vARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13532 {
13533 GLuint program;
13534 GLint location;
13535 GLsizei count;
13536 GLuint64 *value;
13537 if(!enif_get_uint(env, argv[0], &program)) Badarg(5926,"program");
13538 if(!enif_get_int(env, argv[1], &location)) Badarg(5926,"location");
13539 if(!enif_get_int(env, argv[2], &count)) Badarg(5926,"count");
13540 if(!enif_is_list(env, argv[3])) { Badarg(5926,"value")}
13541 int value_a;
13542 const ERL_NIF_TERM *value_tpl;
13543 ERL_NIF_TERM value_l, value_h, value_t;
13544 std::vector <GLuint64> value_vec (4*count);
13545 GLuint64 *value_ptr = value_vec.data();
13546 value_l = argv[3];
13547 while(enif_get_list_cell(env, value_l, &value_h, &value_t)) {
13548 if(!enif_get_tuple(env, value_h, &value_a, &value_tpl) || value_a != 4) Badarg(5926,"value");
13549 if(!enif_get_uint64(env, value_tpl[0],(egl_uint64_t *) value_ptr++)) Badarg(5926,"value");
13550 if(!enif_get_uint64(env, value_tpl[1],(egl_uint64_t *) value_ptr++)) Badarg(5926,"value");
13551 if(!enif_get_uint64(env, value_tpl[2],(egl_uint64_t *) value_ptr++)) Badarg(5926,"value");
13552 if(!enif_get_uint64(env, value_tpl[3],(egl_uint64_t *) value_ptr++)) Badarg(5926,"value");
13553 value_l = value_t;
13554 };
13555 value = value_vec.data();
13556 weglProgramUniform4ui64vARB(program,location,count,value);
13557 }
13558
ecb_glColorTable(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13559 void ecb_glColorTable(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13560 {
13561 GLenum target;
13562 GLenum internalformat;
13563 GLsizei width;
13564 GLenum format;
13565 GLenum type;
13566 ErlNifBinary table;
13567 GLvoid *table_idx;
13568 if(!enif_get_uint(env, argv[0], &target)) Badarg(5927,"target");
13569 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5927,"internalformat");
13570 if(!enif_get_int(env, argv[2], &width)) Badarg(5927,"width");
13571 if(!enif_get_uint(env, argv[3], &format)) Badarg(5927,"format");
13572 if(!enif_get_uint(env, argv[4], &type)) Badarg(5927,"type");
13573 if(!egl_get_ptr(env, argv[5], (void **) &table_idx)) {
13574 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[5], &table))
13575 table_idx = (GLvoid *) table.data;
13576 else Badarg(5927,"table");
13577 }
13578 weglColorTable(target,internalformat,width,format,type,table_idx);
13579 }
13580
ecb_glColorTableParameterfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13581 void ecb_glColorTableParameterfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13582 {
13583 GLenum target;
13584 GLenum pname;
13585 GLfloat params[4];
13586 if(!enif_get_uint(env, argv[0], &target)) Badarg(5929,"target");
13587 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5929,"pname");
13588 {
13589 int params_a;
13590 const ERL_NIF_TERM *params_t;
13591 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t) || params_a != 4) {
13592 Badarg(5929,"params");
13593 } else {
13594 int i1 = 0;
13595 if(!egl_get_float(env, params_t[i1++], ¶ms[0])) Badarg(5929,"params");
13596 if(!egl_get_float(env, params_t[i1++], ¶ms[1])) Badarg(5929,"params");
13597 if(!egl_get_float(env, params_t[i1++], ¶ms[2])) Badarg(5929,"params");
13598 if(!egl_get_float(env, params_t[i1++], ¶ms[3])) Badarg(5929,"params");
13599 }};
13600 weglColorTableParameterfv(target,pname,params);
13601 }
13602
ecb_glColorTableParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13603 void ecb_glColorTableParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13604 {
13605 GLenum target;
13606 GLenum pname;
13607 GLint params[4];
13608 if(!enif_get_uint(env, argv[0], &target)) Badarg(5930,"target");
13609 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5930,"pname");
13610 {
13611 int params_a;
13612 const ERL_NIF_TERM *params_t;
13613 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t) || params_a != 4) {
13614 Badarg(5930,"params");
13615 } else {
13616 int i1 = 0;
13617 if(!enif_get_int(env, params_t[i1++], ¶ms[0])) Badarg(5930,"params");
13618 if(!enif_get_int(env, params_t[i1++], ¶ms[1])) Badarg(5930,"params");
13619 if(!enif_get_int(env, params_t[i1++], ¶ms[2])) Badarg(5930,"params");
13620 if(!enif_get_int(env, params_t[i1++], ¶ms[3])) Badarg(5930,"params");
13621 }};
13622 weglColorTableParameteriv(target,pname,params);
13623 }
13624
ecb_glCopyColorTable(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13625 void ecb_glCopyColorTable(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13626 {
13627 GLenum target;
13628 GLenum internalformat;
13629 GLint x;
13630 GLint y;
13631 GLsizei width;
13632 if(!enif_get_uint(env, argv[0], &target)) Badarg(5931,"target");
13633 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5931,"internalformat");
13634 if(!enif_get_int(env, argv[2], &x)) Badarg(5931,"x");
13635 if(!enif_get_int(env, argv[3], &y)) Badarg(5931,"y");
13636 if(!enif_get_int(env, argv[4], &width)) Badarg(5931,"width");
13637 weglCopyColorTable(target,internalformat,x,y,width);
13638 }
13639
ecb_glGetColorTable(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13640 void ecb_glGetColorTable(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13641 {
13642 GLenum target;
13643 GLenum format;
13644 GLenum type;
13645 ErlNifBinary table;
13646 if(!enif_get_uint(env, argv[0], &target)) Badarg(5932,"target");
13647 if(!enif_get_uint(env, argv[1], &format)) Badarg(5932,"format");
13648 if(!enif_get_uint(env, argv[2], &type)) Badarg(5932,"type");
13649 if(enif_is_binary(env, argv[3]))
13650 enif_inspect_binary(env, argv[3], &table);
13651 else if(enif_is_tuple(env, argv[3])) {
13652 int table_a;
13653 const ERL_NIF_TERM *table_t;
13654 if(enif_get_tuple(env, argv[3], &table_a, &table_t) &&
13655 enif_is_binary(env, table_t[1]))
13656 enif_inspect_binary(env, table_t[1], &table);
13657 else Badarg(5932, "table");
13658 } else Badarg(5932, "table");
13659 weglGetColorTable(target,format,type,(GLvoid *) table.data);
13660 enif_send(NULL, self, env,
13661 enif_make_tuple2(env,EGL_ATOM_REPLY,
13662 EGL_ATOM_OK));
13663 }
13664
ecb_glGetColorTableParameterfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13665 void ecb_glGetColorTableParameterfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13666 {
13667 ERL_NIF_TERM reply;
13668 GLenum target;
13669 GLenum pname;
13670 GLfloat params[4];
13671 if(!enif_get_uint(env, argv[0], &target)) Badarg(5933,"target");
13672 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5933,"pname");
13673 weglGetColorTableParameterfv(target,pname,params);
13674 reply = enif_make_tuple4(env,
13675 enif_make_double(env, (double) params[0]),
13676 enif_make_double(env, (double) params[1]),
13677 enif_make_double(env, (double) params[2]),
13678 enif_make_double(env, (double) params[3]));
13679 enif_send(NULL, self, env,
13680 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
13681 }
13682
ecb_glGetColorTableParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13683 void ecb_glGetColorTableParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13684 {
13685 ERL_NIF_TERM reply;
13686 GLenum target;
13687 GLenum pname;
13688 GLint params[4];
13689 if(!enif_get_uint(env, argv[0], &target)) Badarg(5934,"target");
13690 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5934,"pname");
13691 weglGetColorTableParameteriv(target,pname,params);
13692 reply = enif_make_tuple4(env,
13693 enif_make_int(env, params[0]),
13694 enif_make_int(env, params[1]),
13695 enif_make_int(env, params[2]),
13696 enif_make_int(env, params[3]));
13697 enif_send(NULL, self, env,
13698 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
13699 }
13700
ecb_glColorSubTable(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13701 void ecb_glColorSubTable(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13702 {
13703 GLenum target;
13704 GLsizei start;
13705 GLsizei count;
13706 GLenum format;
13707 GLenum type;
13708 ErlNifBinary data;
13709 GLvoid *data_idx;
13710 if(!enif_get_uint(env, argv[0], &target)) Badarg(5935,"target");
13711 if(!enif_get_int(env, argv[1], &start)) Badarg(5935,"start");
13712 if(!enif_get_int(env, argv[2], &count)) Badarg(5935,"count");
13713 if(!enif_get_uint(env, argv[3], &format)) Badarg(5935,"format");
13714 if(!enif_get_uint(env, argv[4], &type)) Badarg(5935,"type");
13715 if(!egl_get_ptr(env, argv[5], (void **) &data_idx)) {
13716 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[5], &data))
13717 data_idx = (GLvoid *) data.data;
13718 else Badarg(5935,"data");
13719 }
13720 weglColorSubTable(target,start,count,format,type,data_idx);
13721 }
13722
ecb_glCopyColorSubTable(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13723 void ecb_glCopyColorSubTable(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13724 {
13725 GLenum target;
13726 GLsizei start;
13727 GLint x;
13728 GLint y;
13729 GLsizei width;
13730 if(!enif_get_uint(env, argv[0], &target)) Badarg(5937,"target");
13731 if(!enif_get_int(env, argv[1], &start)) Badarg(5937,"start");
13732 if(!enif_get_int(env, argv[2], &x)) Badarg(5937,"x");
13733 if(!enif_get_int(env, argv[3], &y)) Badarg(5937,"y");
13734 if(!enif_get_int(env, argv[4], &width)) Badarg(5937,"width");
13735 weglCopyColorSubTable(target,start,x,y,width);
13736 }
13737
ecb_glConvolutionFilter1D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13738 void ecb_glConvolutionFilter1D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13739 {
13740 GLenum target;
13741 GLenum internalformat;
13742 GLsizei width;
13743 GLenum format;
13744 GLenum type;
13745 ErlNifBinary image;
13746 GLvoid *image_idx;
13747 if(!enif_get_uint(env, argv[0], &target)) Badarg(5938,"target");
13748 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5938,"internalformat");
13749 if(!enif_get_int(env, argv[2], &width)) Badarg(5938,"width");
13750 if(!enif_get_uint(env, argv[3], &format)) Badarg(5938,"format");
13751 if(!enif_get_uint(env, argv[4], &type)) Badarg(5938,"type");
13752 if(!egl_get_ptr(env, argv[5], (void **) &image_idx)) {
13753 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[5], &image))
13754 image_idx = (GLvoid *) image.data;
13755 else Badarg(5938,"image");
13756 }
13757 weglConvolutionFilter1D(target,internalformat,width,format,type,image_idx);
13758 }
13759
ecb_glConvolutionFilter2D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13760 void ecb_glConvolutionFilter2D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13761 {
13762 GLenum target;
13763 GLenum internalformat;
13764 GLsizei width;
13765 GLsizei height;
13766 GLenum format;
13767 GLenum type;
13768 ErlNifBinary image;
13769 GLvoid *image_idx;
13770 if(!enif_get_uint(env, argv[0], &target)) Badarg(5940,"target");
13771 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5940,"internalformat");
13772 if(!enif_get_int(env, argv[2], &width)) Badarg(5940,"width");
13773 if(!enif_get_int(env, argv[3], &height)) Badarg(5940,"height");
13774 if(!enif_get_uint(env, argv[4], &format)) Badarg(5940,"format");
13775 if(!enif_get_uint(env, argv[5], &type)) Badarg(5940,"type");
13776 if(!egl_get_ptr(env, argv[6], (void **) &image_idx)) {
13777 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[6], &image))
13778 image_idx = (GLvoid *) image.data;
13779 else Badarg(5940,"image");
13780 }
13781 weglConvolutionFilter2D(target,internalformat,width,height,format,type,image_idx);
13782 }
13783
ecb_glConvolutionParameterf(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13784 void ecb_glConvolutionParameterf(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13785 {
13786 GLenum target;
13787 GLenum pname;
13788 GLfloat params[4];
13789 if(!enif_get_uint(env, argv[0], &target)) Badarg(5942,"target");
13790 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5942,"pname");
13791 {
13792 int params_a;
13793 const ERL_NIF_TERM *params_t;
13794 int i;
13795 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
13796 Badarg(5942,"params");
13797 } else {
13798 for(i = 0; i < params_a; i++)
13799 if(!egl_get_float(env, params_t[i], ¶ms[i])) Badarg(5942,"params");
13800 }};
13801 weglConvolutionParameterf(target,pname,params);
13802 }
13803
ecb_glConvolutionParameterfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13804 void ecb_glConvolutionParameterfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13805 {
13806 GLenum target;
13807 GLenum pname;
13808 GLfloat params[4];
13809 if(!enif_get_uint(env, argv[0], &target)) Badarg(5943,"target");
13810 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5943,"pname");
13811 {
13812 int params_a;
13813 const ERL_NIF_TERM *params_t;
13814 int i;
13815 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
13816 Badarg(5943,"params");
13817 } else {
13818 for(i = 0; i < params_a; i++)
13819 if(!egl_get_float(env, params_t[i], ¶ms[i])) Badarg(5943,"params");
13820 }};
13821 weglConvolutionParameterfv(target,pname,params);
13822 }
13823
ecb_glConvolutionParameteri(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13824 void ecb_glConvolutionParameteri(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13825 {
13826 GLenum target;
13827 GLenum pname;
13828 GLint params[4];
13829 if(!enif_get_uint(env, argv[0], &target)) Badarg(5944,"target");
13830 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5944,"pname");
13831 {
13832 int params_a;
13833 const ERL_NIF_TERM *params_t;
13834 int i;
13835 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
13836 Badarg(5944,"params");
13837 } else {
13838 for(i = 0; i < params_a; i++)
13839 if(!enif_get_int(env, params_t[i], ¶ms[i])) Badarg(5944,"params");
13840 }};
13841 weglConvolutionParameteri(target,pname,params);
13842 }
13843
ecb_glConvolutionParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13844 void ecb_glConvolutionParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13845 {
13846 GLenum target;
13847 GLenum pname;
13848 GLint params[4];
13849 if(!enif_get_uint(env, argv[0], &target)) Badarg(5945,"target");
13850 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5945,"pname");
13851 {
13852 int params_a;
13853 const ERL_NIF_TERM *params_t;
13854 int i;
13855 if(!enif_get_tuple(env, argv[2], ¶ms_a, ¶ms_t)) {
13856 Badarg(5945,"params");
13857 } else {
13858 for(i = 0; i < params_a; i++)
13859 if(!enif_get_int(env, params_t[i], ¶ms[i])) Badarg(5945,"params");
13860 }};
13861 weglConvolutionParameteriv(target,pname,params);
13862 }
13863
ecb_glCopyConvolutionFilter1D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13864 void ecb_glCopyConvolutionFilter1D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13865 {
13866 GLenum target;
13867 GLenum internalformat;
13868 GLint x;
13869 GLint y;
13870 GLsizei width;
13871 if(!enif_get_uint(env, argv[0], &target)) Badarg(5946,"target");
13872 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5946,"internalformat");
13873 if(!enif_get_int(env, argv[2], &x)) Badarg(5946,"x");
13874 if(!enif_get_int(env, argv[3], &y)) Badarg(5946,"y");
13875 if(!enif_get_int(env, argv[4], &width)) Badarg(5946,"width");
13876 weglCopyConvolutionFilter1D(target,internalformat,x,y,width);
13877 }
13878
ecb_glCopyConvolutionFilter2D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13879 void ecb_glCopyConvolutionFilter2D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13880 {
13881 GLenum target;
13882 GLenum internalformat;
13883 GLint x;
13884 GLint y;
13885 GLsizei width;
13886 GLsizei height;
13887 if(!enif_get_uint(env, argv[0], &target)) Badarg(5947,"target");
13888 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5947,"internalformat");
13889 if(!enif_get_int(env, argv[2], &x)) Badarg(5947,"x");
13890 if(!enif_get_int(env, argv[3], &y)) Badarg(5947,"y");
13891 if(!enif_get_int(env, argv[4], &width)) Badarg(5947,"width");
13892 if(!enif_get_int(env, argv[5], &height)) Badarg(5947,"height");
13893 weglCopyConvolutionFilter2D(target,internalformat,x,y,width,height);
13894 }
13895
ecb_glGetConvolutionFilter(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13896 void ecb_glGetConvolutionFilter(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13897 {
13898 GLenum target;
13899 GLenum format;
13900 GLenum type;
13901 ErlNifBinary image;
13902 if(!enif_get_uint(env, argv[0], &target)) Badarg(5948,"target");
13903 if(!enif_get_uint(env, argv[1], &format)) Badarg(5948,"format");
13904 if(!enif_get_uint(env, argv[2], &type)) Badarg(5948,"type");
13905 if(enif_is_binary(env, argv[3]))
13906 enif_inspect_binary(env, argv[3], &image);
13907 else if(enif_is_tuple(env, argv[3])) {
13908 int image_a;
13909 const ERL_NIF_TERM *image_t;
13910 if(enif_get_tuple(env, argv[3], &image_a, &image_t) &&
13911 enif_is_binary(env, image_t[1]))
13912 enif_inspect_binary(env, image_t[1], &image);
13913 else Badarg(5948, "image");
13914 } else Badarg(5948, "image");
13915 weglGetConvolutionFilter(target,format,type,(GLvoid *) image.data);
13916 enif_send(NULL, self, env,
13917 enif_make_tuple2(env,EGL_ATOM_REPLY,
13918 EGL_ATOM_OK));
13919 }
13920
ecb_glGetConvolutionParameterfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13921 void ecb_glGetConvolutionParameterfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13922 {
13923 ERL_NIF_TERM reply;
13924 GLenum target;
13925 GLenum pname;
13926 GLfloat params[4];
13927 if(!enif_get_uint(env, argv[0], &target)) Badarg(5949,"target");
13928 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5949,"pname");
13929 weglGetConvolutionParameterfv(target,pname,params);
13930 reply = enif_make_tuple4(env,
13931 enif_make_double(env, (double) params[0]),
13932 enif_make_double(env, (double) params[1]),
13933 enif_make_double(env, (double) params[2]),
13934 enif_make_double(env, (double) params[3]));
13935 enif_send(NULL, self, env,
13936 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
13937 }
13938
ecb_glGetConvolutionParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13939 void ecb_glGetConvolutionParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13940 {
13941 ERL_NIF_TERM reply;
13942 GLenum target;
13943 GLenum pname;
13944 GLint params[4];
13945 if(!enif_get_uint(env, argv[0], &target)) Badarg(5950,"target");
13946 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5950,"pname");
13947 weglGetConvolutionParameteriv(target,pname,params);
13948 reply = enif_make_tuple4(env,
13949 enif_make_int(env, params[0]),
13950 enif_make_int(env, params[1]),
13951 enif_make_int(env, params[2]),
13952 enif_make_int(env, params[3]));
13953 enif_send(NULL, self, env,
13954 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
13955 }
13956
ecb_glSeparableFilter2D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13957 void ecb_glSeparableFilter2D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13958 {
13959 GLenum target;
13960 GLenum internalformat;
13961 GLsizei width;
13962 GLsizei height;
13963 GLenum format;
13964 GLenum type;
13965 ErlNifBinary row;
13966 GLvoid *row_idx;
13967 ErlNifBinary column;
13968 GLvoid *column_idx;
13969 if(!enif_get_uint(env, argv[0], &target)) Badarg(5951,"target");
13970 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5951,"internalformat");
13971 if(!enif_get_int(env, argv[2], &width)) Badarg(5951,"width");
13972 if(!enif_get_int(env, argv[3], &height)) Badarg(5951,"height");
13973 if(!enif_get_uint(env, argv[4], &format)) Badarg(5951,"format");
13974 if(!enif_get_uint(env, argv[5], &type)) Badarg(5951,"type");
13975 if(!egl_get_ptr(env, argv[6], (void **) &row_idx)) {
13976 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[6], &row))
13977 row_idx = (GLvoid *) row.data;
13978 else Badarg(5951,"row");
13979 }
13980 if(!egl_get_ptr(env, argv[7], (void **) &column_idx)) {
13981 if(enif_inspect_binary(env, (ERL_NIF_TERM) argv[7], &column))
13982 column_idx = (GLvoid *) column.data;
13983 else Badarg(5951,"column");
13984 }
13985 weglSeparableFilter2D(target,internalformat,width,height,format,type,row_idx,column_idx);
13986 }
13987
ecb_glGetHistogram(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])13988 void ecb_glGetHistogram(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
13989 {
13990 GLenum target;
13991 GLboolean reset;
13992 GLenum format;
13993 GLenum type;
13994 ErlNifBinary values;
13995 if(!enif_get_uint(env, argv[0], &target)) Badarg(5953,"target");
13996 if(!egl_get_ubyte(env, argv[1], &reset)) Badarg(5953,"reset");
13997 if(!enif_get_uint(env, argv[2], &format)) Badarg(5953,"format");
13998 if(!enif_get_uint(env, argv[3], &type)) Badarg(5953,"type");
13999 if(enif_is_binary(env, argv[4]))
14000 enif_inspect_binary(env, argv[4], &values);
14001 else if(enif_is_tuple(env, argv[4])) {
14002 int values_a;
14003 const ERL_NIF_TERM *values_t;
14004 if(enif_get_tuple(env, argv[4], &values_a, &values_t) &&
14005 enif_is_binary(env, values_t[1]))
14006 enif_inspect_binary(env, values_t[1], &values);
14007 else Badarg(5953, "values");
14008 } else Badarg(5953, "values");
14009 weglGetHistogram(target,reset,format,type,(GLvoid *) values.data);
14010 enif_send(NULL, self, env,
14011 enif_make_tuple2(env,EGL_ATOM_REPLY,
14012 EGL_ATOM_OK));
14013 }
14014
ecb_glGetHistogramParameterfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14015 void ecb_glGetHistogramParameterfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14016 {
14017 ERL_NIF_TERM reply;
14018 GLenum target;
14019 GLenum pname;
14020 GLfloat params[1];
14021 if(!enif_get_uint(env, argv[0], &target)) Badarg(5954,"target");
14022 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5954,"pname");
14023 weglGetHistogramParameterfv(target,pname,params);
14024 reply = enif_make_tuple1(env,
14025 enif_make_double(env, (double) params[0]));
14026 enif_send(NULL, self, env,
14027 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14028 }
14029
ecb_glGetHistogramParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14030 void ecb_glGetHistogramParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14031 {
14032 ERL_NIF_TERM reply;
14033 GLenum target;
14034 GLenum pname;
14035 GLint params[1];
14036 if(!enif_get_uint(env, argv[0], &target)) Badarg(5955,"target");
14037 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5955,"pname");
14038 weglGetHistogramParameteriv(target,pname,params);
14039 reply = enif_make_tuple1(env,
14040 enif_make_int(env, params[0]));
14041 enif_send(NULL, self, env,
14042 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14043 }
14044
ecb_glGetMinmax(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14045 void ecb_glGetMinmax(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14046 {
14047 GLenum target;
14048 GLboolean reset;
14049 GLenum format;
14050 GLenum types;
14051 ErlNifBinary values;
14052 if(!enif_get_uint(env, argv[0], &target)) Badarg(5956,"target");
14053 if(!egl_get_ubyte(env, argv[1], &reset)) Badarg(5956,"reset");
14054 if(!enif_get_uint(env, argv[2], &format)) Badarg(5956,"format");
14055 if(!enif_get_uint(env, argv[3], &types)) Badarg(5956,"types");
14056 if(enif_is_binary(env, argv[4]))
14057 enif_inspect_binary(env, argv[4], &values);
14058 else if(enif_is_tuple(env, argv[4])) {
14059 int values_a;
14060 const ERL_NIF_TERM *values_t;
14061 if(enif_get_tuple(env, argv[4], &values_a, &values_t) &&
14062 enif_is_binary(env, values_t[1]))
14063 enif_inspect_binary(env, values_t[1], &values);
14064 else Badarg(5956, "values");
14065 } else Badarg(5956, "values");
14066 weglGetMinmax(target,reset,format,types,(GLvoid *) values.data);
14067 enif_send(NULL, self, env,
14068 enif_make_tuple2(env,EGL_ATOM_REPLY,
14069 EGL_ATOM_OK));
14070 }
14071
ecb_glGetMinmaxParameterfv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14072 void ecb_glGetMinmaxParameterfv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14073 {
14074 ERL_NIF_TERM reply;
14075 GLenum target;
14076 GLenum pname;
14077 GLfloat params[1];
14078 if(!enif_get_uint(env, argv[0], &target)) Badarg(5957,"target");
14079 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5957,"pname");
14080 weglGetMinmaxParameterfv(target,pname,params);
14081 reply = enif_make_tuple1(env,
14082 enif_make_double(env, (double) params[0]));
14083 enif_send(NULL, self, env,
14084 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14085 }
14086
ecb_glGetMinmaxParameteriv(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14087 void ecb_glGetMinmaxParameteriv(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14088 {
14089 ERL_NIF_TERM reply;
14090 GLenum target;
14091 GLenum pname;
14092 GLint params[1];
14093 if(!enif_get_uint(env, argv[0], &target)) Badarg(5958,"target");
14094 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5958,"pname");
14095 weglGetMinmaxParameteriv(target,pname,params);
14096 reply = enif_make_tuple1(env,
14097 enif_make_int(env, params[0]));
14098 enif_send(NULL, self, env,
14099 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14100 }
14101
ecb_glHistogram(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14102 void ecb_glHistogram(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14103 {
14104 GLenum target;
14105 GLsizei width;
14106 GLenum internalformat;
14107 GLboolean sink;
14108 if(!enif_get_uint(env, argv[0], &target)) Badarg(5959,"target");
14109 if(!enif_get_int(env, argv[1], &width)) Badarg(5959,"width");
14110 if(!enif_get_uint(env, argv[2], &internalformat)) Badarg(5959,"internalformat");
14111 if(!egl_get_ubyte(env, argv[3], &sink)) Badarg(5959,"sink");
14112 weglHistogram(target,width,internalformat,sink);
14113 }
14114
ecb_glMinmax(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14115 void ecb_glMinmax(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14116 {
14117 GLenum target;
14118 GLenum internalformat;
14119 GLboolean sink;
14120 if(!enif_get_uint(env, argv[0], &target)) Badarg(5960,"target");
14121 if(!enif_get_uint(env, argv[1], &internalformat)) Badarg(5960,"internalformat");
14122 if(!egl_get_ubyte(env, argv[2], &sink)) Badarg(5960,"sink");
14123 weglMinmax(target,internalformat,sink);
14124 }
14125
ecb_glResetHistogram(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14126 void ecb_glResetHistogram(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14127 {
14128 GLenum target;
14129 if(!enif_get_uint(env, argv[0], &target)) Badarg(5961,"target");
14130 weglResetHistogram(target);
14131 }
14132
ecb_glResetMinmax(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14133 void ecb_glResetMinmax(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14134 {
14135 GLenum target;
14136 if(!enif_get_uint(env, argv[0], &target)) Badarg(5962,"target");
14137 weglResetMinmax(target);
14138 }
14139
ecb_glCurrentPaletteMatrixARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14140 void ecb_glCurrentPaletteMatrixARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14141 {
14142 GLint index;
14143 if(!enif_get_int(env, argv[0], &index)) Badarg(5963,"index");
14144 weglCurrentPaletteMatrixARB(index);
14145 }
14146
ecb_glMatrixIndexubvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14147 void ecb_glMatrixIndexubvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14148 {
14149 GLint size;
14150 GLubyte *indices;
14151 if(!enif_get_int(env, argv[0], &size)) Badarg(5964,"size");
14152 if(!enif_is_list(env, argv[1])) Badarg(5964, "indices")
14153 else {
14154 ERL_NIF_TERM indices_l, indices_h, indices_t;
14155 std::vector <GLubyte> indices_vec;
14156 GLubyte indices_tmp;
14157 indices_l = argv[1];
14158 while(enif_get_list_cell(env, indices_l, &indices_h, &indices_t)) {
14159 if(!egl_get_ubyte(env, indices_h, &indices_tmp)) Badarg(5964,"indices");
14160 indices_vec.push_back(indices_tmp);
14161 indices_l = indices_t;
14162 };
14163 indices = indices_vec.data();
14164 }
14165 weglMatrixIndexubvARB(size,indices);
14166 }
14167
ecb_glMatrixIndexusvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14168 void ecb_glMatrixIndexusvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14169 {
14170 GLint size;
14171 GLushort *indices;
14172 if(!enif_get_int(env, argv[0], &size)) Badarg(5965,"size");
14173 if(!enif_is_list(env, argv[1])) Badarg(5965, "indices")
14174 else {
14175 ERL_NIF_TERM indices_l, indices_h, indices_t;
14176 std::vector <GLushort> indices_vec;
14177 GLushort indices_tmp;
14178 indices_l = argv[1];
14179 while(enif_get_list_cell(env, indices_l, &indices_h, &indices_t)) {
14180 if(!egl_get_ushort(env, indices_h, &indices_tmp)) Badarg(5965,"indices");
14181 indices_vec.push_back(indices_tmp);
14182 indices_l = indices_t;
14183 };
14184 indices = indices_vec.data();
14185 }
14186 weglMatrixIndexusvARB(size,indices);
14187 }
14188
ecb_glMatrixIndexuivARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14189 void ecb_glMatrixIndexuivARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14190 {
14191 GLint size;
14192 GLuint *indices;
14193 if(!enif_get_int(env, argv[0], &size)) Badarg(5966,"size");
14194 if(!enif_is_list(env, argv[1])) Badarg(5966, "indices")
14195 else {
14196 ERL_NIF_TERM indices_l, indices_h, indices_t;
14197 std::vector <GLuint> indices_vec;
14198 GLuint indices_tmp;
14199 indices_l = argv[1];
14200 while(enif_get_list_cell(env, indices_l, &indices_h, &indices_t)) {
14201 if(!enif_get_uint(env, indices_h, &indices_tmp)) Badarg(5966,"indices");
14202 indices_vec.push_back(indices_tmp);
14203 indices_l = indices_t;
14204 };
14205 indices = indices_vec.data();
14206 }
14207 weglMatrixIndexuivARB(size,indices);
14208 }
14209
ecb_glSampleCoverageARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14210 void ecb_glSampleCoverageARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14211 {
14212 GLfloat value;
14213 GLboolean invert;
14214 if(!egl_get_float(env, argv[0], &value)) Badarg(5967,"value");
14215 if(!egl_get_ubyte(env, argv[1], &invert)) Badarg(5967,"invert");
14216 weglSampleCoverageARB(value,invert);
14217 }
14218
ecb_glMaxShaderCompilerThreadsARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14219 void ecb_glMaxShaderCompilerThreadsARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14220 {
14221 GLuint count;
14222 if(!enif_get_uint(env, argv[0], &count)) Badarg(5968,"count");
14223 weglMaxShaderCompilerThreadsARB(count);
14224 }
14225
ecb_glEvaluateDepthValuesARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14226 void ecb_glEvaluateDepthValuesARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14227 {
14228 weglEvaluateDepthValuesARB();
14229 }
14230
ecb_glDeleteObjectARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14231 void ecb_glDeleteObjectARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14232 {
14233 egl_uint64_t obj;
14234 if(!enif_get_uint64(env, argv[0], &obj)) Badarg(5970,"obj");
14235 weglDeleteObjectARB((GLhandleARB) obj);
14236 }
14237
ecb_glGetHandleARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14238 void ecb_glGetHandleARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14239 {
14240 GLhandleARB result;
14241 ERL_NIF_TERM reply;
14242 GLenum pname;
14243 if(!enif_get_uint(env, argv[0], &pname)) Badarg(5971,"pname");
14244 result = weglGetHandleARB(pname);
14245 reply = enif_make_uint64(env, (egl_uint64_t) result);
14246 enif_send(NULL, self, env,
14247 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14248 }
14249
ecb_glDetachObjectARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14250 void ecb_glDetachObjectARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14251 {
14252 egl_uint64_t containerObj;
14253 egl_uint64_t attachedObj;
14254 if(!enif_get_uint64(env, argv[0], &containerObj)) Badarg(5972,"containerObj");
14255 if(!enif_get_uint64(env, argv[1], &attachedObj)) Badarg(5972,"attachedObj");
14256 weglDetachObjectARB((GLhandleARB) containerObj,(GLhandleARB) attachedObj);
14257 }
14258
ecb_glCreateShaderObjectARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14259 void ecb_glCreateShaderObjectARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14260 {
14261 GLhandleARB result;
14262 ERL_NIF_TERM reply;
14263 GLenum shaderType;
14264 if(!enif_get_uint(env, argv[0], &shaderType)) Badarg(5973,"shaderType");
14265 result = weglCreateShaderObjectARB(shaderType);
14266 reply = enif_make_uint64(env, (egl_uint64_t) result);
14267 enif_send(NULL, self, env,
14268 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14269 }
14270
ecb_glShaderSourceARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14271 void ecb_glShaderSourceARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14272 {
14273 egl_uint64_t shaderObj;
14274 GLsizei count;
14275 if(!enif_get_uint64(env, argv[0], &shaderObj)) Badarg(5974,"shaderObj");
14276 if(!enif_get_int(env, argv[1], &count)) Badarg(5974,"count");
14277 ERL_NIF_TERM string_l, string_h, string_t;
14278 ErlNifBinary string_tmp;
14279 std::vector <GLchar *> string;
14280 string_l = argv[2];
14281 while(enif_get_list_cell(env, string_l, &string_h, &string_t)) {
14282 if(!enif_inspect_binary(env, string_h, &string_tmp)) Badarg(5974,"string");
14283 string.push_back((GLchar *) string_tmp.data);
14284 string_l = string_t;
14285 }
14286 weglShaderSourceARB((GLhandleARB) shaderObj,count,(const GLchar **) string.data(),NULL);
14287 }
14288
ecb_glCompileShaderARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14289 void ecb_glCompileShaderARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14290 {
14291 egl_uint64_t shaderObj;
14292 if(!enif_get_uint64(env, argv[0], &shaderObj)) Badarg(5975,"shaderObj");
14293 weglCompileShaderARB((GLhandleARB) shaderObj);
14294 }
14295
ecb_glCreateProgramObjectARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14296 void ecb_glCreateProgramObjectARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14297 {
14298 GLhandleARB result;
14299 ERL_NIF_TERM reply;
14300 result = weglCreateProgramObjectARB();
14301 reply = enif_make_uint64(env, (egl_uint64_t) result);
14302 enif_send(NULL, self, env,
14303 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14304 }
14305
ecb_glAttachObjectARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14306 void ecb_glAttachObjectARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14307 {
14308 egl_uint64_t containerObj;
14309 egl_uint64_t obj;
14310 if(!enif_get_uint64(env, argv[0], &containerObj)) Badarg(5977,"containerObj");
14311 if(!enif_get_uint64(env, argv[1], &obj)) Badarg(5977,"obj");
14312 weglAttachObjectARB((GLhandleARB) containerObj,(GLhandleARB) obj);
14313 }
14314
ecb_glLinkProgramARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14315 void ecb_glLinkProgramARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14316 {
14317 egl_uint64_t programObj;
14318 if(!enif_get_uint64(env, argv[0], &programObj)) Badarg(5978,"programObj");
14319 weglLinkProgramARB((GLhandleARB) programObj);
14320 }
14321
ecb_glUseProgramObjectARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14322 void ecb_glUseProgramObjectARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14323 {
14324 egl_uint64_t programObj;
14325 if(!enif_get_uint64(env, argv[0], &programObj)) Badarg(5979,"programObj");
14326 weglUseProgramObjectARB((GLhandleARB) programObj);
14327 }
14328
ecb_glValidateProgramARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14329 void ecb_glValidateProgramARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14330 {
14331 egl_uint64_t programObj;
14332 if(!enif_get_uint64(env, argv[0], &programObj)) Badarg(5980,"programObj");
14333 weglValidateProgramARB((GLhandleARB) programObj);
14334 }
14335
ecb_glGetObjectParameterfvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14336 void ecb_glGetObjectParameterfvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14337 {
14338 ERL_NIF_TERM reply;
14339 egl_uint64_t obj;
14340 GLenum pname;
14341 GLfloat params;
14342 if(!enif_get_uint64(env, argv[0], &obj)) Badarg(5981,"obj");
14343 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5981,"pname");
14344 weglGetObjectParameterfvARB((GLhandleARB) obj,pname,¶ms);
14345 reply = enif_make_double(env, (double) params);
14346 enif_send(NULL, self, env,
14347 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14348 }
14349
ecb_glGetObjectParameterivARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14350 void ecb_glGetObjectParameterivARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14351 {
14352 ERL_NIF_TERM reply;
14353 egl_uint64_t obj;
14354 GLenum pname;
14355 GLint params;
14356 if(!enif_get_uint64(env, argv[0], &obj)) Badarg(5982,"obj");
14357 if(!enif_get_uint(env, argv[1], &pname)) Badarg(5982,"pname");
14358 weglGetObjectParameterivARB((GLhandleARB) obj,pname,¶ms);
14359 reply = enif_make_int(env, params);
14360 enif_send(NULL, self, env,
14361 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14362 }
14363
ecb_glGetInfoLogARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14364 void ecb_glGetInfoLogARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14365 {
14366 ERL_NIF_TERM reply;
14367 egl_uint64_t obj;
14368 GLsizei maxLength;
14369 GLsizei length;
14370 unsigned char *infoLog;
14371 if(!enif_get_uint64(env, argv[0], &obj)) Badarg(5983,"obj");
14372 if(!enif_get_int(env, argv[1], &maxLength)) Badarg(5983,"maxLength");
14373 infoLog = (unsigned char *) enif_alloc((int) maxLength*sizeof(GLchar));
14374 weglGetInfoLogARB((GLhandleARB) obj,maxLength,&length,(GLchar *) infoLog);
14375 reply = enif_make_string(env, (const char *) infoLog, ERL_NIF_LATIN1);
14376 enif_send(NULL, self, env,
14377 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14378 enif_free(infoLog);
14379 }
14380
ecb_glGetAttachedObjectsARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14381 void ecb_glGetAttachedObjectsARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14382 {
14383 ERL_NIF_TERM reply;
14384 egl_uint64_t containerObj;
14385 GLsizei maxCount;
14386 GLsizei count;
14387 if(!enif_get_uint64(env, argv[0], &containerObj)) Badarg(5984,"containerObj");
14388 if(!enif_get_int(env, argv[1], &maxCount)) Badarg(5984,"maxCount");
14389 std::vector <GLhandleARB> obj (maxCount);
14390 std::vector <ERL_NIF_TERM> obj_ts (maxCount);
14391 weglGetAttachedObjectsARB((GLhandleARB) containerObj,maxCount,&count,obj.data());
14392 for(int ri=0; ri < (int) count; ri++)
14393 obj_ts[ri] = enif_make_uint64(env, (egl_uint64_t) obj[ri]);
14394 reply = enif_make_list_from_array(env, obj_ts.data(), count);
14395 enif_send(NULL, self, env,
14396 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14397 }
14398
ecb_glGetUniformLocationARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14399 void ecb_glGetUniformLocationARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14400 {
14401 GLint result;
14402 ERL_NIF_TERM reply;
14403 egl_uint64_t programObj;
14404 ErlNifBinary name;
14405 if(!enif_get_uint64(env, argv[0], &programObj)) Badarg(5985,"programObj");
14406 if(!enif_inspect_binary(env, argv[1], &name)) Badarg(5985,"name");
14407 result = weglGetUniformLocationARB((GLhandleARB) programObj,(GLchar *) name.data);
14408 reply = enif_make_int(env, result);
14409 enif_send(NULL, self, env,
14410 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14411 }
14412
ecb_glGetActiveUniformARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14413 void ecb_glGetActiveUniformARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14414 {
14415 ERL_NIF_TERM reply;
14416 egl_uint64_t programObj;
14417 GLuint index;
14418 GLsizei maxLength;
14419 GLsizei length;
14420 GLint size;
14421 GLenum type;
14422 unsigned char *name;
14423 if(!enif_get_uint64(env, argv[0], &programObj)) Badarg(5986,"programObj");
14424 if(!enif_get_uint(env, argv[1], &index)) Badarg(5986,"index");
14425 if(!enif_get_int(env, argv[2], &maxLength)) Badarg(5986,"maxLength");
14426 name = (unsigned char *) enif_alloc((int) maxLength*sizeof(GLchar));
14427 weglGetActiveUniformARB((GLhandleARB) programObj,index,maxLength,&length,&size,&type,(GLchar *) name);
14428 reply = enif_make_tuple3(env,
14429 enif_make_int(env, size),
14430 enif_make_int(env, type),
14431 enif_make_string(env, (const char *) name, ERL_NIF_LATIN1) );
14432 enif_send(NULL, self, env,
14433 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14434 enif_free(name);
14435 }
14436
ecb_glGetUniformfvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14437 void ecb_glGetUniformfvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14438 {
14439 ERL_NIF_TERM reply;
14440 egl_uint64_t programObj;
14441 GLint location;
14442 GLfloat params[16];
14443 ERL_NIF_TERM params_ts[16];
14444 if(!enif_get_uint64(env, argv[0], &programObj)) Badarg(5987,"programObj");
14445 if(!enif_get_int(env, argv[1], &location)) Badarg(5987,"location");
14446 weglGetUniformfvARB((GLhandleARB) programObj,location,params);
14447 for(int ri=0; ri < (int) 16; ri++)
14448 params_ts[ri] = enif_make_double(env, (double) params[ri]);
14449 reply = enif_make_tuple_from_array(env, params_ts, 16);
14450 enif_send(NULL, self, env,
14451 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14452 }
14453
ecb_glGetUniformivARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14454 void ecb_glGetUniformivARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14455 {
14456 ERL_NIF_TERM reply;
14457 egl_uint64_t programObj;
14458 GLint location;
14459 GLint params[16];
14460 ERL_NIF_TERM params_ts[16];
14461 if(!enif_get_uint64(env, argv[0], &programObj)) Badarg(5988,"programObj");
14462 if(!enif_get_int(env, argv[1], &location)) Badarg(5988,"location");
14463 weglGetUniformivARB((GLhandleARB) programObj,location,params);
14464 for(int ri=0; ri < (int) 16; ri++)
14465 params_ts[ri] = enif_make_int(env, params[ri]);
14466 reply = enif_make_tuple_from_array(env, params_ts, 16);
14467 enif_send(NULL, self, env,
14468 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14469 }
14470
ecb_glGetShaderSourceARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14471 void ecb_glGetShaderSourceARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14472 {
14473 ERL_NIF_TERM reply;
14474 egl_uint64_t obj;
14475 GLsizei maxLength;
14476 GLsizei length;
14477 unsigned char *source;
14478 if(!enif_get_uint64(env, argv[0], &obj)) Badarg(5989,"obj");
14479 if(!enif_get_int(env, argv[1], &maxLength)) Badarg(5989,"maxLength");
14480 source = (unsigned char *) enif_alloc((int) maxLength*sizeof(GLchar));
14481 weglGetShaderSourceARB((GLhandleARB) obj,maxLength,&length,(GLchar *) source);
14482 reply = enif_make_string(env, (const char *) source, ERL_NIF_LATIN1);
14483 enif_send(NULL, self, env,
14484 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14485 enif_free(source);
14486 }
14487
ecb_glDeleteNamedStringARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14488 void ecb_glDeleteNamedStringARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14489 {
14490 ErlNifBinary name;
14491 if(!enif_inspect_binary(env, argv[0], &name)) Badarg(5990,"name");
14492 weglDeleteNamedStringARB((GLint) name.size,(GLchar *) name.data);
14493 }
14494
ecb_glCompileShaderIncludeARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14495 void ecb_glCompileShaderIncludeARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14496 {
14497 GLuint shader;
14498 GLsizei count;
14499 if(!enif_get_uint(env, argv[0], &shader)) Badarg(5991,"shader");
14500 if(!enif_get_int(env, argv[1], &count)) Badarg(5991,"count");
14501 ERL_NIF_TERM path_l, path_h, path_t;
14502 ErlNifBinary path_tmp;
14503 std::vector <GLchar *> path;
14504 path_l = argv[2];
14505 while(enif_get_list_cell(env, path_l, &path_h, &path_t)) {
14506 if(!enif_inspect_binary(env, path_h, &path_tmp)) Badarg(5991,"path");
14507 path.push_back((GLchar *) path_tmp.data);
14508 path_l = path_t;
14509 }
14510 weglCompileShaderIncludeARB(shader,count,(const GLchar **) path.data(),NULL);
14511 }
14512
ecb_glIsNamedStringARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14513 void ecb_glIsNamedStringARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14514 {
14515 GLboolean result;
14516 ERL_NIF_TERM reply;
14517 ErlNifBinary name;
14518 if(!enif_inspect_binary(env, argv[0], &name)) Badarg(5992,"name");
14519 result = weglIsNamedStringARB((GLint) name.size,(GLchar *) name.data);
14520 reply = enif_make_int(env, result);
14521 enif_send(NULL, self, env,
14522 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14523 }
14524
ecb_glBufferPageCommitmentARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14525 void ecb_glBufferPageCommitmentARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14526 {
14527 GLenum target;
14528 GLintptr offset;
14529 GLsizeiptr size;
14530 GLboolean commit;
14531 if(!enif_get_uint(env, argv[0], &target)) Badarg(5993,"target");
14532 if(!egl_get_word(env, argv[1], (egl_word *) &offset)) Badarg(5993,"offset");
14533 if(!egl_get_word(env, argv[2], (egl_word *) &size)) Badarg(5993,"size");
14534 if(!egl_get_ubyte(env, argv[3], &commit)) Badarg(5993,"commit");
14535 weglBufferPageCommitmentARB(target,offset,size,commit);
14536 }
14537
ecb_glTexPageCommitmentARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14538 void ecb_glTexPageCommitmentARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14539 {
14540 GLenum target;
14541 GLint level;
14542 GLint xoffset;
14543 GLint yoffset;
14544 GLint zoffset;
14545 GLsizei width;
14546 GLsizei height;
14547 GLsizei depth;
14548 GLboolean commit;
14549 if(!enif_get_uint(env, argv[0], &target)) Badarg(5994,"target");
14550 if(!enif_get_int(env, argv[1], &level)) Badarg(5994,"level");
14551 if(!enif_get_int(env, argv[2], &xoffset)) Badarg(5994,"xoffset");
14552 if(!enif_get_int(env, argv[3], &yoffset)) Badarg(5994,"yoffset");
14553 if(!enif_get_int(env, argv[4], &zoffset)) Badarg(5994,"zoffset");
14554 if(!enif_get_int(env, argv[5], &width)) Badarg(5994,"width");
14555 if(!enif_get_int(env, argv[6], &height)) Badarg(5994,"height");
14556 if(!enif_get_int(env, argv[7], &depth)) Badarg(5994,"depth");
14557 if(!egl_get_ubyte(env, argv[8], &commit)) Badarg(5994,"commit");
14558 weglTexPageCommitmentARB(target,level,xoffset,yoffset,zoffset,width,height,depth,commit);
14559 }
14560
ecb_glGetCompressedTexImageARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14561 void ecb_glGetCompressedTexImageARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14562 {
14563 GLenum target;
14564 GLint level;
14565 ErlNifBinary img;
14566 if(!enif_get_uint(env, argv[0], &target)) Badarg(5995,"target");
14567 if(!enif_get_int(env, argv[1], &level)) Badarg(5995,"level");
14568 if(enif_is_binary(env, argv[2]))
14569 enif_inspect_binary(env, argv[2], &img);
14570 else if(enif_is_tuple(env, argv[2])) {
14571 int img_a;
14572 const ERL_NIF_TERM *img_t;
14573 if(enif_get_tuple(env, argv[2], &img_a, &img_t) &&
14574 enif_is_binary(env, img_t[1]))
14575 enif_inspect_binary(env, img_t[1], &img);
14576 else Badarg(5995, "img");
14577 } else Badarg(5995, "img");
14578 weglGetCompressedTexImageARB(target,level,(void *) img.data);
14579 enif_send(NULL, self, env,
14580 enif_make_tuple2(env,EGL_ATOM_REPLY,
14581 EGL_ATOM_OK));
14582 }
14583
ecb_glLoadTransposeMatrixfARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14584 void ecb_glLoadTransposeMatrixfARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14585 {
14586 GLfloat m[16];
14587 {
14588 int m_a;
14589 const ERL_NIF_TERM *m_t;
14590 if(!enif_get_tuple(env, argv[0], &m_a, &m_t)
14591 || (m_a != 12 && m_a != 16)) {
14592 Badarg(5996,"m");
14593 } else {
14594 int i1 = 0;
14595 if(!egl_get_float(env, m_t[i1++], &m[0])) Badarg(5996,"m");
14596 if(!egl_get_float(env, m_t[i1++], &m[1])) Badarg(5996,"m");
14597 if(!egl_get_float(env, m_t[i1++], &m[2])) Badarg(5996,"m");
14598 if(m_a == 16)
14599 if(!egl_get_float(env, m_t[i1++], &m[3])) Badarg(5996,"m");
14600 if(!egl_get_float(env, m_t[i1++], &m[4])) Badarg(5996,"m");
14601 if(!egl_get_float(env, m_t[i1++], &m[5])) Badarg(5996,"m");
14602 if(!egl_get_float(env, m_t[i1++], &m[6])) Badarg(5996,"m");
14603 if(m_a == 16)
14604 if(!egl_get_float(env, m_t[i1++], &m[7])) Badarg(5996,"m");
14605 if(!egl_get_float(env, m_t[i1++], &m[8])) Badarg(5996,"m");
14606 if(!egl_get_float(env, m_t[i1++], &m[9])) Badarg(5996,"m");
14607 if(!egl_get_float(env, m_t[i1++], &m[10])) Badarg(5996,"m");
14608 if(m_a == 16)
14609 if(!egl_get_float(env, m_t[i1++], &m[11])) Badarg(5996,"m");
14610 if(!egl_get_float(env, m_t[i1++], &m[12])) Badarg(5996,"m");
14611 if(!egl_get_float(env, m_t[i1++], &m[13])) Badarg(5996,"m");
14612 if(!egl_get_float(env, m_t[i1++], &m[14])) Badarg(5996,"m");
14613 if(m_a == 16) {
14614 if(!egl_get_float(env, m_t[i1++], &m[15])) Badarg(5996,"m");
14615 } else {
14616 m[3] = 0.0; m[7] = 0.0; m[11] = 0.0; m[15] = 1.0;
14617 }
14618 }};
14619 weglLoadTransposeMatrixfARB(m);
14620 }
14621
ecb_glLoadTransposeMatrixdARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14622 void ecb_glLoadTransposeMatrixdARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14623 {
14624 GLdouble m[16];
14625 {
14626 int m_a;
14627 const ERL_NIF_TERM *m_t;
14628 if(!enif_get_tuple(env, argv[0], &m_a, &m_t)
14629 || (m_a != 12 && m_a != 16)) {
14630 Badarg(5997,"m");
14631 } else {
14632 int i1 = 0;
14633 if(!enif_get_double(env, m_t[i1++], &m[0])) Badarg(5997,"m");
14634 if(!enif_get_double(env, m_t[i1++], &m[1])) Badarg(5997,"m");
14635 if(!enif_get_double(env, m_t[i1++], &m[2])) Badarg(5997,"m");
14636 if(m_a == 16)
14637 if(!enif_get_double(env, m_t[i1++], &m[3])) Badarg(5997,"m");
14638 if(!enif_get_double(env, m_t[i1++], &m[4])) Badarg(5997,"m");
14639 if(!enif_get_double(env, m_t[i1++], &m[5])) Badarg(5997,"m");
14640 if(!enif_get_double(env, m_t[i1++], &m[6])) Badarg(5997,"m");
14641 if(m_a == 16)
14642 if(!enif_get_double(env, m_t[i1++], &m[7])) Badarg(5997,"m");
14643 if(!enif_get_double(env, m_t[i1++], &m[8])) Badarg(5997,"m");
14644 if(!enif_get_double(env, m_t[i1++], &m[9])) Badarg(5997,"m");
14645 if(!enif_get_double(env, m_t[i1++], &m[10])) Badarg(5997,"m");
14646 if(m_a == 16)
14647 if(!enif_get_double(env, m_t[i1++], &m[11])) Badarg(5997,"m");
14648 if(!enif_get_double(env, m_t[i1++], &m[12])) Badarg(5997,"m");
14649 if(!enif_get_double(env, m_t[i1++], &m[13])) Badarg(5997,"m");
14650 if(!enif_get_double(env, m_t[i1++], &m[14])) Badarg(5997,"m");
14651 if(m_a == 16) {
14652 if(!enif_get_double(env, m_t[i1++], &m[15])) Badarg(5997,"m");
14653 } else {
14654 m[3] = 0.0; m[7] = 0.0; m[11] = 0.0; m[15] = 1.0;
14655 }
14656 }};
14657 weglLoadTransposeMatrixdARB(m);
14658 }
14659
ecb_glMultTransposeMatrixfARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14660 void ecb_glMultTransposeMatrixfARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14661 {
14662 GLfloat m[16];
14663 {
14664 int m_a;
14665 const ERL_NIF_TERM *m_t;
14666 if(!enif_get_tuple(env, argv[0], &m_a, &m_t)
14667 || (m_a != 12 && m_a != 16)) {
14668 Badarg(5998,"m");
14669 } else {
14670 int i1 = 0;
14671 if(!egl_get_float(env, m_t[i1++], &m[0])) Badarg(5998,"m");
14672 if(!egl_get_float(env, m_t[i1++], &m[1])) Badarg(5998,"m");
14673 if(!egl_get_float(env, m_t[i1++], &m[2])) Badarg(5998,"m");
14674 if(m_a == 16)
14675 if(!egl_get_float(env, m_t[i1++], &m[3])) Badarg(5998,"m");
14676 if(!egl_get_float(env, m_t[i1++], &m[4])) Badarg(5998,"m");
14677 if(!egl_get_float(env, m_t[i1++], &m[5])) Badarg(5998,"m");
14678 if(!egl_get_float(env, m_t[i1++], &m[6])) Badarg(5998,"m");
14679 if(m_a == 16)
14680 if(!egl_get_float(env, m_t[i1++], &m[7])) Badarg(5998,"m");
14681 if(!egl_get_float(env, m_t[i1++], &m[8])) Badarg(5998,"m");
14682 if(!egl_get_float(env, m_t[i1++], &m[9])) Badarg(5998,"m");
14683 if(!egl_get_float(env, m_t[i1++], &m[10])) Badarg(5998,"m");
14684 if(m_a == 16)
14685 if(!egl_get_float(env, m_t[i1++], &m[11])) Badarg(5998,"m");
14686 if(!egl_get_float(env, m_t[i1++], &m[12])) Badarg(5998,"m");
14687 if(!egl_get_float(env, m_t[i1++], &m[13])) Badarg(5998,"m");
14688 if(!egl_get_float(env, m_t[i1++], &m[14])) Badarg(5998,"m");
14689 if(m_a == 16) {
14690 if(!egl_get_float(env, m_t[i1++], &m[15])) Badarg(5998,"m");
14691 } else {
14692 m[3] = 0.0; m[7] = 0.0; m[11] = 0.0; m[15] = 1.0;
14693 }
14694 }};
14695 weglMultTransposeMatrixfARB(m);
14696 }
14697
ecb_glMultTransposeMatrixdARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14698 void ecb_glMultTransposeMatrixdARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14699 {
14700 GLdouble m[16];
14701 {
14702 int m_a;
14703 const ERL_NIF_TERM *m_t;
14704 if(!enif_get_tuple(env, argv[0], &m_a, &m_t)
14705 || (m_a != 12 && m_a != 16)) {
14706 Badarg(5999,"m");
14707 } else {
14708 int i1 = 0;
14709 if(!enif_get_double(env, m_t[i1++], &m[0])) Badarg(5999,"m");
14710 if(!enif_get_double(env, m_t[i1++], &m[1])) Badarg(5999,"m");
14711 if(!enif_get_double(env, m_t[i1++], &m[2])) Badarg(5999,"m");
14712 if(m_a == 16)
14713 if(!enif_get_double(env, m_t[i1++], &m[3])) Badarg(5999,"m");
14714 if(!enif_get_double(env, m_t[i1++], &m[4])) Badarg(5999,"m");
14715 if(!enif_get_double(env, m_t[i1++], &m[5])) Badarg(5999,"m");
14716 if(!enif_get_double(env, m_t[i1++], &m[6])) Badarg(5999,"m");
14717 if(m_a == 16)
14718 if(!enif_get_double(env, m_t[i1++], &m[7])) Badarg(5999,"m");
14719 if(!enif_get_double(env, m_t[i1++], &m[8])) Badarg(5999,"m");
14720 if(!enif_get_double(env, m_t[i1++], &m[9])) Badarg(5999,"m");
14721 if(!enif_get_double(env, m_t[i1++], &m[10])) Badarg(5999,"m");
14722 if(m_a == 16)
14723 if(!enif_get_double(env, m_t[i1++], &m[11])) Badarg(5999,"m");
14724 if(!enif_get_double(env, m_t[i1++], &m[12])) Badarg(5999,"m");
14725 if(!enif_get_double(env, m_t[i1++], &m[13])) Badarg(5999,"m");
14726 if(!enif_get_double(env, m_t[i1++], &m[14])) Badarg(5999,"m");
14727 if(m_a == 16) {
14728 if(!enif_get_double(env, m_t[i1++], &m[15])) Badarg(5999,"m");
14729 } else {
14730 m[3] = 0.0; m[7] = 0.0; m[11] = 0.0; m[15] = 1.0;
14731 }
14732 }};
14733 weglMultTransposeMatrixdARB(m);
14734 }
14735
ecb_glWeightbvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14736 void ecb_glWeightbvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14737 {
14738 GLint size;
14739 GLbyte *weights;
14740 if(!enif_get_int(env, argv[0], &size)) Badarg(6000,"size");
14741 if(!enif_is_list(env, argv[1])) Badarg(6000, "weights")
14742 else {
14743 ERL_NIF_TERM weights_l, weights_h, weights_t;
14744 std::vector <GLbyte> weights_vec;
14745 GLbyte weights_tmp;
14746 weights_l = argv[1];
14747 while(enif_get_list_cell(env, weights_l, &weights_h, &weights_t)) {
14748 if(!egl_get_byte(env, weights_h, &weights_tmp)) Badarg(6000,"weights");
14749 weights_vec.push_back(weights_tmp);
14750 weights_l = weights_t;
14751 };
14752 weights = weights_vec.data();
14753 }
14754 weglWeightbvARB(size,weights);
14755 }
14756
ecb_glWeightsvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14757 void ecb_glWeightsvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14758 {
14759 GLint size;
14760 GLshort *weights;
14761 if(!enif_get_int(env, argv[0], &size)) Badarg(6001,"size");
14762 if(!enif_is_list(env, argv[1])) Badarg(6001, "weights")
14763 else {
14764 ERL_NIF_TERM weights_l, weights_h, weights_t;
14765 std::vector <GLshort> weights_vec;
14766 GLshort weights_tmp;
14767 weights_l = argv[1];
14768 while(enif_get_list_cell(env, weights_l, &weights_h, &weights_t)) {
14769 if(!egl_get_short(env, weights_h, &weights_tmp)) Badarg(6001,"weights");
14770 weights_vec.push_back(weights_tmp);
14771 weights_l = weights_t;
14772 };
14773 weights = weights_vec.data();
14774 }
14775 weglWeightsvARB(size,weights);
14776 }
14777
ecb_glWeightivARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14778 void ecb_glWeightivARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14779 {
14780 GLint size;
14781 GLint *weights;
14782 if(!enif_get_int(env, argv[0], &size)) Badarg(6002,"size");
14783 if(!enif_is_list(env, argv[1])) Badarg(6002, "weights")
14784 else {
14785 ERL_NIF_TERM weights_l, weights_h, weights_t;
14786 std::vector <GLint> weights_vec;
14787 GLint weights_tmp;
14788 weights_l = argv[1];
14789 while(enif_get_list_cell(env, weights_l, &weights_h, &weights_t)) {
14790 if(!enif_get_int(env, weights_h, &weights_tmp)) Badarg(6002,"weights");
14791 weights_vec.push_back(weights_tmp);
14792 weights_l = weights_t;
14793 };
14794 weights = weights_vec.data();
14795 }
14796 weglWeightivARB(size,weights);
14797 }
14798
ecb_glWeightfvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14799 void ecb_glWeightfvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14800 {
14801 GLint size;
14802 GLfloat *weights;
14803 if(!enif_get_int(env, argv[0], &size)) Badarg(6003,"size");
14804 if(!enif_is_list(env, argv[1])) Badarg(6003, "weights")
14805 else {
14806 ERL_NIF_TERM weights_l, weights_h, weights_t;
14807 std::vector <GLfloat> weights_vec;
14808 GLfloat weights_tmp;
14809 weights_l = argv[1];
14810 while(enif_get_list_cell(env, weights_l, &weights_h, &weights_t)) {
14811 if(!egl_get_float(env, weights_h, &weights_tmp)) Badarg(6003,"weights");
14812 weights_vec.push_back(weights_tmp);
14813 weights_l = weights_t;
14814 };
14815 weights = weights_vec.data();
14816 }
14817 weglWeightfvARB(size,weights);
14818 }
14819
ecb_glWeightdvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14820 void ecb_glWeightdvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14821 {
14822 GLint size;
14823 GLdouble *weights;
14824 if(!enif_get_int(env, argv[0], &size)) Badarg(6004,"size");
14825 if(!enif_is_list(env, argv[1])) Badarg(6004, "weights")
14826 else {
14827 ERL_NIF_TERM weights_l, weights_h, weights_t;
14828 std::vector <GLdouble> weights_vec;
14829 GLdouble weights_tmp;
14830 weights_l = argv[1];
14831 while(enif_get_list_cell(env, weights_l, &weights_h, &weights_t)) {
14832 if(!enif_get_double(env, weights_h, &weights_tmp)) Badarg(6004,"weights");
14833 weights_vec.push_back(weights_tmp);
14834 weights_l = weights_t;
14835 };
14836 weights = weights_vec.data();
14837 }
14838 weglWeightdvARB(size,weights);
14839 }
14840
ecb_glWeightubvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14841 void ecb_glWeightubvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14842 {
14843 GLint size;
14844 GLubyte *weights;
14845 if(!enif_get_int(env, argv[0], &size)) Badarg(6005,"size");
14846 if(!enif_is_list(env, argv[1])) Badarg(6005, "weights")
14847 else {
14848 ERL_NIF_TERM weights_l, weights_h, weights_t;
14849 std::vector <GLubyte> weights_vec;
14850 GLubyte weights_tmp;
14851 weights_l = argv[1];
14852 while(enif_get_list_cell(env, weights_l, &weights_h, &weights_t)) {
14853 if(!egl_get_ubyte(env, weights_h, &weights_tmp)) Badarg(6005,"weights");
14854 weights_vec.push_back(weights_tmp);
14855 weights_l = weights_t;
14856 };
14857 weights = weights_vec.data();
14858 }
14859 weglWeightubvARB(size,weights);
14860 }
14861
ecb_glWeightusvARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14862 void ecb_glWeightusvARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14863 {
14864 GLint size;
14865 GLushort *weights;
14866 if(!enif_get_int(env, argv[0], &size)) Badarg(6006,"size");
14867 if(!enif_is_list(env, argv[1])) Badarg(6006, "weights")
14868 else {
14869 ERL_NIF_TERM weights_l, weights_h, weights_t;
14870 std::vector <GLushort> weights_vec;
14871 GLushort weights_tmp;
14872 weights_l = argv[1];
14873 while(enif_get_list_cell(env, weights_l, &weights_h, &weights_t)) {
14874 if(!egl_get_ushort(env, weights_h, &weights_tmp)) Badarg(6006,"weights");
14875 weights_vec.push_back(weights_tmp);
14876 weights_l = weights_t;
14877 };
14878 weights = weights_vec.data();
14879 }
14880 weglWeightusvARB(size,weights);
14881 }
14882
ecb_glWeightuivARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14883 void ecb_glWeightuivARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14884 {
14885 GLint size;
14886 GLuint *weights;
14887 if(!enif_get_int(env, argv[0], &size)) Badarg(6007,"size");
14888 if(!enif_is_list(env, argv[1])) Badarg(6007, "weights")
14889 else {
14890 ERL_NIF_TERM weights_l, weights_h, weights_t;
14891 std::vector <GLuint> weights_vec;
14892 GLuint weights_tmp;
14893 weights_l = argv[1];
14894 while(enif_get_list_cell(env, weights_l, &weights_h, &weights_t)) {
14895 if(!enif_get_uint(env, weights_h, &weights_tmp)) Badarg(6007,"weights");
14896 weights_vec.push_back(weights_tmp);
14897 weights_l = weights_t;
14898 };
14899 weights = weights_vec.data();
14900 }
14901 weglWeightuivARB(size,weights);
14902 }
14903
ecb_glVertexBlendARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14904 void ecb_glVertexBlendARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14905 {
14906 GLint count;
14907 if(!enif_get_int(env, argv[0], &count)) Badarg(6008,"count");
14908 weglVertexBlendARB(count);
14909 }
14910
ecb_glGetBufferParameterivARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14911 void ecb_glGetBufferParameterivARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14912 {
14913 ERL_NIF_TERM reply;
14914 GLenum target;
14915 GLenum pname;
14916 GLint params[16];
14917 ERL_NIF_TERM params_ts[16];
14918 if(!enif_get_uint(env, argv[0], &target)) Badarg(6009,"target");
14919 if(!enif_get_uint(env, argv[1], &pname)) Badarg(6009,"pname");
14920 weglGetBufferParameterivARB(target,pname,params);
14921 for(int ri=0; ri < (int) 16; ri++)
14922 params_ts[ri] = enif_make_int(env, params[ri]);
14923 reply = enif_make_list_from_array(env, params_ts, 16);
14924 enif_send(NULL, self, env,
14925 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14926 }
14927
ecb_glBindAttribLocationARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14928 void ecb_glBindAttribLocationARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14929 {
14930 egl_uint64_t programObj;
14931 GLuint index;
14932 ErlNifBinary name;
14933 if(!enif_get_uint64(env, argv[0], &programObj)) Badarg(6010,"programObj");
14934 if(!enif_get_uint(env, argv[1], &index)) Badarg(6010,"index");
14935 if(!enif_inspect_binary(env, argv[2], &name)) Badarg(6010,"name");
14936 weglBindAttribLocationARB((GLhandleARB) programObj,index,(GLchar *) name.data);
14937 }
14938
ecb_glGetActiveAttribARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14939 void ecb_glGetActiveAttribARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14940 {
14941 ERL_NIF_TERM reply;
14942 egl_uint64_t programObj;
14943 GLuint index;
14944 GLsizei maxLength;
14945 GLsizei length;
14946 GLint size;
14947 GLenum type;
14948 unsigned char *name;
14949 if(!enif_get_uint64(env, argv[0], &programObj)) Badarg(6011,"programObj");
14950 if(!enif_get_uint(env, argv[1], &index)) Badarg(6011,"index");
14951 if(!enif_get_int(env, argv[2], &maxLength)) Badarg(6011,"maxLength");
14952 name = (unsigned char *) enif_alloc((int) maxLength*sizeof(GLchar));
14953 weglGetActiveAttribARB((GLhandleARB) programObj,index,maxLength,&length,&size,&type,(GLchar *) name);
14954 reply = enif_make_tuple3(env,
14955 enif_make_int(env, size),
14956 enif_make_int(env, type),
14957 enif_make_string(env, (const char *) name, ERL_NIF_LATIN1) );
14958 enif_send(NULL, self, env,
14959 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14960 enif_free(name);
14961 }
14962
ecb_glGetAttribLocationARB(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14963 void ecb_glGetAttribLocationARB(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14964 {
14965 GLint result;
14966 ERL_NIF_TERM reply;
14967 egl_uint64_t programObj;
14968 ErlNifBinary name;
14969 if(!enif_get_uint64(env, argv[0], &programObj)) Badarg(6012,"programObj");
14970 if(!enif_inspect_binary(env, argv[1], &name)) Badarg(6012,"name");
14971 result = weglGetAttribLocationARB((GLhandleARB) programObj,(GLchar *) name.data);
14972 reply = enif_make_int(env, result);
14973 enif_send(NULL, self, env,
14974 enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
14975 }
14976
ecb_glBlendBarrierKHR(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14977 void ecb_glBlendBarrierKHR(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14978 {
14979 weglBlendBarrierKHR();
14980 }
14981
ecb_glMaxShaderCompilerThreadsKHR(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14982 void ecb_glMaxShaderCompilerThreadsKHR(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14983 {
14984 GLuint count;
14985 if(!enif_get_uint(env, argv[0], &count)) Badarg(6014,"count");
14986 weglMaxShaderCompilerThreadsKHR(count);
14987 }
14988
ecb_glDepthBoundsEXT(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])14989 void ecb_glDepthBoundsEXT(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
14990 {
14991 GLclampd zmin;
14992 GLclampd zmax;
14993 if(!enif_get_double(env, argv[0], &zmin)) Badarg(6015,"zmin");
14994 if(!enif_get_double(env, argv[1], &zmax)) Badarg(6015,"zmax");
14995 weglDepthBoundsEXT(zmin,zmax);
14996 }
14997
14998
14999
15000 #include "gl_finit.h"
15001
15002