← Back to branch summary

~ubuntu-branches/ubuntu/trusty/erlang/trusty

« back to all changes in this revision

Viewing changes to lib/wx/c_src/gen/gl_funcs.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Clint Byrum
  • Date: 2011-05-05 15:48:43 UTC
  • mfrom: (3.5.13 sid)
  • Revision ID: james.westby@ubuntu.com-20110505154843-0om6ekzg6m7ugj27
Tags: 1:14.b.2-dfsg-3ubuntu1
* Merge from debian unstable.  Remaining changes:
  - Drop libwxgtk2.8-dev build dependency. Wx isn't in main, and not
    supposed to.
  - Drop erlang-wx binary.
  - Drop erlang-wx dependency from -megaco, -common-test, and -reltool, they
    do not really need wx. Also drop it from -debugger; the GUI needs wx,
    but it apparently has CLI bits as well, and is also needed by -megaco,
    so let's keep the package for now.
  - debian/patches/series: Do what I meant, and enable build-options.patch
    instead.
* Additional changes:
  - Drop erlang-wx from -et
* Dropped Changes:
  - patches/pcre-crash.patch: CVE-2008-2371: outer level option with
    alternatives caused crash. (Applied Upstream)
  - fix for ssl certificate verification in newSSL: 
    ssl_cacertfile_fix.patch (Applied Upstream)
  - debian/patches/series: Enable native.patch again, to get stripped beam
    files and reduce the package size again. (build-options is what
    actually accomplished this)
  - Remove build-options.patch on advice from upstream and because it caused
    odd build failures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/wx/c_src/gen/gl_funcs.cpp
1
1
/*
2
2
 * %CopyrightBegin%
3
 
 * 
4
 
 * Copyright Ericsson AB 2008-2009. All Rights Reserved.
5
 
 * 
 
3
 *
 
4
 * Copyright Ericsson AB 2008-2010. All Rights Reserved.
 
5
 *
6
6
 * The contents of this file are subject to the Erlang Public License,
7
7
 * Version 1.1, (the "License"); you may not use this file except in
8
8
 * compliance with the License. You should have received a copy of the
9
9
 * Erlang Public License along with this software. If not, it can be
10
10
 * retrieved online at http://www.erlang.org/.
11
 
 * 
 
11
 *
12
12
 * Software distributed under the License is distributed on an "AS IS"
13
13
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
14
14
 * the License for the specific language governing rights and limitations
15
15
 * under the License.
16
 
 * 
 
16
 *
17
17
 * %CopyrightEnd% 
18
18
*/
19
 
/***** This file is generated do not edit ****/ 
 
19
/***** This file is generated do not edit ****/
20
20
 
21
21
#include <stdio.h>
22
22
#include <string.h>
23
 
#include "../wxe_impl.h"
24
 
#include "../wxe_gl.h"
 
23
#include "../egl_impl.h"
25
24
#include "gl_fdefs.h"
26
25
 
27
 
int gl_error_op;
28
 
void gl_dispatch(int op, char *bp,ErlDrvTermData caller,WXEBinRef *bins[]){
29
 
 gl_error_op = op;
30
 
 if(caller != gl_active) {
31
 
   wxGLCanvas * current = glc[caller];
32
 
   if(current) { gl_active = caller; current->SetCurrent();}
33
 
   else {
34
 
       ErlDrvTermData rt[] = // Error msg
35
 
      {ERL_DRV_ATOM, driver_mk_atom((char *) "_wxe_error_"),
36
 
       ERL_DRV_INT,  op,
37
 
       ERL_DRV_ATOM, driver_mk_atom((char *) "no_gl_context"),
38
 
       ERL_DRV_TUPLE,3};
39
 
      driver_send_term(WXE_DRV_PORT,caller,rt,8);
40
 
      return ;
41
 
   }
42
 
 };
 
26
extern gl_fns_t gl_fns[];
43
27
 
44
 
 switch(op) 
 
28
void egl_dispatch(int op, char *bp, ErlDrvPort port, ErlDrvTermData caller, char *bins[], int bins_sz[]){
 
29
 try {
 
30
 switch(op)
45
31
{
46
 
 case 5000: 
47
 
   wxe_tess_impl(bp, caller); 
48
 
   break;
49
 
 case WXE_BIN_INCR:
50
 
   driver_binary_inc_refc(bins[0]->bin);
51
 
   break;
52
 
 case WXE_BIN_DECR:
53
 
   driver_binary_dec_refc(bins[0]->bin);
54
 
   break;
55
 
case 5010: { // gluBuild1DMipmapLevels 
 
32
 case 5000:
 
33
   erl_tess_impl(bp, port, caller);
 
34
   break;
 
35
case 5010: { // gluBuild1DMipmapLevels
56
36
 GLenum *target = (GLenum *) bp; bp += 4;
57
37
 GLint *internalFormat = (GLint *) bp; bp += 4;
58
38
 GLsizei *width = (GLsizei *) bp; bp += 4;
61
41
 GLint *level = (GLint *) bp; bp += 4;
62
42
 GLint *base = (GLint *) bp; bp += 4;
63
43
 GLint *max = (GLint *) bp; bp += 4;
64
 
 void *data = (void *) bins[0]->base;
 
44
 void *data = (void *) bins[0];
65
45
 GLint result = wegluBuild1DMipmapLevels(*target,*internalFormat,*width,*format,*type,*level,*base,*max,data);
66
46
 int AP = 0; ErlDrvTermData rt[6];
67
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
47
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
68
48
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
69
49
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
70
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
71
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
72
 
}; break; 
73
 
case 5011: { // gluBuild1DMipmaps 
 
50
 driver_send_term(port,caller,rt,AP);
 
51
}; break;
 
52
case 5011: { // gluBuild1DMipmaps
74
53
 GLenum *target = (GLenum *) bp; bp += 4;
75
54
 GLint *internalFormat = (GLint *) bp; bp += 4;
76
55
 GLsizei *width = (GLsizei *) bp; bp += 4;
77
56
 GLenum *format = (GLenum *) bp; bp += 4;
78
57
 GLenum *type = (GLenum *) bp; bp += 4;
79
 
 void *data = (void *) bins[0]->base;
 
58
 void *data = (void *) bins[0];
80
59
 GLint result = wegluBuild1DMipmaps(*target,*internalFormat,*width,*format,*type,data);
81
60
 int AP = 0; ErlDrvTermData rt[6];
82
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
61
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
83
62
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
84
63
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
85
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
86
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
87
 
}; break; 
88
 
case 5012: { // gluBuild2DMipmapLevels 
 
64
 driver_send_term(port,caller,rt,AP);
 
65
}; break;
 
66
case 5012: { // gluBuild2DMipmapLevels
89
67
 GLenum *target = (GLenum *) bp; bp += 4;
90
68
 GLint *internalFormat = (GLint *) bp; bp += 4;
91
69
 GLsizei *width = (GLsizei *) bp; bp += 4;
95
73
 GLint *level = (GLint *) bp; bp += 4;
96
74
 GLint *base = (GLint *) bp; bp += 4;
97
75
 GLint *max = (GLint *) bp; bp += 4;
98
 
 void *data = (void *) bins[0]->base;
 
76
 void *data = (void *) bins[0];
99
77
 GLint result = wegluBuild2DMipmapLevels(*target,*internalFormat,*width,*height,*format,*type,*level,*base,*max,data);
100
78
 int AP = 0; ErlDrvTermData rt[6];
101
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
79
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
102
80
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
103
81
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
104
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
105
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
106
 
}; break; 
107
 
case 5013: { // gluBuild2DMipmaps 
 
82
 driver_send_term(port,caller,rt,AP);
 
83
}; break;
 
84
case 5013: { // gluBuild2DMipmaps
108
85
 GLenum *target = (GLenum *) bp; bp += 4;
109
86
 GLint *internalFormat = (GLint *) bp; bp += 4;
110
87
 GLsizei *width = (GLsizei *) bp; bp += 4;
111
88
 GLsizei *height = (GLsizei *) bp; bp += 4;
112
89
 GLenum *format = (GLenum *) bp; bp += 4;
113
90
 GLenum *type = (GLenum *) bp; bp += 4;
114
 
 void *data = (void *) bins[0]->base;
 
91
 void *data = (void *) bins[0];
115
92
 GLint result = wegluBuild2DMipmaps(*target,*internalFormat,*width,*height,*format,*type,data);
116
93
 int AP = 0; ErlDrvTermData rt[6];
117
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
94
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
118
95
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
119
96
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
120
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
121
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
122
 
}; break; 
123
 
case 5014: { // gluBuild3DMipmapLevels 
 
97
 driver_send_term(port,caller,rt,AP);
 
98
}; break;
 
99
case 5014: { // gluBuild3DMipmapLevels
124
100
 GLenum *target = (GLenum *) bp; bp += 4;
125
101
 GLint *internalFormat = (GLint *) bp; bp += 4;
126
102
 GLsizei *width = (GLsizei *) bp; bp += 4;
131
107
 GLint *level = (GLint *) bp; bp += 4;
132
108
 GLint *base = (GLint *) bp; bp += 4;
133
109
 GLint *max = (GLint *) bp; bp += 4;
134
 
 void *data = (void *) bins[0]->base;
 
110
 void *data = (void *) bins[0];
135
111
 GLint result = wegluBuild3DMipmapLevels(*target,*internalFormat,*width,*height,*depth,*format,*type,*level,*base,*max,data);
136
112
 int AP = 0; ErlDrvTermData rt[6];
137
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
113
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
138
114
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
139
115
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
140
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
141
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
142
 
}; break; 
143
 
case 5015: { // gluBuild3DMipmaps 
 
116
 driver_send_term(port,caller,rt,AP);
 
117
}; break;
 
118
case 5015: { // gluBuild3DMipmaps
144
119
 GLenum *target = (GLenum *) bp; bp += 4;
145
120
 GLint *internalFormat = (GLint *) bp; bp += 4;
146
121
 GLsizei *width = (GLsizei *) bp; bp += 4;
148
123
 GLsizei *depth = (GLsizei *) bp; bp += 4;
149
124
 GLenum *format = (GLenum *) bp; bp += 4;
150
125
 GLenum *type = (GLenum *) bp; bp += 4;
151
 
 void *data = (void *) bins[0]->base;
 
126
 void *data = (void *) bins[0];
152
127
 GLint result = wegluBuild3DMipmaps(*target,*internalFormat,*width,*height,*depth,*format,*type,data);
153
128
 int AP = 0; ErlDrvTermData rt[6];
154
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
129
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
155
130
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
156
131
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
157
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
158
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
159
 
}; break; 
160
 
case 5016: { // gluCheckExtension 
161
 
 int * extNameLen = (int *) bp; bp += 4;
162
 
 GLubyte * extName = (GLubyte *) bp;  bp += (8-((*extNameLen*1+4)%8))%8;
163
 
 int * extStringLen = (int *) bp; bp += 4;
164
 
 GLubyte * extString = (GLubyte *) bp;  bp += (8-((*extStringLen*1+4)%8))%8;
 
132
 driver_send_term(port,caller,rt,AP);
 
133
}; break;
 
134
case 5016: { // gluCheckExtension
 
135
 GLubyte *extName = (GLubyte *) bp;
 
136
 int extNameLen[1] = {strlen((char *)extName)}; bp += extNameLen[0]+1+((8-((1+extNameLen[0]+0)%8))%8);
 
137
 GLubyte *extString = (GLubyte *) bp;
 
138
 int extStringLen[1] = {strlen((char *)extString)}; bp += extStringLen[0]+1+((8-((1+extStringLen[0]+0)%8))%8);
165
139
 GLboolean result = wegluCheckExtension(extName,extString);
166
140
 int AP = 0; ErlDrvTermData rt[6];
167
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
141
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
168
142
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
169
143
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
170
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
171
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
172
 
}; break; 
173
 
case 5017: { // gluCylinder 
 
144
 driver_send_term(port,caller,rt,AP);
 
145
}; break;
 
146
case 5017: { // gluCylinder
174
147
 GLUquadric * quad = (GLUquadric *) * (GLuint64EXT *) bp; bp += 8;
175
148
 GLdouble *base = (GLdouble *) bp; bp += 8;
176
149
 GLdouble *top = (GLdouble *) bp; bp += 8;
178
151
 GLint *slices = (GLint *) bp; bp += 4;
179
152
 GLint *stacks = (GLint *) bp; bp += 4;
180
153
 wegluCylinder(quad,*base,*top,*height,*slices,*stacks);
181
 
}; break; 
182
 
case 5018: { // gluDeleteQuadric 
 
154
}; break;
 
155
case 5018: { // gluDeleteQuadric
183
156
 GLUquadric * quad = (GLUquadric *) * (GLuint64EXT *) bp; bp += 8;
184
157
 wegluDeleteQuadric(quad);
185
 
}; break; 
186
 
case 5019: { // gluDisk 
 
158
}; break;
 
159
case 5019: { // gluDisk
187
160
 GLUquadric * quad = (GLUquadric *) * (GLuint64EXT *) bp; bp += 8;
188
161
 GLdouble *inner = (GLdouble *) bp; bp += 8;
189
162
 GLdouble *outer = (GLdouble *) bp; bp += 8;
190
163
 GLint *slices = (GLint *) bp; bp += 4;
191
164
 GLint *loops = (GLint *) bp; bp += 4;
192
165
 wegluDisk(quad,*inner,*outer,*slices,*loops);
193
 
}; break; 
194
 
case 5020: { // gluErrorString 
 
166
}; break;
 
167
case 5020: { // gluErrorString
195
168
 GLenum *error = (GLenum *) bp; bp += 4;
196
169
 const GLubyte *  result = wegluErrorString(*error);
197
170
 int AP = 0; ErlDrvTermData rt[7];
198
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
171
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
199
172
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) result; rt[AP++] = strlen((char *) result);
200
173
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
201
 
 if (AP != 7 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7);
202
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
203
 
}; break; 
204
 
case 5021: { // gluGetString 
 
174
 driver_send_term(port,caller,rt,AP);
 
175
}; break;
 
176
case 5021: { // gluGetString
205
177
 GLenum *name = (GLenum *) bp; bp += 4;
206
178
 const GLubyte *  result = wegluGetString(*name);
207
179
 int AP = 0; ErlDrvTermData rt[7];
208
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
180
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
209
181
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) result; rt[AP++] = strlen((char *) result);
210
182
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
211
 
 if (AP != 7 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7);
212
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
213
 
}; break; 
214
 
case 5022: { // gluLookAt 
 
183
 driver_send_term(port,caller,rt,AP);
 
184
}; break;
 
185
case 5022: { // gluLookAt
215
186
 GLdouble *eyeX = (GLdouble *) bp; bp += 8;
216
187
 GLdouble *eyeY = (GLdouble *) bp; bp += 8;
217
188
 GLdouble *eyeZ = (GLdouble *) bp; bp += 8;
222
193
 GLdouble *upY = (GLdouble *) bp; bp += 8;
223
194
 GLdouble *upZ = (GLdouble *) bp; bp += 8;
224
195
 wegluLookAt(*eyeX,*eyeY,*eyeZ,*centerX,*centerY,*centerZ,*upX,*upY,*upZ);
225
 
}; break; 
226
 
case 5023: { // gluNewQuadric 
 
196
}; break;
 
197
case 5023: { // gluNewQuadric
227
198
 GLUquadric *  result = wegluNewQuadric();
228
199
 int AP = 0; ErlDrvTermData rt[6];
229
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
200
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
230
201
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
231
202
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
232
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
233
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
234
 
}; break; 
235
 
case 5024: { // gluOrtho2D 
 
203
 driver_send_term(port,caller,rt,AP);
 
204
}; break;
 
205
case 5024: { // gluOrtho2D
236
206
 GLdouble *left = (GLdouble *) bp; bp += 8;
237
207
 GLdouble *right = (GLdouble *) bp; bp += 8;
238
208
 GLdouble *bottom = (GLdouble *) bp; bp += 8;
239
209
 GLdouble *top = (GLdouble *) bp; bp += 8;
240
210
 wegluOrtho2D(*left,*right,*bottom,*top);
241
 
}; break; 
242
 
case 5025: { // gluPartialDisk 
 
211
}; break;
 
212
case 5025: { // gluPartialDisk
243
213
 GLUquadric * quad = (GLUquadric *) * (GLuint64EXT *) bp; bp += 8;
244
214
 GLdouble *inner = (GLdouble *) bp; bp += 8;
245
215
 GLdouble *outer = (GLdouble *) bp; bp += 8;
248
218
 GLdouble *start = (GLdouble *) bp; bp += 8;
249
219
 GLdouble *sweep = (GLdouble *) bp; bp += 8;
250
220
 wegluPartialDisk(quad,*inner,*outer,*slices,*loops,*start,*sweep);
251
 
}; break; 
252
 
case 5026: { // gluPerspective 
 
221
}; break;
 
222
case 5026: { // gluPerspective
253
223
 GLdouble *fovy = (GLdouble *) bp; bp += 8;
254
224
 GLdouble *aspect = (GLdouble *) bp; bp += 8;
255
225
 GLdouble *zNear = (GLdouble *) bp; bp += 8;
256
226
 GLdouble *zFar = (GLdouble *) bp; bp += 8;
257
227
 wegluPerspective(*fovy,*aspect,*zNear,*zFar);
258
 
}; break; 
259
 
case 5027: { // gluPickMatrix 
 
228
}; break;
 
229
case 5027: { // gluPickMatrix
260
230
 GLdouble *x = (GLdouble *) bp; bp += 8;
261
231
 GLdouble *y = (GLdouble *) bp; bp += 8;
262
232
 GLdouble *delX = (GLdouble *) bp; bp += 8;
263
233
 GLdouble *delY = (GLdouble *) bp; bp += 8;
264
234
 GLint * viewport = (GLint *) bp; bp += 16;
265
235
 wegluPickMatrix(*x,*y,*delX,*delY,viewport);
266
 
}; break; 
267
 
case 5028: { // gluProject 
 
236
}; break;
 
237
case 5028: { // gluProject
268
238
 GLdouble *objX = (GLdouble *) bp; bp += 8;
269
239
 GLdouble *objY = (GLdouble *) bp; bp += 8;
270
240
 GLdouble *objZ = (GLdouble *) bp; bp += 8;
276
246
 GLdouble winZ[1] = {0.0};
277
247
 GLint result = wegluProject(*objX,*objY,*objZ,model,proj,view,winX,winY,winZ);
278
248
 int AP = 0; ErlDrvTermData rt[14];
279
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
249
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
280
250
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
281
251
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) winX;
282
252
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) winY;
283
253
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) winZ;
284
254
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
285
255
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
286
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
287
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
288
 
}; break; 
289
 
case 5029: { // gluQuadricDrawStyle 
 
256
 driver_send_term(port,caller,rt,AP);
 
257
}; break;
 
258
case 5029: { // gluQuadricDrawStyle
290
259
 GLUquadric * quad = (GLUquadric *) * (GLuint64EXT *) bp; bp += 8;
291
260
 GLenum *draw = (GLenum *) bp; bp += 4;
292
261
 wegluQuadricDrawStyle(quad,*draw);
293
 
}; break; 
294
 
case 5030: { // gluQuadricNormals 
 
262
}; break;
 
263
case 5030: { // gluQuadricNormals
295
264
 GLUquadric * quad = (GLUquadric *) * (GLuint64EXT *) bp; bp += 8;
296
265
 GLenum *normal = (GLenum *) bp; bp += 4;
297
266
 wegluQuadricNormals(quad,*normal);
298
 
}; break; 
299
 
case 5031: { // gluQuadricOrientation 
 
267
}; break;
 
268
case 5031: { // gluQuadricOrientation
300
269
 GLUquadric * quad = (GLUquadric *) * (GLuint64EXT *) bp; bp += 8;
301
270
 GLenum *orientation = (GLenum *) bp; bp += 4;
302
271
 wegluQuadricOrientation(quad,*orientation);
303
 
}; break; 
304
 
case 5032: { // gluQuadricTexture 
 
272
}; break;
 
273
case 5032: { // gluQuadricTexture
305
274
 GLUquadric * quad = (GLUquadric *) * (GLuint64EXT *) bp; bp += 8;
306
275
 GLboolean *texture = (GLboolean *) bp; bp += 1;
307
276
 wegluQuadricTexture(quad,*texture);
308
 
}; break; 
309
 
case 5033: { // gluScaleImage 
 
277
}; break;
 
278
case 5033: { // gluScaleImage
310
279
 GLenum *format = (GLenum *) bp; bp += 4;
311
280
 GLsizei *wIn = (GLsizei *) bp; bp += 4;
312
281
 GLsizei *hIn = (GLsizei *) bp; bp += 4;
313
282
 GLenum *typeIn = (GLenum *) bp; bp += 4;
314
 
 void *dataIn = (void *) bins[0]->base;
 
283
 void *dataIn = (void *) bins[0];
315
284
 GLsizei *wOut = (GLsizei *) bp; bp += 4;
316
285
 GLsizei *hOut = (GLsizei *) bp; bp += 4;
317
286
 GLenum *typeOut = (GLenum *) bp; bp += 4;
318
 
 GLvoid *dataOut = (GLvoid *) bins[1]->base;
 
287
 GLvoid *dataOut = (GLvoid *) bins[1];
319
288
 GLint result = wegluScaleImage(*format,*wIn,*hIn,*typeIn,dataIn,*wOut,*hOut,*typeOut,dataOut);
320
289
 int AP = 0; ErlDrvTermData rt[6];
321
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
290
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
322
291
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
323
292
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
324
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
325
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
326
 
}; break; 
327
 
case 5034: { // gluSphere 
 
293
 driver_send_term(port,caller,rt,AP);
 
294
}; break;
 
295
case 5034: { // gluSphere
328
296
 GLUquadric * quad = (GLUquadric *) * (GLuint64EXT *) bp; bp += 8;
329
297
 GLdouble *radius = (GLdouble *) bp; bp += 8;
330
298
 GLint *slices = (GLint *) bp; bp += 4;
331
299
 GLint *stacks = (GLint *) bp; bp += 4;
332
300
 wegluSphere(quad,*radius,*slices,*stacks);
333
 
}; break; 
334
 
case 5035: { // gluUnProject 
 
301
}; break;
 
302
case 5035: { // gluUnProject
335
303
 GLdouble *winX = (GLdouble *) bp; bp += 8;
336
304
 GLdouble *winY = (GLdouble *) bp; bp += 8;
337
305
 GLdouble *winZ = (GLdouble *) bp; bp += 8;
343
311
 GLdouble objZ[1] = {0.0};
344
312
 GLint result = wegluUnProject(*winX,*winY,*winZ,model,proj,view,objX,objY,objZ);
345
313
 int AP = 0; ErlDrvTermData rt[14];
346
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
314
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
347
315
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
348
316
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) objX;
349
317
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) objY;
350
318
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) objZ;
351
319
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
352
320
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
353
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
354
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
355
 
}; break; 
356
 
case 5036: { // gluUnProject4 
 
321
 driver_send_term(port,caller,rt,AP);
 
322
}; break;
 
323
case 5036: { // gluUnProject4
357
324
 GLdouble *winX = (GLdouble *) bp; bp += 8;
358
325
 GLdouble *winY = (GLdouble *) bp; bp += 8;
359
326
 GLdouble *winZ = (GLdouble *) bp; bp += 8;
369
336
 GLdouble objW[1] = {0.0};
370
337
 GLint result = wegluUnProject4(*winX,*winY,*winZ,*clipW,model,proj,view,*nearVal,*farVal,objX,objY,objZ,objW);
371
338
 int AP = 0; ErlDrvTermData rt[16];
372
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
339
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
373
340
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
374
341
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) objX;
375
342
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) objY;
377
344
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) objW;
378
345
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 5;
379
346
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
380
 
 if (AP != 16 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,16);
381
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
382
 
}; break; 
383
 
case 5037: { // glAccum 
 
347
 driver_send_term(port,caller,rt,AP);
 
348
}; break;
 
349
case 5037: { // glAccum
384
350
 GLenum *op = (GLenum *) bp; bp += 4;
385
351
 GLfloat *value = (GLfloat *) bp; bp += 4;
386
352
 weglAccum(*op,*value);
387
 
}; break; 
388
 
case 5038: { // glAlphaFunc 
 
353
}; break;
 
354
case 5038: { // glAlphaFunc
389
355
 GLenum *func = (GLenum *) bp; bp += 4;
390
356
 GLclampf *ref = (GLclampf *) bp; bp += 4;
391
357
 weglAlphaFunc(*func,*ref);
392
 
}; break; 
393
 
case 5039: { // glAreTexturesResident 
 
358
}; break;
 
359
case 5039: { // glAreTexturesResident
394
360
 int * texturesLen = (int *) bp; bp += 4;
395
361
 GLuint * textures = (GLuint *) bp;  bp += (8-((*texturesLen*4+4)%8))%8;
396
362
 GLboolean *residences;
398
364
 GLboolean result = weglAreTexturesResident(*texturesLen,textures,residences);
399
365
 int AP = 0; ErlDrvTermData *rt;
400
366
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(11 + (*texturesLen)*2));
401
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
367
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
402
368
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
403
369
 for(int i=0; i < *texturesLen; i++) {
404
370
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) residences[i];}
405
371
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*texturesLen)+1;
406
372
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
407
373
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
408
 
 if (AP != 11 + (*texturesLen)*2 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,11 + (*texturesLen)*2);
409
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
410
 
 driver_free(rt); 
 
374
 driver_send_term(port,caller,rt,AP);
 
375
 driver_free(rt);
411
376
 driver_free(residences);
412
 
}; break; 
413
 
case 5040: { // glArrayElement 
 
377
}; break;
 
378
case 5040: { // glArrayElement
414
379
 GLint *i = (GLint *) bp; bp += 4;
415
380
 weglArrayElement(*i);
416
 
}; break; 
417
 
case 5041: { // glBegin 
 
381
}; break;
 
382
case 5041: { // glBegin
418
383
 GLenum *mode = (GLenum *) bp; bp += 4;
419
384
 weglBegin(*mode);
420
 
}; break; 
421
 
case 5042: { // glBindTexture 
 
385
}; break;
 
386
case 5042: { // glBindTexture
422
387
 GLenum *target = (GLenum *) bp; bp += 4;
423
388
 GLuint *texture = (GLuint *) bp; bp += 4;
424
389
 weglBindTexture(*target,*texture);
425
 
}; break; 
426
 
case 5043: { // glBitmap 
 
390
}; break;
 
391
case 5043: { // glBitmap
427
392
 GLsizei *width = (GLsizei *) bp; bp += 4;
428
393
 GLsizei *height = (GLsizei *) bp; bp += 4;
429
394
 GLfloat *xorig = (GLfloat *) bp; bp += 4;
432
397
 GLfloat *ymove = (GLfloat *) bp; bp += 4;
433
398
 GLubyte *bitmap = (GLubyte *) * (int *) bp; bp += 4;
434
399
 weglBitmap(*width,*height,*xorig,*yorig,*xmove,*ymove,bitmap);
435
 
}; break; 
436
 
case 5044: { // glBitmap 
 
400
}; break;
 
401
case 5044: { // glBitmap
437
402
 GLsizei *width = (GLsizei *) bp; bp += 4;
438
403
 GLsizei *height = (GLsizei *) bp; bp += 4;
439
404
 GLfloat *xorig = (GLfloat *) bp; bp += 4;
440
405
 GLfloat *yorig = (GLfloat *) bp; bp += 4;
441
406
 GLfloat *xmove = (GLfloat *) bp; bp += 4;
442
407
 GLfloat *ymove = (GLfloat *) bp; bp += 4;
443
 
 GLubyte *bitmap = (GLubyte *) bins[0]->base;
 
408
 GLubyte *bitmap = (GLubyte *) bins[0];
444
409
 weglBitmap(*width,*height,*xorig,*yorig,*xmove,*ymove,bitmap);
445
 
}; break; 
446
 
case 5045: { // glBlendFunc 
 
410
}; break;
 
411
case 5045: { // glBlendFunc
447
412
 GLenum *sfactor = (GLenum *) bp; bp += 4;
448
413
 GLenum *dfactor = (GLenum *) bp; bp += 4;
449
414
 weglBlendFunc(*sfactor,*dfactor);
450
 
}; break; 
451
 
case 5046: { // glCallList 
 
415
}; break;
 
416
case 5046: { // glCallList
452
417
 GLuint *list = (GLuint *) bp; bp += 4;
453
418
 weglCallList(*list);
454
 
}; break; 
455
 
case 5047: { // glCallLists 
 
419
}; break;
 
420
case 5047: { // glCallLists
456
421
 int * listsLen = (int *) bp; bp += 4;
457
422
 GLuint * lists = (GLuint *) bp;  bp += (8-((*listsLen*4+4)%8))%8;
458
423
 weglCallLists(*listsLen,GL_UNSIGNED_INT,lists);
459
 
}; break; 
460
 
case 5048: { // glClear 
 
424
}; break;
 
425
case 5048: { // glClear
461
426
 GLbitfield *mask = (GLbitfield *) bp; bp += 4;
462
427
 weglClear(*mask);
463
 
}; break; 
464
 
case 5049: { // glClearAccum 
 
428
}; break;
 
429
case 5049: { // glClearAccum
465
430
 GLfloat *red = (GLfloat *) bp; bp += 4;
466
431
 GLfloat *green = (GLfloat *) bp; bp += 4;
467
432
 GLfloat *blue = (GLfloat *) bp; bp += 4;
468
433
 GLfloat *alpha = (GLfloat *) bp; bp += 4;
469
434
 weglClearAccum(*red,*green,*blue,*alpha);
470
 
}; break; 
471
 
case 5050: { // glClearColor 
 
435
}; break;
 
436
case 5050: { // glClearColor
472
437
 GLclampf *red = (GLclampf *) bp; bp += 4;
473
438
 GLclampf *green = (GLclampf *) bp; bp += 4;
474
439
 GLclampf *blue = (GLclampf *) bp; bp += 4;
475
440
 GLclampf *alpha = (GLclampf *) bp; bp += 4;
476
441
 weglClearColor(*red,*green,*blue,*alpha);
477
 
}; break; 
478
 
case 5051: { // glClearDepth 
 
442
}; break;
 
443
case 5051: { // glClearDepth
479
444
 GLclampd *depth = (GLclampd *) bp; bp += 8;
480
445
 weglClearDepth(*depth);
481
 
}; break; 
482
 
case 5052: { // glClearIndex 
 
446
}; break;
 
447
case 5052: { // glClearIndex
483
448
 GLfloat *c = (GLfloat *) bp; bp += 4;
484
449
 weglClearIndex(*c);
485
 
}; break; 
486
 
case 5053: { // glClearStencil 
 
450
}; break;
 
451
case 5053: { // glClearStencil
487
452
 GLint *s = (GLint *) bp; bp += 4;
488
453
 weglClearStencil(*s);
489
 
}; break; 
490
 
case 5054: { // glClipPlane 
 
454
}; break;
 
455
case 5054: { // glClipPlane
491
456
 GLenum *plane = (GLenum *) bp; bp += 4;
492
457
 bp += 4;
493
458
 GLdouble * equation = (GLdouble *) bp; bp += 32;
494
459
 weglClipPlane(*plane,equation);
495
 
}; break; 
496
 
case 5055: { // glColor3bv 
 
460
}; break;
 
461
case 5055: { // glColor3bv
497
462
 GLbyte *v = (GLbyte *) bp; bp += 1;
498
463
 weglColor3bv(v);
499
 
}; break; 
500
 
case 5056: { // glColor3dv 
 
464
}; break;
 
465
case 5056: { // glColor3dv
501
466
 GLdouble *v = (GLdouble *) bp; bp += 8;
502
467
 weglColor3dv(v);
503
 
}; break; 
504
 
case 5057: { // glColor3fv 
 
468
}; break;
 
469
case 5057: { // glColor3fv
505
470
 GLfloat *v = (GLfloat *) bp; bp += 4;
506
471
 weglColor3fv(v);
507
 
}; break; 
508
 
case 5058: { // glColor3iv 
 
472
}; break;
 
473
case 5058: { // glColor3iv
509
474
 GLint *v = (GLint *) bp; bp += 4;
510
475
 weglColor3iv(v);
511
 
}; break; 
512
 
case 5059: { // glColor3sv 
 
476
}; break;
 
477
case 5059: { // glColor3sv
513
478
 GLshort *v = (GLshort *) bp; bp += 2;
514
479
 weglColor3sv(v);
515
 
}; break; 
516
 
case 5060: { // glColor3ubv 
 
480
}; break;
 
481
case 5060: { // glColor3ubv
517
482
 GLubyte *v = (GLubyte *) bp; bp += 1;
518
483
 weglColor3ubv(v);
519
 
}; break; 
520
 
case 5061: { // glColor3uiv 
 
484
}; break;
 
485
case 5061: { // glColor3uiv
521
486
 GLuint *v = (GLuint *) bp; bp += 4;
522
487
 weglColor3uiv(v);
523
 
}; break; 
524
 
case 5062: { // glColor3usv 
 
488
}; break;
 
489
case 5062: { // glColor3usv
525
490
 GLushort *v = (GLushort *) bp; bp += 2;
526
491
 weglColor3usv(v);
527
 
}; break; 
528
 
case 5063: { // glColor4bv 
 
492
}; break;
 
493
case 5063: { // glColor4bv
529
494
 GLbyte *v = (GLbyte *) bp; bp += 1;
530
495
 weglColor4bv(v);
531
 
}; break; 
532
 
case 5064: { // glColor4dv 
 
496
}; break;
 
497
case 5064: { // glColor4dv
533
498
 GLdouble *v = (GLdouble *) bp; bp += 8;
534
499
 weglColor4dv(v);
535
 
}; break; 
536
 
case 5065: { // glColor4fv 
 
500
}; break;
 
501
case 5065: { // glColor4fv
537
502
 GLfloat *v = (GLfloat *) bp; bp += 4;
538
503
 weglColor4fv(v);
539
 
}; break; 
540
 
case 5066: { // glColor4iv 
 
504
}; break;
 
505
case 5066: { // glColor4iv
541
506
 GLint *v = (GLint *) bp; bp += 4;
542
507
 weglColor4iv(v);
543
 
}; break; 
544
 
case 5067: { // glColor4sv 
 
508
}; break;
 
509
case 5067: { // glColor4sv
545
510
 GLshort *v = (GLshort *) bp; bp += 2;
546
511
 weglColor4sv(v);
547
 
}; break; 
548
 
case 5068: { // glColor4ubv 
 
512
}; break;
 
513
case 5068: { // glColor4ubv
549
514
 GLubyte *v = (GLubyte *) bp; bp += 1;
550
515
 weglColor4ubv(v);
551
 
}; break; 
552
 
case 5069: { // glColor4uiv 
 
516
}; break;
 
517
case 5069: { // glColor4uiv
553
518
 GLuint *v = (GLuint *) bp; bp += 4;
554
519
 weglColor4uiv(v);
555
 
}; break; 
556
 
case 5070: { // glColor4usv 
 
520
}; break;
 
521
case 5070: { // glColor4usv
557
522
 GLushort *v = (GLushort *) bp; bp += 2;
558
523
 weglColor4usv(v);
559
 
}; break; 
560
 
case 5071: { // glColorMask 
 
524
}; break;
 
525
case 5071: { // glColorMask
561
526
 GLboolean *red = (GLboolean *) bp; bp += 1;
562
527
 GLboolean *green = (GLboolean *) bp; bp += 1;
563
528
 GLboolean *blue = (GLboolean *) bp; bp += 1;
564
529
 GLboolean *alpha = (GLboolean *) bp; bp += 1;
565
530
 weglColorMask(*red,*green,*blue,*alpha);
566
 
}; break; 
567
 
case 5072: { // glColorMaterial 
 
531
}; break;
 
532
case 5072: { // glColorMaterial
568
533
 GLenum *face = (GLenum *) bp; bp += 4;
569
534
 GLenum *mode = (GLenum *) bp; bp += 4;
570
535
 weglColorMaterial(*face,*mode);
571
 
}; break; 
572
 
case 5073: { // glColorPointer 
 
536
}; break;
 
537
case 5073: { // glColorPointer
573
538
 GLint *size = (GLint *) bp; bp += 4;
574
539
 GLenum *type = (GLenum *) bp; bp += 4;
575
540
 GLsizei *stride = (GLsizei *) bp; bp += 4;
576
541
 GLvoid *pointer = (GLvoid *) * (int *) bp; bp += 4;
577
542
 weglColorPointer(*size,*type,*stride,pointer);
578
 
}; break; 
579
 
case 5074: { // glColorPointer 
 
543
}; break;
 
544
case 5074: { // glColorPointer
580
545
 GLint *size = (GLint *) bp; bp += 4;
581
546
 GLenum *type = (GLenum *) bp; bp += 4;
582
547
 GLsizei *stride = (GLsizei *) bp; bp += 4;
583
 
 GLvoid *pointer = (GLvoid *) bins[0]->base;
 
548
 GLvoid *pointer = (GLvoid *) bins[0];
584
549
 weglColorPointer(*size,*type,*stride,pointer);
585
 
}; break; 
586
 
case 5075: { // glCopyPixels 
 
550
}; break;
 
551
case 5075: { // glCopyPixels
587
552
 GLint *x = (GLint *) bp; bp += 4;
588
553
 GLint *y = (GLint *) bp; bp += 4;
589
554
 GLsizei *width = (GLsizei *) bp; bp += 4;
590
555
 GLsizei *height = (GLsizei *) bp; bp += 4;
591
556
 GLenum *type = (GLenum *) bp; bp += 4;
592
557
 weglCopyPixels(*x,*y,*width,*height,*type);
593
 
}; break; 
594
 
case 5076: { // glCopyTexImage1D 
 
558
}; break;
 
559
case 5076: { // glCopyTexImage1D
595
560
 GLenum *target = (GLenum *) bp; bp += 4;
596
561
 GLint *level = (GLint *) bp; bp += 4;
597
562
 GLenum *internalFormat = (GLenum *) bp; bp += 4;
600
565
 GLsizei *width = (GLsizei *) bp; bp += 4;
601
566
 GLint *border = (GLint *) bp; bp += 4;
602
567
 weglCopyTexImage1D(*target,*level,*internalFormat,*x,*y,*width,*border);
603
 
}; break; 
604
 
case 5077: { // glCopyTexImage2D 
 
568
}; break;
 
569
case 5077: { // glCopyTexImage2D
605
570
 GLenum *target = (GLenum *) bp; bp += 4;
606
571
 GLint *level = (GLint *) bp; bp += 4;
607
572
 GLenum *internalFormat = (GLenum *) bp; bp += 4;
611
576
 GLsizei *height = (GLsizei *) bp; bp += 4;
612
577
 GLint *border = (GLint *) bp; bp += 4;
613
578
 weglCopyTexImage2D(*target,*level,*internalFormat,*x,*y,*width,*height,*border);
614
 
}; break; 
615
 
case 5078: { // glCopyTexSubImage1D 
 
579
}; break;
 
580
case 5078: { // glCopyTexSubImage1D
616
581
 GLenum *target = (GLenum *) bp; bp += 4;
617
582
 GLint *level = (GLint *) bp; bp += 4;
618
583
 GLint *xoffset = (GLint *) bp; bp += 4;
620
585
 GLint *y = (GLint *) bp; bp += 4;
621
586
 GLsizei *width = (GLsizei *) bp; bp += 4;
622
587
 weglCopyTexSubImage1D(*target,*level,*xoffset,*x,*y,*width);
623
 
}; break; 
624
 
case 5079: { // glCopyTexSubImage2D 
 
588
}; break;
 
589
case 5079: { // glCopyTexSubImage2D
625
590
 GLenum *target = (GLenum *) bp; bp += 4;
626
591
 GLint *level = (GLint *) bp; bp += 4;
627
592
 GLint *xoffset = (GLint *) bp; bp += 4;
631
596
 GLsizei *width = (GLsizei *) bp; bp += 4;
632
597
 GLsizei *height = (GLsizei *) bp; bp += 4;
633
598
 weglCopyTexSubImage2D(*target,*level,*xoffset,*yoffset,*x,*y,*width,*height);
634
 
}; break; 
635
 
case 5080: { // glCullFace 
 
599
}; break;
 
600
case 5080: { // glCullFace
636
601
 GLenum *mode = (GLenum *) bp; bp += 4;
637
602
 weglCullFace(*mode);
638
 
}; break; 
639
 
case 5081: { // glDeleteLists 
 
603
}; break;
 
604
case 5081: { // glDeleteLists
640
605
 GLuint *list = (GLuint *) bp; bp += 4;
641
606
 GLsizei *range = (GLsizei *) bp; bp += 4;
642
607
 weglDeleteLists(*list,*range);
643
 
}; break; 
644
 
case 5082: { // glDeleteTextures 
 
608
}; break;
 
609
case 5082: { // glDeleteTextures
645
610
 int * texturesLen = (int *) bp; bp += 4;
646
611
 GLuint * textures = (GLuint *) bp;  bp += (8-((*texturesLen*4+4)%8))%8;
647
612
 weglDeleteTextures(*texturesLen,textures);
648
 
}; break; 
649
 
case 5083: { // glDepthFunc 
 
613
}; break;
 
614
case 5083: { // glDepthFunc
650
615
 GLenum *func = (GLenum *) bp; bp += 4;
651
616
 weglDepthFunc(*func);
652
 
}; break; 
653
 
case 5084: { // glDepthMask 
 
617
}; break;
 
618
case 5084: { // glDepthMask
654
619
 GLboolean *flag = (GLboolean *) bp; bp += 1;
655
620
 weglDepthMask(*flag);
656
 
}; break; 
657
 
case 5085: { // glDepthRange 
 
621
}; break;
 
622
case 5085: { // glDepthRange
658
623
 GLclampd *zNear = (GLclampd *) bp; bp += 8;
659
624
 GLclampd *zFar = (GLclampd *) bp; bp += 8;
660
625
 weglDepthRange(*zNear,*zFar);
661
 
}; break; 
662
 
case 5086: { // glDisable 
 
626
}; break;
 
627
case 5086: { // glDisable
663
628
 GLenum *cap = (GLenum *) bp; bp += 4;
664
629
 weglDisable(*cap);
665
 
}; break; 
666
 
case 5087: { // glDisableClientState 
 
630
}; break;
 
631
case 5087: { // glDisableClientState
667
632
 GLenum *array = (GLenum *) bp; bp += 4;
668
633
 weglDisableClientState(*array);
669
 
}; break; 
670
 
case 5088: { // glDrawArrays 
 
634
}; break;
 
635
case 5088: { // glDrawArrays
671
636
 GLenum *mode = (GLenum *) bp; bp += 4;
672
637
 GLint *first = (GLint *) bp; bp += 4;
673
638
 GLsizei *count = (GLsizei *) bp; bp += 4;
674
639
 weglDrawArrays(*mode,*first,*count);
675
 
}; break; 
676
 
case 5089: { // glDrawBuffer 
 
640
}; break;
 
641
case 5089: { // glDrawBuffer
677
642
 GLenum *mode = (GLenum *) bp; bp += 4;
678
643
 weglDrawBuffer(*mode);
679
 
}; break; 
680
 
case 5090: { // glDrawElements 
 
644
}; break;
 
645
case 5090: { // glDrawElements
681
646
 GLenum *mode = (GLenum *) bp; bp += 4;
682
647
 GLsizei *count = (GLsizei *) bp; bp += 4;
683
648
 GLenum *type = (GLenum *) bp; bp += 4;
684
649
 GLvoid *indices = (GLvoid *) * (int *) bp; bp += 4;
685
650
 weglDrawElements(*mode,*count,*type,indices);
686
 
}; break; 
687
 
case 5091: { // glDrawElements 
 
651
}; break;
 
652
case 5091: { // glDrawElements
688
653
 GLenum *mode = (GLenum *) bp; bp += 4;
689
654
 GLsizei *count = (GLsizei *) bp; bp += 4;
690
655
 GLenum *type = (GLenum *) bp; bp += 4;
691
 
 GLvoid *indices = (GLvoid *) bins[0]->base;
 
656
 GLvoid *indices = (GLvoid *) bins[0];
692
657
 weglDrawElements(*mode,*count,*type,indices);
693
 
}; break; 
694
 
case 5092: { // glDrawPixels 
 
658
}; break;
 
659
case 5092: { // glDrawPixels
695
660
 GLsizei *width = (GLsizei *) bp; bp += 4;
696
661
 GLsizei *height = (GLsizei *) bp; bp += 4;
697
662
 GLenum *format = (GLenum *) bp; bp += 4;
698
663
 GLenum *type = (GLenum *) bp; bp += 4;
699
664
 GLvoid *pixels = (GLvoid *) * (int *) bp; bp += 4;
700
665
 weglDrawPixels(*width,*height,*format,*type,pixels);
701
 
}; break; 
702
 
case 5093: { // glDrawPixels 
 
666
}; break;
 
667
case 5093: { // glDrawPixels
703
668
 GLsizei *width = (GLsizei *) bp; bp += 4;
704
669
 GLsizei *height = (GLsizei *) bp; bp += 4;
705
670
 GLenum *format = (GLenum *) bp; bp += 4;
706
671
 GLenum *type = (GLenum *) bp; bp += 4;
707
 
 GLvoid *pixels = (GLvoid *) bins[0]->base;
 
672
 GLvoid *pixels = (GLvoid *) bins[0];
708
673
 weglDrawPixels(*width,*height,*format,*type,pixels);
709
 
}; break; 
710
 
case 5094: { // glEdgeFlagv 
 
674
}; break;
 
675
case 5094: { // glEdgeFlagv
711
676
 GLboolean *flag = (GLboolean *) bp; bp += 1;
712
677
 weglEdgeFlagv(flag);
713
 
}; break; 
714
 
case 5095: { // glEdgeFlagPointer 
 
678
}; break;
 
679
case 5095: { // glEdgeFlagPointer
715
680
 GLsizei *stride = (GLsizei *) bp; bp += 4;
716
681
 GLvoid *pointer = (GLvoid *) * (int *) bp; bp += 4;
717
682
 weglEdgeFlagPointer(*stride,pointer);
718
 
}; break; 
719
 
case 5096: { // glEdgeFlagPointer 
 
683
}; break;
 
684
case 5096: { // glEdgeFlagPointer
720
685
 GLsizei *stride = (GLsizei *) bp; bp += 4;
721
 
 GLvoid *pointer = (GLvoid *) bins[0]->base;
 
686
 GLvoid *pointer = (GLvoid *) bins[0];
722
687
 weglEdgeFlagPointer(*stride,pointer);
723
 
}; break; 
724
 
case 5097: { // glEnable 
 
688
}; break;
 
689
case 5097: { // glEnable
725
690
 GLenum *cap = (GLenum *) bp; bp += 4;
726
691
 weglEnable(*cap);
727
 
}; break; 
728
 
case 5098: { // glEnableClientState 
 
692
}; break;
 
693
case 5098: { // glEnableClientState
729
694
 GLenum *array = (GLenum *) bp; bp += 4;
730
695
 weglEnableClientState(*array);
731
 
}; break; 
732
 
case 5099: { // glEnd 
 
696
}; break;
 
697
case 5099: { // glEnd
733
698
 weglEnd();
734
 
}; break; 
735
 
case 5100: { // glEndList 
 
699
}; break;
 
700
case 5100: { // glEndList
736
701
 weglEndList();
737
 
}; break; 
738
 
case 5101: { // glEvalCoord1dv 
 
702
}; break;
 
703
case 5101: { // glEvalCoord1dv
739
704
 GLdouble *u = (GLdouble *) bp; bp += 8;
740
705
 weglEvalCoord1dv(u);
741
 
}; break; 
742
 
case 5102: { // glEvalCoord1fv 
 
706
}; break;
 
707
case 5102: { // glEvalCoord1fv
743
708
 GLfloat *u = (GLfloat *) bp; bp += 4;
744
709
 weglEvalCoord1fv(u);
745
 
}; break; 
746
 
case 5103: { // glEvalCoord2dv 
 
710
}; break;
 
711
case 5103: { // glEvalCoord2dv
747
712
 GLdouble *u = (GLdouble *) bp; bp += 8;
748
713
 weglEvalCoord2dv(u);
749
 
}; break; 
750
 
case 5104: { // glEvalCoord2fv 
 
714
}; break;
 
715
case 5104: { // glEvalCoord2fv
751
716
 GLfloat *u = (GLfloat *) bp; bp += 4;
752
717
 weglEvalCoord2fv(u);
753
 
}; break; 
754
 
case 5105: { // glEvalMesh1 
 
718
}; break;
 
719
case 5105: { // glEvalMesh1
755
720
 GLenum *mode = (GLenum *) bp; bp += 4;
756
721
 GLint *i1 = (GLint *) bp; bp += 4;
757
722
 GLint *i2 = (GLint *) bp; bp += 4;
758
723
 weglEvalMesh1(*mode,*i1,*i2);
759
 
}; break; 
760
 
case 5106: { // glEvalMesh2 
 
724
}; break;
 
725
case 5106: { // glEvalMesh2
761
726
 GLenum *mode = (GLenum *) bp; bp += 4;
762
727
 GLint *i1 = (GLint *) bp; bp += 4;
763
728
 GLint *i2 = (GLint *) bp; bp += 4;
764
729
 GLint *j1 = (GLint *) bp; bp += 4;
765
730
 GLint *j2 = (GLint *) bp; bp += 4;
766
731
 weglEvalMesh2(*mode,*i1,*i2,*j1,*j2);
767
 
}; break; 
768
 
case 5107: { // glEvalPoint1 
 
732
}; break;
 
733
case 5107: { // glEvalPoint1
769
734
 GLint *i = (GLint *) bp; bp += 4;
770
735
 weglEvalPoint1(*i);
771
 
}; break; 
772
 
case 5108: { // glEvalPoint2 
 
736
}; break;
 
737
case 5108: { // glEvalPoint2
773
738
 GLint *i = (GLint *) bp; bp += 4;
774
739
 GLint *j = (GLint *) bp; bp += 4;
775
740
 weglEvalPoint2(*i,*j);
776
 
}; break; 
777
 
case 5109: { // glFeedbackBuffer 
 
741
}; break;
 
742
case 5109: { // glFeedbackBuffer
778
743
 GLsizei *size = (GLsizei *) bp; bp += 4;
779
744
 GLenum *type = (GLenum *) bp; bp += 4;
780
 
 GLfloat *buffer = (GLfloat *) bins[0]->base;
 
745
 GLfloat *buffer = (GLfloat *) bins[0];
781
746
 weglFeedbackBuffer(*size,*type,buffer);
782
747
 int AP = 0; ErlDrvTermData rt[6];
783
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
748
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
784
749
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
785
750
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
786
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
787
 
}; break; 
788
 
case 5110: { // glFinish 
 
751
 driver_send_term(port,caller,rt,AP);
 
752
}; break;
 
753
case 5110: { // glFinish
789
754
 weglFinish();
790
 
}; break; 
791
 
case 5111: { // glFlush 
 
755
}; break;
 
756
case 5111: { // glFlush
792
757
 weglFlush();
793
 
}; break; 
794
 
case 5112: { // glFogf 
 
758
}; break;
 
759
case 5112: { // glFogf
795
760
 GLenum *pname = (GLenum *) bp; bp += 4;
796
761
 GLfloat *param = (GLfloat *) bp; bp += 4;
797
762
 weglFogf(*pname,*param);
798
 
}; break; 
799
 
case 5113: { // glFogfv 
 
763
}; break;
 
764
case 5113: { // glFogfv
800
765
 GLenum *pname = (GLenum *) bp; bp += 4;
801
766
 int *paramsLen = (int *) bp; bp += 4;
802
767
 GLfloat *params = (GLfloat *) bp; bp += *paramsLen*4+((*paramsLen)+0)%2*4;
803
768
 weglFogfv(*pname,params);
804
 
}; break; 
805
 
case 5114: { // glFogi 
 
769
}; break;
 
770
case 5114: { // glFogi
806
771
 GLenum *pname = (GLenum *) bp; bp += 4;
807
772
 GLint *param = (GLint *) bp; bp += 4;
808
773
 weglFogi(*pname,*param);
809
 
}; break; 
810
 
case 5115: { // glFogiv 
 
774
}; break;
 
775
case 5115: { // glFogiv
811
776
 GLenum *pname = (GLenum *) bp; bp += 4;
812
777
 int *paramsLen = (int *) bp; bp += 4;
813
778
 GLint *params = (GLint *) bp; bp += *paramsLen*4+((*paramsLen)+0)%2*4;
814
779
 weglFogiv(*pname,params);
815
 
}; break; 
816
 
case 5116: { // glFrontFace 
 
780
}; break;
 
781
case 5116: { // glFrontFace
817
782
 GLenum *mode = (GLenum *) bp; bp += 4;
818
783
 weglFrontFace(*mode);
819
 
}; break; 
820
 
case 5117: { // glFrustum 
 
784
}; break;
 
785
case 5117: { // glFrustum
821
786
 GLdouble *left = (GLdouble *) bp; bp += 8;
822
787
 GLdouble *right = (GLdouble *) bp; bp += 8;
823
788
 GLdouble *bottom = (GLdouble *) bp; bp += 8;
825
790
 GLdouble *zNear = (GLdouble *) bp; bp += 8;
826
791
 GLdouble *zFar = (GLdouble *) bp; bp += 8;
827
792
 weglFrustum(*left,*right,*bottom,*top,*zNear,*zFar);
828
 
}; break; 
829
 
case 5118: { // glGenLists 
 
793
}; break;
 
794
case 5118: { // glGenLists
830
795
 GLsizei *range = (GLsizei *) bp; bp += 4;
831
796
 GLuint result = weglGenLists(*range);
832
797
 int AP = 0; ErlDrvTermData rt[6];
833
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
798
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
834
799
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
835
800
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
836
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
837
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
838
 
}; break; 
839
 
case 5119: { // glGenTextures 
 
801
 driver_send_term(port,caller,rt,AP);
 
802
}; break;
 
803
case 5119: { // glGenTextures
840
804
 GLsizei *n = (GLsizei *) bp; bp += 4;
841
805
 GLuint *textures;
842
806
 textures = (GLuint *) driver_alloc(sizeof(GLuint) * *n);
843
807
 weglGenTextures(*n,textures);
844
808
 int AP = 0; ErlDrvTermData *rt;
845
809
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*n)*2));
846
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
810
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
847
811
 for(int i=0; i < *n; i++) {
848
812
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) textures[i];}
849
813
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*n)+1;
850
814
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
851
 
 if (AP != 7 + (*n)*2 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7 + (*n)*2);
852
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
853
 
 driver_free(rt); 
 
815
 driver_send_term(port,caller,rt,AP);
 
816
 driver_free(rt);
854
817
 driver_free(textures);
855
 
}; break; 
856
 
case 5120: { // glGetBooleanv 
 
818
}; break;
 
819
case 5120: { // glGetBooleanv
857
820
 GLenum *pname = (GLenum *) bp; bp += 4;
858
821
 GLboolean params[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
859
822
 weglGetBooleanv(*pname,params);
860
823
 int AP = 0; ErlDrvTermData rt[39];
861
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
824
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
862
825
 GLboolean *paramsTmp = params;
863
826
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
864
827
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
878
841
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
879
842
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 16+1;
880
843
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
881
 
 if (AP != 39 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,39);
882
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
883
 
}; break; 
884
 
case 5121: { // glGetClipPlane 
 
844
 driver_send_term(port,caller,rt,AP);
 
845
}; break;
 
846
case 5121: { // glGetClipPlane
885
847
 GLenum *plane = (GLenum *) bp; bp += 4;
886
848
 GLdouble equation[4] = {0.0,0.0,0.0,0.0};
887
849
 weglGetClipPlane(*plane,equation);
888
850
 int AP = 0; ErlDrvTermData rt[14];
889
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
851
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
890
852
 GLdouble *equationTmp = equation;
891
853
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) equationTmp++;
892
854
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) equationTmp++;
894
856
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) equationTmp++;
895
857
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
896
858
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
897
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
898
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
899
 
}; break; 
900
 
case 5122: { // glGetDoublev 
 
859
 driver_send_term(port,caller,rt,AP);
 
860
}; break;
 
861
case 5122: { // glGetDoublev
901
862
 GLenum *pname = (GLenum *) bp; bp += 4;
902
863
 GLdouble params[16] = {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
903
864
 weglGetDoublev(*pname,params);
904
865
 int AP = 0; ErlDrvTermData rt[39];
905
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
866
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
906
867
 GLdouble *paramsTmp = params;
907
868
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
908
869
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
922
883
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
923
884
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 16+1;
924
885
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
925
 
 if (AP != 39 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,39);
926
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
927
 
}; break; 
928
 
case 5123: { // glGetError 
 
886
 driver_send_term(port,caller,rt,AP);
 
887
}; break;
 
888
case 5123: { // glGetError
929
889
 GLenum result = weglGetError();
930
890
 int AP = 0; ErlDrvTermData rt[6];
931
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
891
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
932
892
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
933
893
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
934
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
935
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
936
 
}; break; 
937
 
case 5124: { // glGetFloatv 
 
894
 driver_send_term(port,caller,rt,AP);
 
895
}; break;
 
896
case 5124: { // glGetFloatv
938
897
 GLenum *pname = (GLenum *) bp; bp += 4;
939
898
 GLfloat params[16] = {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
940
899
 weglGetFloatv(*pname,params);
941
900
 int AP = 0; ErlDrvTermData rt[39];
942
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
901
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
943
902
 GLdouble paramsConv[16], *paramsTmp = paramsConv; 
944
903
 for(int i=0; i < 16; i++) paramsConv[i] = (GLdouble) params[i];
945
904
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
960
919
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
961
920
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 16+1;
962
921
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
963
 
 if (AP != 39 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,39);
964
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
965
 
}; break; 
966
 
case 5125: { // glGetIntegerv 
 
922
 driver_send_term(port,caller,rt,AP);
 
923
}; break;
 
924
case 5125: { // glGetIntegerv
967
925
 GLenum *pname = (GLenum *) bp; bp += 4;
968
926
 GLint params[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
969
927
 weglGetIntegerv(*pname,params);
970
928
 int AP = 0; ErlDrvTermData rt[39];
971
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
929
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
972
930
 GLint *paramsTmp = params;
973
931
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
974
932
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
988
946
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
989
947
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 16+1;
990
948
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
991
 
 if (AP != 39 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,39);
992
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
993
 
}; break; 
994
 
case 5126: { // glGetLightfv 
 
949
 driver_send_term(port,caller,rt,AP);
 
950
}; break;
 
951
case 5126: { // glGetLightfv
995
952
 GLenum *light = (GLenum *) bp; bp += 4;
996
953
 GLenum *pname = (GLenum *) bp; bp += 4;
997
954
 GLfloat params[4] = {0.0,0.0,0.0,0.0};
998
955
 weglGetLightfv(*light,*pname,params);
999
956
 int AP = 0; ErlDrvTermData rt[14];
1000
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
957
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1001
958
 GLdouble paramsConv[4], *paramsTmp = paramsConv; 
1002
959
 for(int i=0; i < 4; i++) paramsConv[i] = (GLdouble) params[i];
1003
960
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
1006
963
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
1007
964
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
1008
965
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1009
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
1010
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1011
 
}; break; 
1012
 
case 5127: { // glGetLightiv 
 
966
 driver_send_term(port,caller,rt,AP);
 
967
}; break;
 
968
case 5127: { // glGetLightiv
1013
969
 GLenum *light = (GLenum *) bp; bp += 4;
1014
970
 GLenum *pname = (GLenum *) bp; bp += 4;
1015
971
 GLint params[4] = {0,0,0,0};
1016
972
 weglGetLightiv(*light,*pname,params);
1017
973
 int AP = 0; ErlDrvTermData rt[14];
1018
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
974
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1019
975
 GLint *paramsTmp = params;
1020
976
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1021
977
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1023
979
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1024
980
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
1025
981
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1026
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
1027
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1028
 
}; break; 
1029
 
case 5128: { // glGetMapdv 
 
982
 driver_send_term(port,caller,rt,AP);
 
983
}; break;
 
984
case 5128: { // glGetMapdv
1030
985
 GLenum *target = (GLenum *) bp; bp += 4;
1031
986
 GLenum *query = (GLenum *) bp; bp += 4;
1032
 
 GLdouble *v = (GLdouble *) bins[0]->base;
 
987
 GLdouble *v = (GLdouble *) bins[0];
1033
988
 weglGetMapdv(*target,*query,v);
1034
989
 int AP = 0; ErlDrvTermData rt[6];
1035
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
990
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1036
991
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
1037
992
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1038
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1039
 
}; break; 
1040
 
case 5129: { // glGetMapfv 
 
993
 driver_send_term(port,caller,rt,AP);
 
994
}; break;
 
995
case 5129: { // glGetMapfv
1041
996
 GLenum *target = (GLenum *) bp; bp += 4;
1042
997
 GLenum *query = (GLenum *) bp; bp += 4;
1043
 
 GLfloat *v = (GLfloat *) bins[0]->base;
 
998
 GLfloat *v = (GLfloat *) bins[0];
1044
999
 weglGetMapfv(*target,*query,v);
1045
1000
 int AP = 0; ErlDrvTermData rt[6];
1046
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1001
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1047
1002
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
1048
1003
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1049
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1050
 
}; break; 
1051
 
case 5130: { // glGetMapiv 
 
1004
 driver_send_term(port,caller,rt,AP);
 
1005
}; break;
 
1006
case 5130: { // glGetMapiv
1052
1007
 GLenum *target = (GLenum *) bp; bp += 4;
1053
1008
 GLenum *query = (GLenum *) bp; bp += 4;
1054
 
 GLint *v = (GLint *) bins[0]->base;
 
1009
 GLint *v = (GLint *) bins[0];
1055
1010
 weglGetMapiv(*target,*query,v);
1056
1011
 int AP = 0; ErlDrvTermData rt[6];
1057
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1012
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1058
1013
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
1059
1014
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1060
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1061
 
}; break; 
1062
 
case 5131: { // glGetMaterialfv 
 
1015
 driver_send_term(port,caller,rt,AP);
 
1016
}; break;
 
1017
case 5131: { // glGetMaterialfv
1063
1018
 GLenum *face = (GLenum *) bp; bp += 4;
1064
1019
 GLenum *pname = (GLenum *) bp; bp += 4;
1065
1020
 GLfloat params[4] = {0.0,0.0,0.0,0.0};
1066
1021
 weglGetMaterialfv(*face,*pname,params);
1067
1022
 int AP = 0; ErlDrvTermData rt[14];
1068
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1023
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1069
1024
 GLdouble paramsConv[4], *paramsTmp = paramsConv; 
1070
1025
 for(int i=0; i < 4; i++) paramsConv[i] = (GLdouble) params[i];
1071
1026
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
1074
1029
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
1075
1030
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
1076
1031
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1077
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
1078
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1079
 
}; break; 
1080
 
case 5132: { // glGetMaterialiv 
 
1032
 driver_send_term(port,caller,rt,AP);
 
1033
}; break;
 
1034
case 5132: { // glGetMaterialiv
1081
1035
 GLenum *face = (GLenum *) bp; bp += 4;
1082
1036
 GLenum *pname = (GLenum *) bp; bp += 4;
1083
1037
 GLint params[4] = {0,0,0,0};
1084
1038
 weglGetMaterialiv(*face,*pname,params);
1085
1039
 int AP = 0; ErlDrvTermData rt[14];
1086
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1040
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1087
1041
 GLint *paramsTmp = params;
1088
1042
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1089
1043
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1091
1045
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1092
1046
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
1093
1047
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1094
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
1095
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1096
 
}; break; 
1097
 
case 5133: { // glGetPixelMapfv 
 
1048
 driver_send_term(port,caller,rt,AP);
 
1049
}; break;
 
1050
case 5133: { // glGetPixelMapfv
1098
1051
 GLenum *map = (GLenum *) bp; bp += 4;
1099
 
 GLfloat *values = (GLfloat *) bins[0]->base;
 
1052
 GLfloat *values = (GLfloat *) bins[0];
1100
1053
 weglGetPixelMapfv(*map,values);
1101
1054
 int AP = 0; ErlDrvTermData rt[6];
1102
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1055
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1103
1056
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
1104
1057
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1105
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1106
 
}; break; 
1107
 
case 5134: { // glGetPixelMapuiv 
 
1058
 driver_send_term(port,caller,rt,AP);
 
1059
}; break;
 
1060
case 5134: { // glGetPixelMapuiv
1108
1061
 GLenum *map = (GLenum *) bp; bp += 4;
1109
 
 GLuint *values = (GLuint *) bins[0]->base;
 
1062
 GLuint *values = (GLuint *) bins[0];
1110
1063
 weglGetPixelMapuiv(*map,values);
1111
1064
 int AP = 0; ErlDrvTermData rt[6];
1112
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1065
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1113
1066
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
1114
1067
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1115
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1116
 
}; break; 
1117
 
case 5135: { // glGetPixelMapusv 
 
1068
 driver_send_term(port,caller,rt,AP);
 
1069
}; break;
 
1070
case 5135: { // glGetPixelMapusv
1118
1071
 GLenum *map = (GLenum *) bp; bp += 4;
1119
 
 GLushort *values = (GLushort *) bins[0]->base;
 
1072
 GLushort *values = (GLushort *) bins[0];
1120
1073
 weglGetPixelMapusv(*map,values);
1121
1074
 int AP = 0; ErlDrvTermData rt[6];
1122
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1075
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1123
1076
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
1124
1077
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1125
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1126
 
}; break; 
1127
 
case 5136: { // glGetPolygonStipple 
1128
 
 GLubyte mask[128];
1129
 
 weglGetPolygonStipple(mask);
 
1078
 driver_send_term(port,caller,rt,AP);
 
1079
}; break;
 
1080
case 5136: { // glGetPolygonStipple
 
1081
 ErlDrvBinary *mask = driver_alloc_binary(128);
 
1082
 weglGetPolygonStipple((GLubyte*) mask->orig_bytes);
1130
1083
 int AP = 0; ErlDrvTermData rt[8];
1131
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
1132
 
 ErlDrvBinary * BinCopy = driver_alloc_binary(128);
1133
 
 memcpy(BinCopy->orig_bytes, mask, 128);
1134
 
 rt[AP++] = ERL_DRV_BINARY; rt[AP++] = (ErlDrvTermData) BinCopy; rt[AP++] = 128; rt[AP++] = 0;
 
1084
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
1085
 rt[AP++] = ERL_DRV_BINARY; rt[AP++] = (ErlDrvTermData) mask; rt[AP++] = 128; rt[AP++] = 0;
1135
1086
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1136
 
 if (AP != 8 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,8);
1137
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1138
 
 driver_free_binary(BinCopy);
1139
 
}; break; 
1140
 
case 5137: { // glGetString 
 
1087
 driver_send_term(port,caller,rt,AP);
 
1088
 driver_free_binary(mask);
 
1089
}; break;
 
1090
case 5137: { // glGetString
1141
1091
 GLenum *name = (GLenum *) bp; bp += 4;
1142
1092
 const GLubyte *  result = weglGetString(*name);
1143
1093
 int AP = 0; ErlDrvTermData rt[7];
1144
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1094
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1145
1095
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) result; rt[AP++] = strlen((char *) result);
1146
1096
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1147
 
 if (AP != 7 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7);
1148
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1149
 
}; break; 
1150
 
case 5138: { // glGetTexEnvfv 
 
1097
 driver_send_term(port,caller,rt,AP);
 
1098
}; break;
 
1099
case 5138: { // glGetTexEnvfv
1151
1100
 GLenum *target = (GLenum *) bp; bp += 4;
1152
1101
 GLenum *pname = (GLenum *) bp; bp += 4;
1153
1102
 GLfloat params[4] = {0.0,0.0,0.0,0.0};
1154
1103
 weglGetTexEnvfv(*target,*pname,params);
1155
1104
 int AP = 0; ErlDrvTermData rt[14];
1156
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1105
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1157
1106
 GLdouble paramsConv[4], *paramsTmp = paramsConv; 
1158
1107
 for(int i=0; i < 4; i++) paramsConv[i] = (GLdouble) params[i];
1159
1108
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
1162
1111
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
1163
1112
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
1164
1113
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1165
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
1166
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1167
 
}; break; 
1168
 
case 5139: { // glGetTexEnviv 
 
1114
 driver_send_term(port,caller,rt,AP);
 
1115
}; break;
 
1116
case 5139: { // glGetTexEnviv
1169
1117
 GLenum *target = (GLenum *) bp; bp += 4;
1170
1118
 GLenum *pname = (GLenum *) bp; bp += 4;
1171
1119
 GLint params[4] = {0,0,0,0};
1172
1120
 weglGetTexEnviv(*target,*pname,params);
1173
1121
 int AP = 0; ErlDrvTermData rt[14];
1174
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1122
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1175
1123
 GLint *paramsTmp = params;
1176
1124
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1177
1125
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1179
1127
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1180
1128
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
1181
1129
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1182
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
1183
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1184
 
}; break; 
1185
 
case 5140: { // glGetTexGendv 
 
1130
 driver_send_term(port,caller,rt,AP);
 
1131
}; break;
 
1132
case 5140: { // glGetTexGendv
1186
1133
 GLenum *coord = (GLenum *) bp; bp += 4;
1187
1134
 GLenum *pname = (GLenum *) bp; bp += 4;
1188
1135
 GLdouble params[4] = {0.0,0.0,0.0,0.0};
1189
1136
 weglGetTexGendv(*coord,*pname,params);
1190
1137
 int AP = 0; ErlDrvTermData rt[14];
1191
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1138
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1192
1139
 GLdouble *paramsTmp = params;
1193
1140
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
1194
1141
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
1196
1143
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
1197
1144
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
1198
1145
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1199
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
1200
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1201
 
}; break; 
1202
 
case 5141: { // glGetTexGenfv 
 
1146
 driver_send_term(port,caller,rt,AP);
 
1147
}; break;
 
1148
case 5141: { // glGetTexGenfv
1203
1149
 GLenum *coord = (GLenum *) bp; bp += 4;
1204
1150
 GLenum *pname = (GLenum *) bp; bp += 4;
1205
1151
 GLfloat params[4] = {0.0,0.0,0.0,0.0};
1206
1152
 weglGetTexGenfv(*coord,*pname,params);
1207
1153
 int AP = 0; ErlDrvTermData rt[14];
1208
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1154
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1209
1155
 GLdouble paramsConv[4], *paramsTmp = paramsConv; 
1210
1156
 for(int i=0; i < 4; i++) paramsConv[i] = (GLdouble) params[i];
1211
1157
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
1214
1160
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
1215
1161
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
1216
1162
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1217
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
1218
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1219
 
}; break; 
1220
 
case 5142: { // glGetTexGeniv 
 
1163
 driver_send_term(port,caller,rt,AP);
 
1164
}; break;
 
1165
case 5142: { // glGetTexGeniv
1221
1166
 GLenum *coord = (GLenum *) bp; bp += 4;
1222
1167
 GLenum *pname = (GLenum *) bp; bp += 4;
1223
1168
 GLint params[4] = {0,0,0,0};
1224
1169
 weglGetTexGeniv(*coord,*pname,params);
1225
1170
 int AP = 0; ErlDrvTermData rt[14];
1226
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1171
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1227
1172
 GLint *paramsTmp = params;
1228
1173
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1229
1174
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1231
1176
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1232
1177
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
1233
1178
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1234
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
1235
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1236
 
}; break; 
1237
 
case 5143: { // glGetTexImage 
 
1179
 driver_send_term(port,caller,rt,AP);
 
1180
}; break;
 
1181
case 5143: { // glGetTexImage
1238
1182
 GLenum *target = (GLenum *) bp; bp += 4;
1239
1183
 GLint *level = (GLint *) bp; bp += 4;
1240
1184
 GLenum *format = (GLenum *) bp; bp += 4;
1241
1185
 GLenum *type = (GLenum *) bp; bp += 4;
1242
 
 GLvoid *pixels = (GLvoid *) bins[0]->base;
 
1186
 GLvoid *pixels = (GLvoid *) bins[0];
1243
1187
 weglGetTexImage(*target,*level,*format,*type,pixels);
1244
1188
 int AP = 0; ErlDrvTermData rt[6];
1245
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1189
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1246
1190
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
1247
1191
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1248
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1249
 
}; break; 
1250
 
case 5144: { // glGetTexLevelParameterfv 
 
1192
 driver_send_term(port,caller,rt,AP);
 
1193
}; break;
 
1194
case 5144: { // glGetTexLevelParameterfv
1251
1195
 GLenum *target = (GLenum *) bp; bp += 4;
1252
1196
 GLint *level = (GLint *) bp; bp += 4;
1253
1197
 GLenum *pname = (GLenum *) bp; bp += 4;
1254
1198
 GLfloat params[1] = {0.0};
1255
1199
 weglGetTexLevelParameterfv(*target,*level,*pname,params);
1256
1200
 int AP = 0; ErlDrvTermData rt[8];
1257
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1201
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1258
1202
 GLdouble paramsConv[1], *paramsTmp = paramsConv; 
1259
1203
 for(int i=0; i < 1; i++) paramsConv[i] = (GLdouble) params[i];
1260
1204
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
1261
1205
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 1;
1262
1206
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1263
 
 if (AP != 8 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,8);
1264
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1265
 
}; break; 
1266
 
case 5145: { // glGetTexLevelParameteriv 
 
1207
 driver_send_term(port,caller,rt,AP);
 
1208
}; break;
 
1209
case 5145: { // glGetTexLevelParameteriv
1267
1210
 GLenum *target = (GLenum *) bp; bp += 4;
1268
1211
 GLint *level = (GLint *) bp; bp += 4;
1269
1212
 GLenum *pname = (GLenum *) bp; bp += 4;
1270
1213
 GLint params[1] = {0};
1271
1214
 weglGetTexLevelParameteriv(*target,*level,*pname,params);
1272
1215
 int AP = 0; ErlDrvTermData rt[8];
1273
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1216
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1274
1217
 GLint *paramsTmp = params;
1275
1218
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1276
1219
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 1;
1277
1220
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1278
 
 if (AP != 8 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,8);
1279
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1280
 
}; break; 
1281
 
case 5146: { // glGetTexParameterfv 
 
1221
 driver_send_term(port,caller,rt,AP);
 
1222
}; break;
 
1223
case 5146: { // glGetTexParameterfv
1282
1224
 GLenum *target = (GLenum *) bp; bp += 4;
1283
1225
 GLenum *pname = (GLenum *) bp; bp += 4;
1284
1226
 GLfloat params[4] = {0.0,0.0,0.0,0.0};
1285
1227
 weglGetTexParameterfv(*target,*pname,params);
1286
1228
 int AP = 0; ErlDrvTermData rt[14];
1287
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1229
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1288
1230
 GLdouble paramsConv[4], *paramsTmp = paramsConv; 
1289
1231
 for(int i=0; i < 4; i++) paramsConv[i] = (GLdouble) params[i];
1290
1232
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
1293
1235
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
1294
1236
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
1295
1237
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1296
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
1297
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1298
 
}; break; 
1299
 
case 5147: { // glGetTexParameteriv 
 
1238
 driver_send_term(port,caller,rt,AP);
 
1239
}; break;
 
1240
case 5147: { // glGetTexParameteriv
1300
1241
 GLenum *target = (GLenum *) bp; bp += 4;
1301
1242
 GLenum *pname = (GLenum *) bp; bp += 4;
1302
1243
 GLint params[4] = {0,0,0,0};
1303
1244
 weglGetTexParameteriv(*target,*pname,params);
1304
1245
 int AP = 0; ErlDrvTermData rt[14];
1305
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1246
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1306
1247
 GLint *paramsTmp = params;
1307
1248
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1308
1249
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1310
1251
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
1311
1252
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
1312
1253
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1313
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
1314
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1315
 
}; break; 
1316
 
case 5148: { // glHint 
 
1254
 driver_send_term(port,caller,rt,AP);
 
1255
}; break;
 
1256
case 5148: { // glHint
1317
1257
 GLenum *target = (GLenum *) bp; bp += 4;
1318
1258
 GLenum *mode = (GLenum *) bp; bp += 4;
1319
1259
 weglHint(*target,*mode);
1320
 
}; break; 
1321
 
case 5149: { // glIndexMask 
 
1260
}; break;
 
1261
case 5149: { // glIndexMask
1322
1262
 GLuint *mask = (GLuint *) bp; bp += 4;
1323
1263
 weglIndexMask(*mask);
1324
 
}; break; 
1325
 
case 5150: { // glIndexPointer 
 
1264
}; break;
 
1265
case 5150: { // glIndexPointer
1326
1266
 GLenum *type = (GLenum *) bp; bp += 4;
1327
1267
 GLsizei *stride = (GLsizei *) bp; bp += 4;
1328
1268
 GLvoid *pointer = (GLvoid *) * (int *) bp; bp += 4;
1329
1269
 weglIndexPointer(*type,*stride,pointer);
1330
 
}; break; 
1331
 
case 5151: { // glIndexPointer 
 
1270
}; break;
 
1271
case 5151: { // glIndexPointer
1332
1272
 GLenum *type = (GLenum *) bp; bp += 4;
1333
1273
 GLsizei *stride = (GLsizei *) bp; bp += 4;
1334
 
 GLvoid *pointer = (GLvoid *) bins[0]->base;
 
1274
 GLvoid *pointer = (GLvoid *) bins[0];
1335
1275
 weglIndexPointer(*type,*stride,pointer);
1336
 
}; break; 
1337
 
case 5152: { // glIndexdv 
 
1276
}; break;
 
1277
case 5152: { // glIndexdv
1338
1278
 GLdouble *c = (GLdouble *) bp; bp += 8;
1339
1279
 weglIndexdv(c);
1340
 
}; break; 
1341
 
case 5153: { // glIndexfv 
 
1280
}; break;
 
1281
case 5153: { // glIndexfv
1342
1282
 GLfloat *c = (GLfloat *) bp; bp += 4;
1343
1283
 weglIndexfv(c);
1344
 
}; break; 
1345
 
case 5154: { // glIndexiv 
 
1284
}; break;
 
1285
case 5154: { // glIndexiv
1346
1286
 GLint *c = (GLint *) bp; bp += 4;
1347
1287
 weglIndexiv(c);
1348
 
}; break; 
1349
 
case 5155: { // glIndexsv 
 
1288
}; break;
 
1289
case 5155: { // glIndexsv
1350
1290
 GLshort *c = (GLshort *) bp; bp += 2;
1351
1291
 weglIndexsv(c);
1352
 
}; break; 
1353
 
case 5156: { // glIndexubv 
 
1292
}; break;
 
1293
case 5156: { // glIndexubv
1354
1294
 GLubyte *c = (GLubyte *) bp; bp += 1;
1355
1295
 weglIndexubv(c);
1356
 
}; break; 
1357
 
case 5157: { // glInitNames 
 
1296
}; break;
 
1297
case 5157: { // glInitNames
1358
1298
 weglInitNames();
1359
 
}; break; 
1360
 
case 5158: { // glInterleavedArrays 
 
1299
}; break;
 
1300
case 5158: { // glInterleavedArrays
1361
1301
 GLenum *format = (GLenum *) bp; bp += 4;
1362
1302
 GLsizei *stride = (GLsizei *) bp; bp += 4;
1363
1303
 GLvoid *pointer = (GLvoid *) * (int *) bp; bp += 4;
1364
1304
 weglInterleavedArrays(*format,*stride,pointer);
1365
 
}; break; 
1366
 
case 5159: { // glInterleavedArrays 
 
1305
}; break;
 
1306
case 5159: { // glInterleavedArrays
1367
1307
 GLenum *format = (GLenum *) bp; bp += 4;
1368
1308
 GLsizei *stride = (GLsizei *) bp; bp += 4;
1369
 
 GLvoid *pointer = (GLvoid *) bins[0]->base;
 
1309
 GLvoid *pointer = (GLvoid *) bins[0];
1370
1310
 weglInterleavedArrays(*format,*stride,pointer);
1371
 
}; break; 
1372
 
case 5160: { // glIsEnabled 
 
1311
}; break;
 
1312
case 5160: { // glIsEnabled
1373
1313
 GLenum *cap = (GLenum *) bp; bp += 4;
1374
1314
 GLboolean result = weglIsEnabled(*cap);
1375
1315
 int AP = 0; ErlDrvTermData rt[6];
1376
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1316
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1377
1317
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
1378
1318
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1379
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
1380
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1381
 
}; break; 
1382
 
case 5161: { // glIsList 
 
1319
 driver_send_term(port,caller,rt,AP);
 
1320
}; break;
 
1321
case 5161: { // glIsList
1383
1322
 GLuint *list = (GLuint *) bp; bp += 4;
1384
1323
 GLboolean result = weglIsList(*list);
1385
1324
 int AP = 0; ErlDrvTermData rt[6];
1386
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1325
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1387
1326
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
1388
1327
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1389
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
1390
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1391
 
}; break; 
1392
 
case 5162: { // glIsTexture 
 
1328
 driver_send_term(port,caller,rt,AP);
 
1329
}; break;
 
1330
case 5162: { // glIsTexture
1393
1331
 GLuint *texture = (GLuint *) bp; bp += 4;
1394
1332
 GLboolean result = weglIsTexture(*texture);
1395
1333
 int AP = 0; ErlDrvTermData rt[6];
1396
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1334
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1397
1335
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
1398
1336
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1399
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
1400
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1401
 
}; break; 
1402
 
case 5163: { // glLightModelf 
 
1337
 driver_send_term(port,caller,rt,AP);
 
1338
}; break;
 
1339
case 5163: { // glLightModelf
1403
1340
 GLenum *pname = (GLenum *) bp; bp += 4;
1404
1341
 GLfloat *param = (GLfloat *) bp; bp += 4;
1405
1342
 weglLightModelf(*pname,*param);
1406
 
}; break; 
1407
 
case 5164: { // glLightModelfv 
 
1343
}; break;
 
1344
case 5164: { // glLightModelfv
1408
1345
 GLenum *pname = (GLenum *) bp; bp += 4;
1409
1346
 int *paramsLen = (int *) bp; bp += 4;
1410
1347
 GLfloat *params = (GLfloat *) bp; bp += *paramsLen*4+((*paramsLen)+0)%2*4;
1411
1348
 weglLightModelfv(*pname,params);
1412
 
}; break; 
1413
 
case 5165: { // glLightModeli 
 
1349
}; break;
 
1350
case 5165: { // glLightModeli
1414
1351
 GLenum *pname = (GLenum *) bp; bp += 4;
1415
1352
 GLint *param = (GLint *) bp; bp += 4;
1416
1353
 weglLightModeli(*pname,*param);
1417
 
}; break; 
1418
 
case 5166: { // glLightModeliv 
 
1354
}; break;
 
1355
case 5166: { // glLightModeliv
1419
1356
 GLenum *pname = (GLenum *) bp; bp += 4;
1420
1357
 int *paramsLen = (int *) bp; bp += 4;
1421
1358
 GLint *params = (GLint *) bp; bp += *paramsLen*4+((*paramsLen)+0)%2*4;
1422
1359
 weglLightModeliv(*pname,params);
1423
 
}; break; 
1424
 
case 5167: { // glLightf 
 
1360
}; break;
 
1361
case 5167: { // glLightf
1425
1362
 GLenum *light = (GLenum *) bp; bp += 4;
1426
1363
 GLenum *pname = (GLenum *) bp; bp += 4;
1427
1364
 GLfloat *param = (GLfloat *) bp; bp += 4;
1428
1365
 weglLightf(*light,*pname,*param);
1429
 
}; break; 
1430
 
case 5168: { // glLightfv 
 
1366
}; break;
 
1367
case 5168: { // glLightfv
1431
1368
 GLenum *light = (GLenum *) bp; bp += 4;
1432
1369
 GLenum *pname = (GLenum *) bp; bp += 4;
1433
1370
 int *paramsLen = (int *) bp; bp += 4;
1434
1371
 GLfloat *params = (GLfloat *) bp; bp += *paramsLen*4+((*paramsLen)+1)%2*4;
1435
1372
 weglLightfv(*light,*pname,params);
1436
 
}; break; 
1437
 
case 5169: { // glLighti 
 
1373
}; break;
 
1374
case 5169: { // glLighti
1438
1375
 GLenum *light = (GLenum *) bp; bp += 4;
1439
1376
 GLenum *pname = (GLenum *) bp; bp += 4;
1440
1377
 GLint *param = (GLint *) bp; bp += 4;
1441
1378
 weglLighti(*light,*pname,*param);
1442
 
}; break; 
1443
 
case 5170: { // glLightiv 
 
1379
}; break;
 
1380
case 5170: { // glLightiv
1444
1381
 GLenum *light = (GLenum *) bp; bp += 4;
1445
1382
 GLenum *pname = (GLenum *) bp; bp += 4;
1446
1383
 int *paramsLen = (int *) bp; bp += 4;
1447
1384
 GLint *params = (GLint *) bp; bp += *paramsLen*4+((*paramsLen)+1)%2*4;
1448
1385
 weglLightiv(*light,*pname,params);
1449
 
}; break; 
1450
 
case 5171: { // glLineStipple 
 
1386
}; break;
 
1387
case 5171: { // glLineStipple
1451
1388
 GLint *factor = (GLint *) bp; bp += 4;
1452
1389
 GLushort *pattern = (GLushort *) bp; bp += 2;
1453
1390
 weglLineStipple(*factor,*pattern);
1454
 
}; break; 
1455
 
case 5172: { // glLineWidth 
 
1391
}; break;
 
1392
case 5172: { // glLineWidth
1456
1393
 GLfloat *width = (GLfloat *) bp; bp += 4;
1457
1394
 weglLineWidth(*width);
1458
 
}; break; 
1459
 
case 5173: { // glListBase 
 
1395
}; break;
 
1396
case 5173: { // glListBase
1460
1397
 GLuint *base = (GLuint *) bp; bp += 4;
1461
1398
 weglListBase(*base);
1462
 
}; break; 
1463
 
case 5174: { // glLoadIdentity 
 
1399
}; break;
 
1400
case 5174: { // glLoadIdentity
1464
1401
 weglLoadIdentity();
1465
 
}; break; 
1466
 
case 5175: { // glLoadMatrixd 
 
1402
}; break;
 
1403
case 5175: { // glLoadMatrixd
1467
1404
 GLdouble * m = (GLdouble *) bp; bp += 128;
1468
1405
 weglLoadMatrixd(m);
1469
 
}; break; 
1470
 
case 5176: { // glLoadMatrixf 
 
1406
}; break;
 
1407
case 5176: { // glLoadMatrixf
1471
1408
 GLfloat * m = (GLfloat *) bp; bp += 64;
1472
1409
 weglLoadMatrixf(m);
1473
 
}; break; 
1474
 
case 5177: { // glLoadName 
 
1410
}; break;
 
1411
case 5177: { // glLoadName
1475
1412
 GLuint *name = (GLuint *) bp; bp += 4;
1476
1413
 weglLoadName(*name);
1477
 
}; break; 
1478
 
case 5178: { // glLogicOp 
 
1414
}; break;
 
1415
case 5178: { // glLogicOp
1479
1416
 GLenum *opcode = (GLenum *) bp; bp += 4;
1480
1417
 weglLogicOp(*opcode);
1481
 
}; break; 
1482
 
case 5179: { // glMap1d 
 
1418
}; break;
 
1419
case 5179: { // glMap1d
1483
1420
 GLenum *target = (GLenum *) bp; bp += 4;
1484
1421
 bp += 4;
1485
1422
 GLdouble *u1 = (GLdouble *) bp; bp += 8;
1486
1423
 GLdouble *u2 = (GLdouble *) bp; bp += 8;
1487
1424
 GLint *stride = (GLint *) bp; bp += 4;
1488
1425
 GLint *order = (GLint *) bp; bp += 4;
1489
 
 GLdouble *points = (GLdouble *) bins[0]->base;
 
1426
 GLdouble *points = (GLdouble *) bins[0];
1490
1427
 weglMap1d(*target,*u1,*u2,*stride,*order,points);
1491
 
}; break; 
1492
 
case 5180: { // glMap1f 
 
1428
}; break;
 
1429
case 5180: { // glMap1f
1493
1430
 GLenum *target = (GLenum *) bp; bp += 4;
1494
1431
 GLfloat *u1 = (GLfloat *) bp; bp += 4;
1495
1432
 GLfloat *u2 = (GLfloat *) bp; bp += 4;
1496
1433
 GLint *stride = (GLint *) bp; bp += 4;
1497
1434
 GLint *order = (GLint *) bp; bp += 4;
1498
 
 GLfloat *points = (GLfloat *) bins[0]->base;
 
1435
 GLfloat *points = (GLfloat *) bins[0];
1499
1436
 weglMap1f(*target,*u1,*u2,*stride,*order,points);
1500
 
}; break; 
1501
 
case 5181: { // glMap2d 
 
1437
}; break;
 
1438
case 5181: { // glMap2d
1502
1439
 GLenum *target = (GLenum *) bp; bp += 4;
1503
1440
 bp += 4;
1504
1441
 GLdouble *u1 = (GLdouble *) bp; bp += 8;
1509
1446
 GLdouble *v2 = (GLdouble *) bp; bp += 8;
1510
1447
 GLint *vstride = (GLint *) bp; bp += 4;
1511
1448
 GLint *vorder = (GLint *) bp; bp += 4;
1512
 
 GLdouble *points = (GLdouble *) bins[0]->base;
 
1449
 GLdouble *points = (GLdouble *) bins[0];
1513
1450
 weglMap2d(*target,*u1,*u2,*ustride,*uorder,*v1,*v2,*vstride,*vorder,points);
1514
 
}; break; 
1515
 
case 5182: { // glMap2f 
 
1451
}; break;
 
1452
case 5182: { // glMap2f
1516
1453
 GLenum *target = (GLenum *) bp; bp += 4;
1517
1454
 GLfloat *u1 = (GLfloat *) bp; bp += 4;
1518
1455
 GLfloat *u2 = (GLfloat *) bp; bp += 4;
1522
1459
 GLfloat *v2 = (GLfloat *) bp; bp += 4;
1523
1460
 GLint *vstride = (GLint *) bp; bp += 4;
1524
1461
 GLint *vorder = (GLint *) bp; bp += 4;
1525
 
 GLfloat *points = (GLfloat *) bins[0]->base;
 
1462
 GLfloat *points = (GLfloat *) bins[0];
1526
1463
 weglMap2f(*target,*u1,*u2,*ustride,*uorder,*v1,*v2,*vstride,*vorder,points);
1527
 
}; break; 
1528
 
case 5183: { // glMapGrid1d 
 
1464
}; break;
 
1465
case 5183: { // glMapGrid1d
1529
1466
 GLint *un = (GLint *) bp; bp += 4;
1530
1467
 bp += 4;
1531
1468
 GLdouble *u1 = (GLdouble *) bp; bp += 8;
1532
1469
 GLdouble *u2 = (GLdouble *) bp; bp += 8;
1533
1470
 weglMapGrid1d(*un,*u1,*u2);
1534
 
}; break; 
1535
 
case 5184: { // glMapGrid1f 
 
1471
}; break;
 
1472
case 5184: { // glMapGrid1f
1536
1473
 GLint *un = (GLint *) bp; bp += 4;
1537
1474
 GLfloat *u1 = (GLfloat *) bp; bp += 4;
1538
1475
 GLfloat *u2 = (GLfloat *) bp; bp += 4;
1539
1476
 weglMapGrid1f(*un,*u1,*u2);
1540
 
}; break; 
1541
 
case 5185: { // glMapGrid2d 
 
1477
}; break;
 
1478
case 5185: { // glMapGrid2d
1542
1479
 GLint *un = (GLint *) bp; bp += 4;
1543
1480
 bp += 4;
1544
1481
 GLdouble *u1 = (GLdouble *) bp; bp += 8;
1548
1485
 GLdouble *v1 = (GLdouble *) bp; bp += 8;
1549
1486
 GLdouble *v2 = (GLdouble *) bp; bp += 8;
1550
1487
 weglMapGrid2d(*un,*u1,*u2,*vn,*v1,*v2);
1551
 
}; break; 
1552
 
case 5186: { // glMapGrid2f 
 
1488
}; break;
 
1489
case 5186: { // glMapGrid2f
1553
1490
 GLint *un = (GLint *) bp; bp += 4;
1554
1491
 GLfloat *u1 = (GLfloat *) bp; bp += 4;
1555
1492
 GLfloat *u2 = (GLfloat *) bp; bp += 4;
1557
1494
 GLfloat *v1 = (GLfloat *) bp; bp += 4;
1558
1495
 GLfloat *v2 = (GLfloat *) bp; bp += 4;
1559
1496
 weglMapGrid2f(*un,*u1,*u2,*vn,*v1,*v2);
1560
 
}; break; 
1561
 
case 5187: { // glMaterialf 
 
1497
}; break;
 
1498
case 5187: { // glMaterialf
1562
1499
 GLenum *face = (GLenum *) bp; bp += 4;
1563
1500
 GLenum *pname = (GLenum *) bp; bp += 4;
1564
1501
 GLfloat *param = (GLfloat *) bp; bp += 4;
1565
1502
 weglMaterialf(*face,*pname,*param);
1566
 
}; break; 
1567
 
case 5188: { // glMaterialfv 
 
1503
}; break;
 
1504
case 5188: { // glMaterialfv
1568
1505
 GLenum *face = (GLenum *) bp; bp += 4;
1569
1506
 GLenum *pname = (GLenum *) bp; bp += 4;
1570
1507
 int *paramsLen = (int *) bp; bp += 4;
1571
1508
 GLfloat *params = (GLfloat *) bp; bp += *paramsLen*4+((*paramsLen)+1)%2*4;
1572
1509
 weglMaterialfv(*face,*pname,params);
1573
 
}; break; 
1574
 
case 5189: { // glMateriali 
 
1510
}; break;
 
1511
case 5189: { // glMateriali
1575
1512
 GLenum *face = (GLenum *) bp; bp += 4;
1576
1513
 GLenum *pname = (GLenum *) bp; bp += 4;
1577
1514
 GLint *param = (GLint *) bp; bp += 4;
1578
1515
 weglMateriali(*face,*pname,*param);
1579
 
}; break; 
1580
 
case 5190: { // glMaterialiv 
 
1516
}; break;
 
1517
case 5190: { // glMaterialiv
1581
1518
 GLenum *face = (GLenum *) bp; bp += 4;
1582
1519
 GLenum *pname = (GLenum *) bp; bp += 4;
1583
1520
 int *paramsLen = (int *) bp; bp += 4;
1584
1521
 GLint *params = (GLint *) bp; bp += *paramsLen*4+((*paramsLen)+1)%2*4;
1585
1522
 weglMaterialiv(*face,*pname,params);
1586
 
}; break; 
1587
 
case 5191: { // glMatrixMode 
 
1523
}; break;
 
1524
case 5191: { // glMatrixMode
1588
1525
 GLenum *mode = (GLenum *) bp; bp += 4;
1589
1526
 weglMatrixMode(*mode);
1590
 
}; break; 
1591
 
case 5192: { // glMultMatrixd 
 
1527
}; break;
 
1528
case 5192: { // glMultMatrixd
1592
1529
 GLdouble * m = (GLdouble *) bp; bp += 128;
1593
1530
 weglMultMatrixd(m);
1594
 
}; break; 
1595
 
case 5193: { // glMultMatrixf 
 
1531
}; break;
 
1532
case 5193: { // glMultMatrixf
1596
1533
 GLfloat * m = (GLfloat *) bp; bp += 64;
1597
1534
 weglMultMatrixf(m);
1598
 
}; break; 
1599
 
case 5194: { // glNewList 
 
1535
}; break;
 
1536
case 5194: { // glNewList
1600
1537
 GLuint *list = (GLuint *) bp; bp += 4;
1601
1538
 GLenum *mode = (GLenum *) bp; bp += 4;
1602
1539
 weglNewList(*list,*mode);
1603
 
}; break; 
1604
 
case 5195: { // glNormal3bv 
 
1540
}; break;
 
1541
case 5195: { // glNormal3bv
1605
1542
 GLbyte *v = (GLbyte *) bp; bp += 1;
1606
1543
 weglNormal3bv(v);
1607
 
}; break; 
1608
 
case 5196: { // glNormal3dv 
 
1544
}; break;
 
1545
case 5196: { // glNormal3dv
1609
1546
 GLdouble *v = (GLdouble *) bp; bp += 8;
1610
1547
 weglNormal3dv(v);
1611
 
}; break; 
1612
 
case 5197: { // glNormal3fv 
 
1548
}; break;
 
1549
case 5197: { // glNormal3fv
1613
1550
 GLfloat *v = (GLfloat *) bp; bp += 4;
1614
1551
 weglNormal3fv(v);
1615
 
}; break; 
1616
 
case 5198: { // glNormal3iv 
 
1552
}; break;
 
1553
case 5198: { // glNormal3iv
1617
1554
 GLint *v = (GLint *) bp; bp += 4;
1618
1555
 weglNormal3iv(v);
1619
 
}; break; 
1620
 
case 5199: { // glNormal3sv 
 
1556
}; break;
 
1557
case 5199: { // glNormal3sv
1621
1558
 GLshort *v = (GLshort *) bp; bp += 2;
1622
1559
 weglNormal3sv(v);
1623
 
}; break; 
1624
 
case 5200: { // glNormalPointer 
 
1560
}; break;
 
1561
case 5200: { // glNormalPointer
1625
1562
 GLenum *type = (GLenum *) bp; bp += 4;
1626
1563
 GLsizei *stride = (GLsizei *) bp; bp += 4;
1627
1564
 GLvoid *pointer = (GLvoid *) * (int *) bp; bp += 4;
1628
1565
 weglNormalPointer(*type,*stride,pointer);
1629
 
}; break; 
1630
 
case 5201: { // glNormalPointer 
 
1566
}; break;
 
1567
case 5201: { // glNormalPointer
1631
1568
 GLenum *type = (GLenum *) bp; bp += 4;
1632
1569
 GLsizei *stride = (GLsizei *) bp; bp += 4;
1633
 
 GLvoid *pointer = (GLvoid *) bins[0]->base;
 
1570
 GLvoid *pointer = (GLvoid *) bins[0];
1634
1571
 weglNormalPointer(*type,*stride,pointer);
1635
 
}; break; 
1636
 
case 5202: { // glOrtho 
 
1572
}; break;
 
1573
case 5202: { // glOrtho
1637
1574
 GLdouble *left = (GLdouble *) bp; bp += 8;
1638
1575
 GLdouble *right = (GLdouble *) bp; bp += 8;
1639
1576
 GLdouble *bottom = (GLdouble *) bp; bp += 8;
1641
1578
 GLdouble *zNear = (GLdouble *) bp; bp += 8;
1642
1579
 GLdouble *zFar = (GLdouble *) bp; bp += 8;
1643
1580
 weglOrtho(*left,*right,*bottom,*top,*zNear,*zFar);
1644
 
}; break; 
1645
 
case 5203: { // glPassThrough 
 
1581
}; break;
 
1582
case 5203: { // glPassThrough
1646
1583
 GLfloat *token = (GLfloat *) bp; bp += 4;
1647
1584
 weglPassThrough(*token);
1648
 
}; break; 
1649
 
case 5204: { // glPixelMapfv 
 
1585
}; break;
 
1586
case 5204: { // glPixelMapfv
1650
1587
 GLenum *map = (GLenum *) bp; bp += 4;
1651
1588
 GLsizei *mapsize = (GLsizei *) bp; bp += 4;
1652
 
 GLfloat *values = (GLfloat *) bins[0]->base;
 
1589
 GLfloat *values = (GLfloat *) bins[0];
1653
1590
 weglPixelMapfv(*map,*mapsize,values);
1654
 
}; break; 
1655
 
case 5205: { // glPixelMapuiv 
 
1591
}; break;
 
1592
case 5205: { // glPixelMapuiv
1656
1593
 GLenum *map = (GLenum *) bp; bp += 4;
1657
1594
 GLsizei *mapsize = (GLsizei *) bp; bp += 4;
1658
 
 GLuint *values = (GLuint *) bins[0]->base;
 
1595
 GLuint *values = (GLuint *) bins[0];
1659
1596
 weglPixelMapuiv(*map,*mapsize,values);
1660
 
}; break; 
1661
 
case 5206: { // glPixelMapusv 
 
1597
}; break;
 
1598
case 5206: { // glPixelMapusv
1662
1599
 GLenum *map = (GLenum *) bp; bp += 4;
1663
1600
 GLsizei *mapsize = (GLsizei *) bp; bp += 4;
1664
 
 GLushort *values = (GLushort *) bins[0]->base;
 
1601
 GLushort *values = (GLushort *) bins[0];
1665
1602
 weglPixelMapusv(*map,*mapsize,values);
1666
 
}; break; 
1667
 
case 5207: { // glPixelStoref 
 
1603
}; break;
 
1604
case 5207: { // glPixelStoref
1668
1605
 GLenum *pname = (GLenum *) bp; bp += 4;
1669
1606
 GLfloat *param = (GLfloat *) bp; bp += 4;
1670
1607
 weglPixelStoref(*pname,*param);
1671
 
}; break; 
1672
 
case 5208: { // glPixelStorei 
 
1608
}; break;
 
1609
case 5208: { // glPixelStorei
1673
1610
 GLenum *pname = (GLenum *) bp; bp += 4;
1674
1611
 GLint *param = (GLint *) bp; bp += 4;
1675
1612
 weglPixelStorei(*pname,*param);
1676
 
}; break; 
1677
 
case 5209: { // glPixelTransferf 
 
1613
}; break;
 
1614
case 5209: { // glPixelTransferf
1678
1615
 GLenum *pname = (GLenum *) bp; bp += 4;
1679
1616
 GLfloat *param = (GLfloat *) bp; bp += 4;
1680
1617
 weglPixelTransferf(*pname,*param);
1681
 
}; break; 
1682
 
case 5210: { // glPixelTransferi 
 
1618
}; break;
 
1619
case 5210: { // glPixelTransferi
1683
1620
 GLenum *pname = (GLenum *) bp; bp += 4;
1684
1621
 GLint *param = (GLint *) bp; bp += 4;
1685
1622
 weglPixelTransferi(*pname,*param);
1686
 
}; break; 
1687
 
case 5211: { // glPixelZoom 
 
1623
}; break;
 
1624
case 5211: { // glPixelZoom
1688
1625
 GLfloat *xfactor = (GLfloat *) bp; bp += 4;
1689
1626
 GLfloat *yfactor = (GLfloat *) bp; bp += 4;
1690
1627
 weglPixelZoom(*xfactor,*yfactor);
1691
 
}; break; 
1692
 
case 5212: { // glPointSize 
 
1628
}; break;
 
1629
case 5212: { // glPointSize
1693
1630
 GLfloat *size = (GLfloat *) bp; bp += 4;
1694
1631
 weglPointSize(*size);
1695
 
}; break; 
1696
 
case 5213: { // glPolygonMode 
 
1632
}; break;
 
1633
case 5213: { // glPolygonMode
1697
1634
 GLenum *face = (GLenum *) bp; bp += 4;
1698
1635
 GLenum *mode = (GLenum *) bp; bp += 4;
1699
1636
 weglPolygonMode(*face,*mode);
1700
 
}; break; 
1701
 
case 5214: { // glPolygonOffset 
 
1637
}; break;
 
1638
case 5214: { // glPolygonOffset
1702
1639
 GLfloat *factor = (GLfloat *) bp; bp += 4;
1703
1640
 GLfloat *units = (GLfloat *) bp; bp += 4;
1704
1641
 weglPolygonOffset(*factor,*units);
1705
 
}; break; 
1706
 
case 5215: { // glPolygonStipple 
1707
 
 GLubyte *mask = (GLubyte *) bins[0]->base;
 
1642
}; break;
 
1643
case 5215: { // glPolygonStipple
 
1644
 GLubyte *mask = (GLubyte *) bins[0];
1708
1645
 weglPolygonStipple(mask);
1709
 
}; break; 
1710
 
case 5216: { // glPopAttrib 
 
1646
}; break;
 
1647
case 5216: { // glPopAttrib
1711
1648
 weglPopAttrib();
1712
 
}; break; 
1713
 
case 5217: { // glPopClientAttrib 
 
1649
}; break;
 
1650
case 5217: { // glPopClientAttrib
1714
1651
 weglPopClientAttrib();
1715
 
}; break; 
1716
 
case 5218: { // glPopMatrix 
 
1652
}; break;
 
1653
case 5218: { // glPopMatrix
1717
1654
 weglPopMatrix();
1718
 
}; break; 
1719
 
case 5219: { // glPopName 
 
1655
}; break;
 
1656
case 5219: { // glPopName
1720
1657
 weglPopName();
1721
 
}; break; 
1722
 
case 5220: { // glPrioritizeTextures 
 
1658
}; break;
 
1659
case 5220: { // glPrioritizeTextures
1723
1660
 int * texturesLen = (int *) bp; bp += 4;
1724
1661
 GLuint * textures = (GLuint *) bp;  bp += (8-((*texturesLen*4+4)%8))%8;
1725
1662
 int * prioritiesLen = (int *) bp; bp += 4;
1726
1663
 GLclampf * priorities = (GLclampf *) bp;  bp += (8-((*prioritiesLen*4+4)%8))%8;
1727
1664
 weglPrioritizeTextures(*texturesLen,textures,priorities);
1728
 
}; break; 
1729
 
case 5221: { // glPushAttrib 
 
1665
}; break;
 
1666
case 5221: { // glPushAttrib
1730
1667
 GLbitfield *mask = (GLbitfield *) bp; bp += 4;
1731
1668
 weglPushAttrib(*mask);
1732
 
}; break; 
1733
 
case 5222: { // glPushClientAttrib 
 
1669
}; break;
 
1670
case 5222: { // glPushClientAttrib
1734
1671
 GLbitfield *mask = (GLbitfield *) bp; bp += 4;
1735
1672
 weglPushClientAttrib(*mask);
1736
 
}; break; 
1737
 
case 5223: { // glPushMatrix 
 
1673
}; break;
 
1674
case 5223: { // glPushMatrix
1738
1675
 weglPushMatrix();
1739
 
}; break; 
1740
 
case 5224: { // glPushName 
 
1676
}; break;
 
1677
case 5224: { // glPushName
1741
1678
 GLuint *name = (GLuint *) bp; bp += 4;
1742
1679
 weglPushName(*name);
1743
 
}; break; 
1744
 
case 5225: { // glRasterPos2dv 
 
1680
}; break;
 
1681
case 5225: { // glRasterPos2dv
1745
1682
 GLdouble *v = (GLdouble *) bp; bp += 8;
1746
1683
 weglRasterPos2dv(v);
1747
 
}; break; 
1748
 
case 5226: { // glRasterPos2fv 
 
1684
}; break;
 
1685
case 5226: { // glRasterPos2fv
1749
1686
 GLfloat *v = (GLfloat *) bp; bp += 4;
1750
1687
 weglRasterPos2fv(v);
1751
 
}; break; 
1752
 
case 5227: { // glRasterPos2iv 
 
1688
}; break;
 
1689
case 5227: { // glRasterPos2iv
1753
1690
 GLint *v = (GLint *) bp; bp += 4;
1754
1691
 weglRasterPos2iv(v);
1755
 
}; break; 
1756
 
case 5228: { // glRasterPos2sv 
 
1692
}; break;
 
1693
case 5228: { // glRasterPos2sv
1757
1694
 GLshort *v = (GLshort *) bp; bp += 2;
1758
1695
 weglRasterPos2sv(v);
1759
 
}; break; 
1760
 
case 5229: { // glRasterPos3dv 
 
1696
}; break;
 
1697
case 5229: { // glRasterPos3dv
1761
1698
 GLdouble *v = (GLdouble *) bp; bp += 8;
1762
1699
 weglRasterPos3dv(v);
1763
 
}; break; 
1764
 
case 5230: { // glRasterPos3fv 
 
1700
}; break;
 
1701
case 5230: { // glRasterPos3fv
1765
1702
 GLfloat *v = (GLfloat *) bp; bp += 4;
1766
1703
 weglRasterPos3fv(v);
1767
 
}; break; 
1768
 
case 5231: { // glRasterPos3iv 
 
1704
}; break;
 
1705
case 5231: { // glRasterPos3iv
1769
1706
 GLint *v = (GLint *) bp; bp += 4;
1770
1707
 weglRasterPos3iv(v);
1771
 
}; break; 
1772
 
case 5232: { // glRasterPos3sv 
 
1708
}; break;
 
1709
case 5232: { // glRasterPos3sv
1773
1710
 GLshort *v = (GLshort *) bp; bp += 2;
1774
1711
 weglRasterPos3sv(v);
1775
 
}; break; 
1776
 
case 5233: { // glRasterPos4dv 
 
1712
}; break;
 
1713
case 5233: { // glRasterPos4dv
1777
1714
 GLdouble *v = (GLdouble *) bp; bp += 8;
1778
1715
 weglRasterPos4dv(v);
1779
 
}; break; 
1780
 
case 5234: { // glRasterPos4fv 
 
1716
}; break;
 
1717
case 5234: { // glRasterPos4fv
1781
1718
 GLfloat *v = (GLfloat *) bp; bp += 4;
1782
1719
 weglRasterPos4fv(v);
1783
 
}; break; 
1784
 
case 5235: { // glRasterPos4iv 
 
1720
}; break;
 
1721
case 5235: { // glRasterPos4iv
1785
1722
 GLint *v = (GLint *) bp; bp += 4;
1786
1723
 weglRasterPos4iv(v);
1787
 
}; break; 
1788
 
case 5236: { // glRasterPos4sv 
 
1724
}; break;
 
1725
case 5236: { // glRasterPos4sv
1789
1726
 GLshort *v = (GLshort *) bp; bp += 2;
1790
1727
 weglRasterPos4sv(v);
1791
 
}; break; 
1792
 
case 5237: { // glReadBuffer 
 
1728
}; break;
 
1729
case 5237: { // glReadBuffer
1793
1730
 GLenum *mode = (GLenum *) bp; bp += 4;
1794
1731
 weglReadBuffer(*mode);
1795
 
}; break; 
1796
 
case 5238: { // glReadPixels 
 
1732
}; break;
 
1733
case 5238: { // glReadPixels
1797
1734
 GLint *x = (GLint *) bp; bp += 4;
1798
1735
 GLint *y = (GLint *) bp; bp += 4;
1799
1736
 GLsizei *width = (GLsizei *) bp; bp += 4;
1800
1737
 GLsizei *height = (GLsizei *) bp; bp += 4;
1801
1738
 GLenum *format = (GLenum *) bp; bp += 4;
1802
1739
 GLenum *type = (GLenum *) bp; bp += 4;
1803
 
 GLvoid *pixels = (GLvoid *) bins[0]->base;
 
1740
 GLvoid *pixels = (GLvoid *) bins[0];
1804
1741
 weglReadPixels(*x,*y,*width,*height,*format,*type,pixels);
1805
1742
 int AP = 0; ErlDrvTermData rt[6];
1806
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1743
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1807
1744
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
1808
1745
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1809
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1810
 
}; break; 
1811
 
case 5239: { // glRectd 
 
1746
 driver_send_term(port,caller,rt,AP);
 
1747
}; break;
 
1748
case 5239: { // glRectd
1812
1749
 GLdouble *x1 = (GLdouble *) bp; bp += 8;
1813
1750
 GLdouble *y1 = (GLdouble *) bp; bp += 8;
1814
1751
 GLdouble *x2 = (GLdouble *) bp; bp += 8;
1815
1752
 GLdouble *y2 = (GLdouble *) bp; bp += 8;
1816
1753
 weglRectd(*x1,*y1,*x2,*y2);
1817
 
}; break; 
1818
 
case 5240: { // glRectdv 
 
1754
}; break;
 
1755
case 5240: { // glRectdv
1819
1756
 GLdouble * v1 = (GLdouble *) bp; bp += 16;
1820
1757
 GLdouble * v2 = (GLdouble *) bp; bp += 16;
1821
1758
 weglRectdv(v1,v2);
1822
 
}; break; 
1823
 
case 5241: { // glRectf 
 
1759
}; break;
 
1760
case 5241: { // glRectf
1824
1761
 GLfloat *x1 = (GLfloat *) bp; bp += 4;
1825
1762
 GLfloat *y1 = (GLfloat *) bp; bp += 4;
1826
1763
 GLfloat *x2 = (GLfloat *) bp; bp += 4;
1827
1764
 GLfloat *y2 = (GLfloat *) bp; bp += 4;
1828
1765
 weglRectf(*x1,*y1,*x2,*y2);
1829
 
}; break; 
1830
 
case 5242: { // glRectfv 
 
1766
}; break;
 
1767
case 5242: { // glRectfv
1831
1768
 GLfloat * v1 = (GLfloat *) bp; bp += 8;
1832
1769
 GLfloat * v2 = (GLfloat *) bp; bp += 8;
1833
1770
 weglRectfv(v1,v2);
1834
 
}; break; 
1835
 
case 5243: { // glRecti 
 
1771
}; break;
 
1772
case 5243: { // glRecti
1836
1773
 GLint *x1 = (GLint *) bp; bp += 4;
1837
1774
 GLint *y1 = (GLint *) bp; bp += 4;
1838
1775
 GLint *x2 = (GLint *) bp; bp += 4;
1839
1776
 GLint *y2 = (GLint *) bp; bp += 4;
1840
1777
 weglRecti(*x1,*y1,*x2,*y2);
1841
 
}; break; 
1842
 
case 5244: { // glRectiv 
 
1778
}; break;
 
1779
case 5244: { // glRectiv
1843
1780
 GLint * v1 = (GLint *) bp; bp += 8;
1844
1781
 GLint * v2 = (GLint *) bp; bp += 8;
1845
1782
 weglRectiv(v1,v2);
1846
 
}; break; 
1847
 
case 5245: { // glRects 
 
1783
}; break;
 
1784
case 5245: { // glRects
1848
1785
 GLshort *x1 = (GLshort *) bp; bp += 2;
1849
1786
 GLshort *y1 = (GLshort *) bp; bp += 2;
1850
1787
 GLshort *x2 = (GLshort *) bp; bp += 2;
1851
1788
 GLshort *y2 = (GLshort *) bp; bp += 2;
1852
1789
 weglRects(*x1,*y1,*x2,*y2);
1853
 
}; break; 
1854
 
case 5246: { // glRectsv 
 
1790
}; break;
 
1791
case 5246: { // glRectsv
1855
1792
 GLshort * v1 = (GLshort *) bp; bp += 4;
1856
1793
 GLshort * v2 = (GLshort *) bp; bp += 4;
1857
1794
 weglRectsv(v1,v2);
1858
 
}; break; 
1859
 
case 5247: { // glRenderMode 
 
1795
}; break;
 
1796
case 5247: { // glRenderMode
1860
1797
 GLenum *mode = (GLenum *) bp; bp += 4;
1861
1798
 GLint result = weglRenderMode(*mode);
1862
1799
 int AP = 0; ErlDrvTermData rt[6];
1863
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1800
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1864
1801
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
1865
1802
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1866
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
1867
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1868
 
}; break; 
1869
 
case 5248: { // glRotated 
 
1803
 driver_send_term(port,caller,rt,AP);
 
1804
}; break;
 
1805
case 5248: { // glRotated
1870
1806
 GLdouble *angle = (GLdouble *) bp; bp += 8;
1871
1807
 GLdouble *x = (GLdouble *) bp; bp += 8;
1872
1808
 GLdouble *y = (GLdouble *) bp; bp += 8;
1873
1809
 GLdouble *z = (GLdouble *) bp; bp += 8;
1874
1810
 weglRotated(*angle,*x,*y,*z);
1875
 
}; break; 
1876
 
case 5249: { // glRotatef 
 
1811
}; break;
 
1812
case 5249: { // glRotatef
1877
1813
 GLfloat *angle = (GLfloat *) bp; bp += 4;
1878
1814
 GLfloat *x = (GLfloat *) bp; bp += 4;
1879
1815
 GLfloat *y = (GLfloat *) bp; bp += 4;
1880
1816
 GLfloat *z = (GLfloat *) bp; bp += 4;
1881
1817
 weglRotatef(*angle,*x,*y,*z);
1882
 
}; break; 
1883
 
case 5250: { // glScaled 
 
1818
}; break;
 
1819
case 5250: { // glScaled
1884
1820
 GLdouble *x = (GLdouble *) bp; bp += 8;
1885
1821
 GLdouble *y = (GLdouble *) bp; bp += 8;
1886
1822
 GLdouble *z = (GLdouble *) bp; bp += 8;
1887
1823
 weglScaled(*x,*y,*z);
1888
 
}; break; 
1889
 
case 5251: { // glScalef 
 
1824
}; break;
 
1825
case 5251: { // glScalef
1890
1826
 GLfloat *x = (GLfloat *) bp; bp += 4;
1891
1827
 GLfloat *y = (GLfloat *) bp; bp += 4;
1892
1828
 GLfloat *z = (GLfloat *) bp; bp += 4;
1893
1829
 weglScalef(*x,*y,*z);
1894
 
}; break; 
1895
 
case 5252: { // glScissor 
 
1830
}; break;
 
1831
case 5252: { // glScissor
1896
1832
 GLint *x = (GLint *) bp; bp += 4;
1897
1833
 GLint *y = (GLint *) bp; bp += 4;
1898
1834
 GLsizei *width = (GLsizei *) bp; bp += 4;
1899
1835
 GLsizei *height = (GLsizei *) bp; bp += 4;
1900
1836
 weglScissor(*x,*y,*width,*height);
1901
 
}; break; 
1902
 
case 5253: { // glSelectBuffer 
 
1837
}; break;
 
1838
case 5253: { // glSelectBuffer
1903
1839
 GLsizei *size = (GLsizei *) bp; bp += 4;
1904
 
 GLuint *buffer = (GLuint *) bins[0]->base;
 
1840
 GLuint *buffer = (GLuint *) bins[0];
1905
1841
 weglSelectBuffer(*size,buffer);
1906
1842
 int AP = 0; ErlDrvTermData rt[6];
1907
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
1843
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
1908
1844
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
1909
1845
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
1910
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
1911
 
}; break; 
1912
 
case 5254: { // glShadeModel 
 
1846
 driver_send_term(port,caller,rt,AP);
 
1847
}; break;
 
1848
case 5254: { // glShadeModel
1913
1849
 GLenum *mode = (GLenum *) bp; bp += 4;
1914
1850
 weglShadeModel(*mode);
1915
 
}; break; 
1916
 
case 5255: { // glStencilFunc 
 
1851
}; break;
 
1852
case 5255: { // glStencilFunc
1917
1853
 GLenum *func = (GLenum *) bp; bp += 4;
1918
1854
 GLint *ref = (GLint *) bp; bp += 4;
1919
1855
 GLuint *mask = (GLuint *) bp; bp += 4;
1920
1856
 weglStencilFunc(*func,*ref,*mask);
1921
 
}; break; 
1922
 
case 5256: { // glStencilMask 
 
1857
}; break;
 
1858
case 5256: { // glStencilMask
1923
1859
 GLuint *mask = (GLuint *) bp; bp += 4;
1924
1860
 weglStencilMask(*mask);
1925
 
}; break; 
1926
 
case 5257: { // glStencilOp 
 
1861
}; break;
 
1862
case 5257: { // glStencilOp
1927
1863
 GLenum *fail = (GLenum *) bp; bp += 4;
1928
1864
 GLenum *zfail = (GLenum *) bp; bp += 4;
1929
1865
 GLenum *zpass = (GLenum *) bp; bp += 4;
1930
1866
 weglStencilOp(*fail,*zfail,*zpass);
1931
 
}; break; 
1932
 
case 5258: { // glTexCoord1dv 
 
1867
}; break;
 
1868
case 5258: { // glTexCoord1dv
1933
1869
 GLdouble *v = (GLdouble *) bp; bp += 8;
1934
1870
 weglTexCoord1dv(v);
1935
 
}; break; 
1936
 
case 5259: { // glTexCoord1fv 
 
1871
}; break;
 
1872
case 5259: { // glTexCoord1fv
1937
1873
 GLfloat *v = (GLfloat *) bp; bp += 4;
1938
1874
 weglTexCoord1fv(v);
1939
 
}; break; 
1940
 
case 5260: { // glTexCoord1iv 
 
1875
}; break;
 
1876
case 5260: { // glTexCoord1iv
1941
1877
 GLint *v = (GLint *) bp; bp += 4;
1942
1878
 weglTexCoord1iv(v);
1943
 
}; break; 
1944
 
case 5261: { // glTexCoord1sv 
 
1879
}; break;
 
1880
case 5261: { // glTexCoord1sv
1945
1881
 GLshort *v = (GLshort *) bp; bp += 2;
1946
1882
 weglTexCoord1sv(v);
1947
 
}; break; 
1948
 
case 5262: { // glTexCoord2dv 
 
1883
}; break;
 
1884
case 5262: { // glTexCoord2dv
1949
1885
 GLdouble *v = (GLdouble *) bp; bp += 8;
1950
1886
 weglTexCoord2dv(v);
1951
 
}; break; 
1952
 
case 5263: { // glTexCoord2fv 
 
1887
}; break;
 
1888
case 5263: { // glTexCoord2fv
1953
1889
 GLfloat *v = (GLfloat *) bp; bp += 4;
1954
1890
 weglTexCoord2fv(v);
1955
 
}; break; 
1956
 
case 5264: { // glTexCoord2iv 
 
1891
}; break;
 
1892
case 5264: { // glTexCoord2iv
1957
1893
 GLint *v = (GLint *) bp; bp += 4;
1958
1894
 weglTexCoord2iv(v);
1959
 
}; break; 
1960
 
case 5265: { // glTexCoord2sv 
 
1895
}; break;
 
1896
case 5265: { // glTexCoord2sv
1961
1897
 GLshort *v = (GLshort *) bp; bp += 2;
1962
1898
 weglTexCoord2sv(v);
1963
 
}; break; 
1964
 
case 5266: { // glTexCoord3dv 
 
1899
}; break;
 
1900
case 5266: { // glTexCoord3dv
1965
1901
 GLdouble *v = (GLdouble *) bp; bp += 8;
1966
1902
 weglTexCoord3dv(v);
1967
 
}; break; 
1968
 
case 5267: { // glTexCoord3fv 
 
1903
}; break;
 
1904
case 5267: { // glTexCoord3fv
1969
1905
 GLfloat *v = (GLfloat *) bp; bp += 4;
1970
1906
 weglTexCoord3fv(v);
1971
 
}; break; 
1972
 
case 5268: { // glTexCoord3iv 
 
1907
}; break;
 
1908
case 5268: { // glTexCoord3iv
1973
1909
 GLint *v = (GLint *) bp; bp += 4;
1974
1910
 weglTexCoord3iv(v);
1975
 
}; break; 
1976
 
case 5269: { // glTexCoord3sv 
 
1911
}; break;
 
1912
case 5269: { // glTexCoord3sv
1977
1913
 GLshort *v = (GLshort *) bp; bp += 2;
1978
1914
 weglTexCoord3sv(v);
1979
 
}; break; 
1980
 
case 5270: { // glTexCoord4dv 
 
1915
}; break;
 
1916
case 5270: { // glTexCoord4dv
1981
1917
 GLdouble *v = (GLdouble *) bp; bp += 8;
1982
1918
 weglTexCoord4dv(v);
1983
 
}; break; 
1984
 
case 5271: { // glTexCoord4fv 
 
1919
}; break;
 
1920
case 5271: { // glTexCoord4fv
1985
1921
 GLfloat *v = (GLfloat *) bp; bp += 4;
1986
1922
 weglTexCoord4fv(v);
1987
 
}; break; 
1988
 
case 5272: { // glTexCoord4iv 
 
1923
}; break;
 
1924
case 5272: { // glTexCoord4iv
1989
1925
 GLint *v = (GLint *) bp; bp += 4;
1990
1926
 weglTexCoord4iv(v);
1991
 
}; break; 
1992
 
case 5273: { // glTexCoord4sv 
 
1927
}; break;
 
1928
case 5273: { // glTexCoord4sv
1993
1929
 GLshort *v = (GLshort *) bp; bp += 2;
1994
1930
 weglTexCoord4sv(v);
1995
 
}; break; 
1996
 
case 5274: { // glTexCoordPointer 
 
1931
}; break;
 
1932
case 5274: { // glTexCoordPointer
1997
1933
 GLint *size = (GLint *) bp; bp += 4;
1998
1934
 GLenum *type = (GLenum *) bp; bp += 4;
1999
1935
 GLsizei *stride = (GLsizei *) bp; bp += 4;
2000
1936
 GLvoid *pointer = (GLvoid *) * (int *) bp; bp += 4;
2001
1937
 weglTexCoordPointer(*size,*type,*stride,pointer);
2002
 
}; break; 
2003
 
case 5275: { // glTexCoordPointer 
 
1938
}; break;
 
1939
case 5275: { // glTexCoordPointer
2004
1940
 GLint *size = (GLint *) bp; bp += 4;
2005
1941
 GLenum *type = (GLenum *) bp; bp += 4;
2006
1942
 GLsizei *stride = (GLsizei *) bp; bp += 4;
2007
 
 GLvoid *pointer = (GLvoid *) bins[0]->base;
 
1943
 GLvoid *pointer = (GLvoid *) bins[0];
2008
1944
 weglTexCoordPointer(*size,*type,*stride,pointer);
2009
 
}; break; 
2010
 
case 5276: { // glTexEnvf 
 
1945
}; break;
 
1946
case 5276: { // glTexEnvf
2011
1947
 GLenum *target = (GLenum *) bp; bp += 4;
2012
1948
 GLenum *pname = (GLenum *) bp; bp += 4;
2013
1949
 GLfloat *param = (GLfloat *) bp; bp += 4;
2014
1950
 weglTexEnvf(*target,*pname,*param);
2015
 
}; break; 
2016
 
case 5277: { // glTexEnvfv 
 
1951
}; break;
 
1952
case 5277: { // glTexEnvfv
2017
1953
 GLenum *target = (GLenum *) bp; bp += 4;
2018
1954
 GLenum *pname = (GLenum *) bp; bp += 4;
2019
1955
 int *paramsLen = (int *) bp; bp += 4;
2020
1956
 GLfloat *params = (GLfloat *) bp; bp += *paramsLen*4+((*paramsLen)+1)%2*4;
2021
1957
 weglTexEnvfv(*target,*pname,params);
2022
 
}; break; 
2023
 
case 5278: { // glTexEnvi 
 
1958
}; break;
 
1959
case 5278: { // glTexEnvi
2024
1960
 GLenum *target = (GLenum *) bp; bp += 4;
2025
1961
 GLenum *pname = (GLenum *) bp; bp += 4;
2026
1962
 GLint *param = (GLint *) bp; bp += 4;
2027
1963
 weglTexEnvi(*target,*pname,*param);
2028
 
}; break; 
2029
 
case 5279: { // glTexEnviv 
 
1964
}; break;
 
1965
case 5279: { // glTexEnviv
2030
1966
 GLenum *target = (GLenum *) bp; bp += 4;
2031
1967
 GLenum *pname = (GLenum *) bp; bp += 4;
2032
1968
 int *paramsLen = (int *) bp; bp += 4;
2033
1969
 GLint *params = (GLint *) bp; bp += *paramsLen*4+((*paramsLen)+1)%2*4;
2034
1970
 weglTexEnviv(*target,*pname,params);
2035
 
}; break; 
2036
 
case 5280: { // glTexGend 
 
1971
}; break;
 
1972
case 5280: { // glTexGend
2037
1973
 GLenum *coord = (GLenum *) bp; bp += 4;
2038
1974
 GLenum *pname = (GLenum *) bp; bp += 4;
2039
1975
 GLdouble *param = (GLdouble *) bp; bp += 8;
2040
1976
 weglTexGend(*coord,*pname,*param);
2041
 
}; break; 
2042
 
case 5281: { // glTexGendv 
 
1977
}; break;
 
1978
case 5281: { // glTexGendv
2043
1979
 GLenum *coord = (GLenum *) bp; bp += 4;
2044
1980
 GLenum *pname = (GLenum *) bp; bp += 4;
2045
1981
 int *paramsLen = (int *) bp; bp += 8;
2046
1982
 GLdouble *params = (GLdouble *) bp; bp += *paramsLen*8;
2047
1983
 weglTexGendv(*coord,*pname,params);
2048
 
}; break; 
2049
 
case 5282: { // glTexGenf 
 
1984
}; break;
 
1985
case 5282: { // glTexGenf
2050
1986
 GLenum *coord = (GLenum *) bp; bp += 4;
2051
1987
 GLenum *pname = (GLenum *) bp; bp += 4;
2052
1988
 GLfloat *param = (GLfloat *) bp; bp += 4;
2053
1989
 weglTexGenf(*coord,*pname,*param);
2054
 
}; break; 
2055
 
case 5283: { // glTexGenfv 
 
1990
}; break;
 
1991
case 5283: { // glTexGenfv
2056
1992
 GLenum *coord = (GLenum *) bp; bp += 4;
2057
1993
 GLenum *pname = (GLenum *) bp; bp += 4;
2058
1994
 int *paramsLen = (int *) bp; bp += 4;
2059
1995
 GLfloat *params = (GLfloat *) bp; bp += *paramsLen*4+((*paramsLen)+1)%2*4;
2060
1996
 weglTexGenfv(*coord,*pname,params);
2061
 
}; break; 
2062
 
case 5284: { // glTexGeni 
 
1997
}; break;
 
1998
case 5284: { // glTexGeni
2063
1999
 GLenum *coord = (GLenum *) bp; bp += 4;
2064
2000
 GLenum *pname = (GLenum *) bp; bp += 4;
2065
2001
 GLint *param = (GLint *) bp; bp += 4;
2066
2002
 weglTexGeni(*coord,*pname,*param);
2067
 
}; break; 
2068
 
case 5285: { // glTexGeniv 
 
2003
}; break;
 
2004
case 5285: { // glTexGeniv
2069
2005
 GLenum *coord = (GLenum *) bp; bp += 4;
2070
2006
 GLenum *pname = (GLenum *) bp; bp += 4;
2071
2007
 int *paramsLen = (int *) bp; bp += 4;
2072
2008
 GLint *params = (GLint *) bp; bp += *paramsLen*4+((*paramsLen)+1)%2*4;
2073
2009
 weglTexGeniv(*coord,*pname,params);
2074
 
}; break; 
2075
 
case 5286: { // glTexImage1D 
2076
 
 GLenum *target = (GLenum *) bp; bp += 4;
2077
 
 GLint *level = (GLint *) bp; bp += 4;
2078
 
 GLint *internalformat = (GLint *) bp; bp += 4;
2079
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2080
 
 GLint *border = (GLint *) bp; bp += 4;
2081
 
 GLenum *format = (GLenum *) bp; bp += 4;
2082
 
 GLenum *type = (GLenum *) bp; bp += 4;
2083
 
 GLvoid *pixels = (GLvoid *) * (int *) bp; bp += 4;
2084
 
 weglTexImage1D(*target,*level,*internalformat,*width,*border,*format,*type,pixels);
2085
 
}; break; 
2086
 
case 5287: { // glTexImage1D 
2087
 
 GLenum *target = (GLenum *) bp; bp += 4;
2088
 
 GLint *level = (GLint *) bp; bp += 4;
2089
 
 GLint *internalformat = (GLint *) bp; bp += 4;
2090
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2091
 
 GLint *border = (GLint *) bp; bp += 4;
2092
 
 GLenum *format = (GLenum *) bp; bp += 4;
2093
 
 GLenum *type = (GLenum *) bp; bp += 4;
2094
 
 GLvoid *pixels = (GLvoid *) bins[0]->base;
2095
 
 weglTexImage1D(*target,*level,*internalformat,*width,*border,*format,*type,pixels);
2096
 
}; break; 
2097
 
case 5288: { // glTexImage2D 
2098
 
 GLenum *target = (GLenum *) bp; bp += 4;
2099
 
 GLint *level = (GLint *) bp; bp += 4;
2100
 
 GLint *internalformat = (GLint *) bp; bp += 4;
2101
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2102
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2103
 
 GLint *border = (GLint *) bp; bp += 4;
2104
 
 GLenum *format = (GLenum *) bp; bp += 4;
2105
 
 GLenum *type = (GLenum *) bp; bp += 4;
2106
 
 GLvoid *pixels = (GLvoid *) * (int *) bp; bp += 4;
2107
 
 weglTexImage2D(*target,*level,*internalformat,*width,*height,*border,*format,*type,pixels);
2108
 
}; break; 
2109
 
case 5289: { // glTexImage2D 
2110
 
 GLenum *target = (GLenum *) bp; bp += 4;
2111
 
 GLint *level = (GLint *) bp; bp += 4;
2112
 
 GLint *internalformat = (GLint *) bp; bp += 4;
2113
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2114
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2115
 
 GLint *border = (GLint *) bp; bp += 4;
2116
 
 GLenum *format = (GLenum *) bp; bp += 4;
2117
 
 GLenum *type = (GLenum *) bp; bp += 4;
2118
 
 GLvoid *pixels = (GLvoid *) bins[0]->base;
2119
 
 weglTexImage2D(*target,*level,*internalformat,*width,*height,*border,*format,*type,pixels);
2120
 
}; break; 
2121
 
case 5290: { // glTexParameterf 
 
2010
}; break;
 
2011
case 5286: { // glTexImage1D
 
2012
 GLenum *target = (GLenum *) bp; bp += 4;
 
2013
 GLint *level = (GLint *) bp; bp += 4;
 
2014
 GLint *internalformat = (GLint *) bp; bp += 4;
 
2015
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2016
 GLint *border = (GLint *) bp; bp += 4;
 
2017
 GLenum *format = (GLenum *) bp; bp += 4;
 
2018
 GLenum *type = (GLenum *) bp; bp += 4;
 
2019
 GLvoid *pixels = (GLvoid *) * (int *) bp; bp += 4;
 
2020
 weglTexImage1D(*target,*level,*internalformat,*width,*border,*format,*type,pixels);
 
2021
}; break;
 
2022
case 5287: { // glTexImage1D
 
2023
 GLenum *target = (GLenum *) bp; bp += 4;
 
2024
 GLint *level = (GLint *) bp; bp += 4;
 
2025
 GLint *internalformat = (GLint *) bp; bp += 4;
 
2026
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2027
 GLint *border = (GLint *) bp; bp += 4;
 
2028
 GLenum *format = (GLenum *) bp; bp += 4;
 
2029
 GLenum *type = (GLenum *) bp; bp += 4;
 
2030
 GLvoid *pixels = (GLvoid *) bins[0];
 
2031
 weglTexImage1D(*target,*level,*internalformat,*width,*border,*format,*type,pixels);
 
2032
}; break;
 
2033
case 5288: { // glTexImage2D
 
2034
 GLenum *target = (GLenum *) bp; bp += 4;
 
2035
 GLint *level = (GLint *) bp; bp += 4;
 
2036
 GLint *internalformat = (GLint *) bp; bp += 4;
 
2037
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2038
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2039
 GLint *border = (GLint *) bp; bp += 4;
 
2040
 GLenum *format = (GLenum *) bp; bp += 4;
 
2041
 GLenum *type = (GLenum *) bp; bp += 4;
 
2042
 GLvoid *pixels = (GLvoid *) * (int *) bp; bp += 4;
 
2043
 weglTexImage2D(*target,*level,*internalformat,*width,*height,*border,*format,*type,pixels);
 
2044
}; break;
 
2045
case 5289: { // glTexImage2D
 
2046
 GLenum *target = (GLenum *) bp; bp += 4;
 
2047
 GLint *level = (GLint *) bp; bp += 4;
 
2048
 GLint *internalformat = (GLint *) bp; bp += 4;
 
2049
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2050
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2051
 GLint *border = (GLint *) bp; bp += 4;
 
2052
 GLenum *format = (GLenum *) bp; bp += 4;
 
2053
 GLenum *type = (GLenum *) bp; bp += 4;
 
2054
 GLvoid *pixels = (GLvoid *) bins[0];
 
2055
 weglTexImage2D(*target,*level,*internalformat,*width,*height,*border,*format,*type,pixels);
 
2056
}; break;
 
2057
case 5290: { // glTexParameterf
2122
2058
 GLenum *target = (GLenum *) bp; bp += 4;
2123
2059
 GLenum *pname = (GLenum *) bp; bp += 4;
2124
2060
 GLfloat *param = (GLfloat *) bp; bp += 4;
2125
2061
 weglTexParameterf(*target,*pname,*param);
2126
 
}; break; 
2127
 
case 5291: { // glTexParameterfv 
 
2062
}; break;
 
2063
case 5291: { // glTexParameterfv
2128
2064
 GLenum *target = (GLenum *) bp; bp += 4;
2129
2065
 GLenum *pname = (GLenum *) bp; bp += 4;
2130
2066
 int *paramsLen = (int *) bp; bp += 4;
2131
2067
 GLfloat *params = (GLfloat *) bp; bp += *paramsLen*4+((*paramsLen)+1)%2*4;
2132
2068
 weglTexParameterfv(*target,*pname,params);
2133
 
}; break; 
2134
 
case 5292: { // glTexParameteri 
 
2069
}; break;
 
2070
case 5292: { // glTexParameteri
2135
2071
 GLenum *target = (GLenum *) bp; bp += 4;
2136
2072
 GLenum *pname = (GLenum *) bp; bp += 4;
2137
2073
 GLint *param = (GLint *) bp; bp += 4;
2138
2074
 weglTexParameteri(*target,*pname,*param);
2139
 
}; break; 
2140
 
case 5293: { // glTexParameteriv 
 
2075
}; break;
 
2076
case 5293: { // glTexParameteriv
2141
2077
 GLenum *target = (GLenum *) bp; bp += 4;
2142
2078
 GLenum *pname = (GLenum *) bp; bp += 4;
2143
2079
 int *paramsLen = (int *) bp; bp += 4;
2144
2080
 GLint *params = (GLint *) bp; bp += *paramsLen*4+((*paramsLen)+1)%2*4;
2145
2081
 weglTexParameteriv(*target,*pname,params);
2146
 
}; break; 
2147
 
case 5294: { // glTexSubImage1D 
2148
 
 GLenum *target = (GLenum *) bp; bp += 4;
2149
 
 GLint *level = (GLint *) bp; bp += 4;
2150
 
 GLint *xoffset = (GLint *) bp; bp += 4;
2151
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2152
 
 GLenum *format = (GLenum *) bp; bp += 4;
2153
 
 GLenum *type = (GLenum *) bp; bp += 4;
2154
 
 GLvoid *pixels = (GLvoid *) * (int *) bp; bp += 4;
2155
 
 weglTexSubImage1D(*target,*level,*xoffset,*width,*format,*type,pixels);
2156
 
}; break; 
2157
 
case 5295: { // glTexSubImage1D 
2158
 
 GLenum *target = (GLenum *) bp; bp += 4;
2159
 
 GLint *level = (GLint *) bp; bp += 4;
2160
 
 GLint *xoffset = (GLint *) bp; bp += 4;
2161
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2162
 
 GLenum *format = (GLenum *) bp; bp += 4;
2163
 
 GLenum *type = (GLenum *) bp; bp += 4;
2164
 
 GLvoid *pixels = (GLvoid *) bins[0]->base;
2165
 
 weglTexSubImage1D(*target,*level,*xoffset,*width,*format,*type,pixels);
2166
 
}; break; 
2167
 
case 5296: { // glTexSubImage2D 
2168
 
 GLenum *target = (GLenum *) bp; bp += 4;
2169
 
 GLint *level = (GLint *) bp; bp += 4;
2170
 
 GLint *xoffset = (GLint *) bp; bp += 4;
2171
 
 GLint *yoffset = (GLint *) bp; bp += 4;
2172
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2173
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2174
 
 GLenum *format = (GLenum *) bp; bp += 4;
2175
 
 GLenum *type = (GLenum *) bp; bp += 4;
2176
 
 GLvoid *pixels = (GLvoid *) * (int *) bp; bp += 4;
2177
 
 weglTexSubImage2D(*target,*level,*xoffset,*yoffset,*width,*height,*format,*type,pixels);
2178
 
}; break; 
2179
 
case 5297: { // glTexSubImage2D 
2180
 
 GLenum *target = (GLenum *) bp; bp += 4;
2181
 
 GLint *level = (GLint *) bp; bp += 4;
2182
 
 GLint *xoffset = (GLint *) bp; bp += 4;
2183
 
 GLint *yoffset = (GLint *) bp; bp += 4;
2184
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2185
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2186
 
 GLenum *format = (GLenum *) bp; bp += 4;
2187
 
 GLenum *type = (GLenum *) bp; bp += 4;
2188
 
 GLvoid *pixels = (GLvoid *) bins[0]->base;
2189
 
 weglTexSubImage2D(*target,*level,*xoffset,*yoffset,*width,*height,*format,*type,pixels);
2190
 
}; break; 
2191
 
case 5298: { // glTranslated 
 
2082
}; break;
 
2083
case 5294: { // glTexSubImage1D
 
2084
 GLenum *target = (GLenum *) bp; bp += 4;
 
2085
 GLint *level = (GLint *) bp; bp += 4;
 
2086
 GLint *xoffset = (GLint *) bp; bp += 4;
 
2087
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2088
 GLenum *format = (GLenum *) bp; bp += 4;
 
2089
 GLenum *type = (GLenum *) bp; bp += 4;
 
2090
 GLvoid *pixels = (GLvoid *) * (int *) bp; bp += 4;
 
2091
 weglTexSubImage1D(*target,*level,*xoffset,*width,*format,*type,pixels);
 
2092
}; break;
 
2093
case 5295: { // glTexSubImage1D
 
2094
 GLenum *target = (GLenum *) bp; bp += 4;
 
2095
 GLint *level = (GLint *) bp; bp += 4;
 
2096
 GLint *xoffset = (GLint *) bp; bp += 4;
 
2097
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2098
 GLenum *format = (GLenum *) bp; bp += 4;
 
2099
 GLenum *type = (GLenum *) bp; bp += 4;
 
2100
 GLvoid *pixels = (GLvoid *) bins[0];
 
2101
 weglTexSubImage1D(*target,*level,*xoffset,*width,*format,*type,pixels);
 
2102
}; break;
 
2103
case 5296: { // glTexSubImage2D
 
2104
 GLenum *target = (GLenum *) bp; bp += 4;
 
2105
 GLint *level = (GLint *) bp; bp += 4;
 
2106
 GLint *xoffset = (GLint *) bp; bp += 4;
 
2107
 GLint *yoffset = (GLint *) bp; bp += 4;
 
2108
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2109
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2110
 GLenum *format = (GLenum *) bp; bp += 4;
 
2111
 GLenum *type = (GLenum *) bp; bp += 4;
 
2112
 GLvoid *pixels = (GLvoid *) * (int *) bp; bp += 4;
 
2113
 weglTexSubImage2D(*target,*level,*xoffset,*yoffset,*width,*height,*format,*type,pixels);
 
2114
}; break;
 
2115
case 5297: { // glTexSubImage2D
 
2116
 GLenum *target = (GLenum *) bp; bp += 4;
 
2117
 GLint *level = (GLint *) bp; bp += 4;
 
2118
 GLint *xoffset = (GLint *) bp; bp += 4;
 
2119
 GLint *yoffset = (GLint *) bp; bp += 4;
 
2120
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2121
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2122
 GLenum *format = (GLenum *) bp; bp += 4;
 
2123
 GLenum *type = (GLenum *) bp; bp += 4;
 
2124
 GLvoid *pixels = (GLvoid *) bins[0];
 
2125
 weglTexSubImage2D(*target,*level,*xoffset,*yoffset,*width,*height,*format,*type,pixels);
 
2126
}; break;
 
2127
case 5298: { // glTranslated
2192
2128
 GLdouble *x = (GLdouble *) bp; bp += 8;
2193
2129
 GLdouble *y = (GLdouble *) bp; bp += 8;
2194
2130
 GLdouble *z = (GLdouble *) bp; bp += 8;
2195
2131
 weglTranslated(*x,*y,*z);
2196
 
}; break; 
2197
 
case 5299: { // glTranslatef 
 
2132
}; break;
 
2133
case 5299: { // glTranslatef
2198
2134
 GLfloat *x = (GLfloat *) bp; bp += 4;
2199
2135
 GLfloat *y = (GLfloat *) bp; bp += 4;
2200
2136
 GLfloat *z = (GLfloat *) bp; bp += 4;
2201
2137
 weglTranslatef(*x,*y,*z);
2202
 
}; break; 
2203
 
case 5300: { // glVertex2dv 
 
2138
}; break;
 
2139
case 5300: { // glVertex2dv
2204
2140
 GLdouble *v = (GLdouble *) bp; bp += 8;
2205
2141
 weglVertex2dv(v);
2206
 
}; break; 
2207
 
case 5301: { // glVertex2fv 
 
2142
}; break;
 
2143
case 5301: { // glVertex2fv
2208
2144
 GLfloat *v = (GLfloat *) bp; bp += 4;
2209
2145
 weglVertex2fv(v);
2210
 
}; break; 
2211
 
case 5302: { // glVertex2iv 
 
2146
}; break;
 
2147
case 5302: { // glVertex2iv
2212
2148
 GLint *v = (GLint *) bp; bp += 4;
2213
2149
 weglVertex2iv(v);
2214
 
}; break; 
2215
 
case 5303: { // glVertex2sv 
 
2150
}; break;
 
2151
case 5303: { // glVertex2sv
2216
2152
 GLshort *v = (GLshort *) bp; bp += 2;
2217
2153
 weglVertex2sv(v);
2218
 
}; break; 
2219
 
case 5304: { // glVertex3dv 
 
2154
}; break;
 
2155
case 5304: { // glVertex3dv
2220
2156
 GLdouble *v = (GLdouble *) bp; bp += 8;
2221
2157
 weglVertex3dv(v);
2222
 
}; break; 
2223
 
case 5305: { // glVertex3fv 
 
2158
}; break;
 
2159
case 5305: { // glVertex3fv
2224
2160
 GLfloat *v = (GLfloat *) bp; bp += 4;
2225
2161
 weglVertex3fv(v);
2226
 
}; break; 
2227
 
case 5306: { // glVertex3iv 
 
2162
}; break;
 
2163
case 5306: { // glVertex3iv
2228
2164
 GLint *v = (GLint *) bp; bp += 4;
2229
2165
 weglVertex3iv(v);
2230
 
}; break; 
2231
 
case 5307: { // glVertex3sv 
 
2166
}; break;
 
2167
case 5307: { // glVertex3sv
2232
2168
 GLshort *v = (GLshort *) bp; bp += 2;
2233
2169
 weglVertex3sv(v);
2234
 
}; break; 
2235
 
case 5308: { // glVertex4dv 
 
2170
}; break;
 
2171
case 5308: { // glVertex4dv
2236
2172
 GLdouble *v = (GLdouble *) bp; bp += 8;
2237
2173
 weglVertex4dv(v);
2238
 
}; break; 
2239
 
case 5309: { // glVertex4fv 
 
2174
}; break;
 
2175
case 5309: { // glVertex4fv
2240
2176
 GLfloat *v = (GLfloat *) bp; bp += 4;
2241
2177
 weglVertex4fv(v);
2242
 
}; break; 
2243
 
case 5310: { // glVertex4iv 
 
2178
}; break;
 
2179
case 5310: { // glVertex4iv
2244
2180
 GLint *v = (GLint *) bp; bp += 4;
2245
2181
 weglVertex4iv(v);
2246
 
}; break; 
2247
 
case 5311: { // glVertex4sv 
 
2182
}; break;
 
2183
case 5311: { // glVertex4sv
2248
2184
 GLshort *v = (GLshort *) bp; bp += 2;
2249
2185
 weglVertex4sv(v);
2250
 
}; break; 
2251
 
case 5312: { // glVertexPointer 
 
2186
}; break;
 
2187
case 5312: { // glVertexPointer
2252
2188
 GLint *size = (GLint *) bp; bp += 4;
2253
2189
 GLenum *type = (GLenum *) bp; bp += 4;
2254
2190
 GLsizei *stride = (GLsizei *) bp; bp += 4;
2255
2191
 GLvoid *pointer = (GLvoid *) * (int *) bp; bp += 4;
2256
2192
 weglVertexPointer(*size,*type,*stride,pointer);
2257
 
}; break; 
2258
 
case 5313: { // glVertexPointer 
 
2193
}; break;
 
2194
case 5313: { // glVertexPointer
2259
2195
 GLint *size = (GLint *) bp; bp += 4;
2260
2196
 GLenum *type = (GLenum *) bp; bp += 4;
2261
2197
 GLsizei *stride = (GLsizei *) bp; bp += 4;
2262
 
 GLvoid *pointer = (GLvoid *) bins[0]->base;
 
2198
 GLvoid *pointer = (GLvoid *) bins[0];
2263
2199
 weglVertexPointer(*size,*type,*stride,pointer);
2264
 
}; break; 
2265
 
case 5314: { // glViewport 
 
2200
}; break;
 
2201
case 5314: { // glViewport
2266
2202
 GLint *x = (GLint *) bp; bp += 4;
2267
2203
 GLint *y = (GLint *) bp; bp += 4;
2268
2204
 GLsizei *width = (GLsizei *) bp; bp += 4;
2269
2205
 GLsizei *height = (GLsizei *) bp; bp += 4;
2270
2206
 weglViewport(*x,*y,*width,*height);
2271
 
}; break; 
2272
 
case 5315: { // glBlendColor 
 
2207
}; break;
 
2208
case 5315: { // glBlendColor
2273
2209
 GLclampf *red = (GLclampf *) bp; bp += 4;
2274
2210
 GLclampf *green = (GLclampf *) bp; bp += 4;
2275
2211
 GLclampf *blue = (GLclampf *) bp; bp += 4;
2276
2212
 GLclampf *alpha = (GLclampf *) bp; bp += 4;
2277
2213
 weglBlendColor(*red,*green,*blue,*alpha);
2278
 
}; break; 
2279
 
case 5316: { // glBlendEquation 
 
2214
}; break;
 
2215
case 5316: { // glBlendEquation
2280
2216
 GLenum *mode = (GLenum *) bp; bp += 4;
2281
2217
 weglBlendEquation(*mode);
2282
 
}; break; 
2283
 
case 5317: { // glDrawRangeElements 
 
2218
}; break;
 
2219
case 5317: { // glDrawRangeElements
2284
2220
 GLenum *mode = (GLenum *) bp; bp += 4;
2285
2221
 GLuint *start = (GLuint *) bp; bp += 4;
2286
2222
 GLuint *end = (GLuint *) bp; bp += 4;
2288
2224
 GLenum *type = (GLenum *) bp; bp += 4;
2289
2225
 GLvoid *indices = (GLvoid *) * (int *) bp; bp += 4;
2290
2226
 weglDrawRangeElements(*mode,*start,*end,*count,*type,indices);
2291
 
}; break; 
2292
 
case 5318: { // glDrawRangeElements 
 
2227
}; break;
 
2228
case 5318: { // glDrawRangeElements
2293
2229
 GLenum *mode = (GLenum *) bp; bp += 4;
2294
2230
 GLuint *start = (GLuint *) bp; bp += 4;
2295
2231
 GLuint *end = (GLuint *) bp; bp += 4;
2296
2232
 GLsizei *count = (GLsizei *) bp; bp += 4;
2297
2233
 GLenum *type = (GLenum *) bp; bp += 4;
2298
 
 GLvoid *indices = (GLvoid *) bins[0]->base;
 
2234
 GLvoid *indices = (GLvoid *) bins[0];
2299
2235
 weglDrawRangeElements(*mode,*start,*end,*count,*type,indices);
2300
 
}; break; 
2301
 
case 5319: { // glTexImage3D 
2302
 
 GLenum *target = (GLenum *) bp; bp += 4;
2303
 
 GLint *level = (GLint *) bp; bp += 4;
2304
 
 GLint *internalformat = (GLint *) bp; bp += 4;
2305
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2306
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2307
 
 GLsizei *depth = (GLsizei *) bp; bp += 4;
2308
 
 GLint *border = (GLint *) bp; bp += 4;
2309
 
 GLenum *format = (GLenum *) bp; bp += 4;
2310
 
 GLenum *type = (GLenum *) bp; bp += 4;
2311
 
 GLvoid *pixels = (GLvoid *) * (int *) bp; bp += 4;
2312
 
 weglTexImage3D(*target,*level,*internalformat,*width,*height,*depth,*border,*format,*type,pixels);
2313
 
}; break; 
2314
 
case 5320: { // glTexImage3D 
2315
 
 GLenum *target = (GLenum *) bp; bp += 4;
2316
 
 GLint *level = (GLint *) bp; bp += 4;
2317
 
 GLint *internalformat = (GLint *) bp; bp += 4;
2318
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2319
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2320
 
 GLsizei *depth = (GLsizei *) bp; bp += 4;
2321
 
 GLint *border = (GLint *) bp; bp += 4;
2322
 
 GLenum *format = (GLenum *) bp; bp += 4;
2323
 
 GLenum *type = (GLenum *) bp; bp += 4;
2324
 
 GLvoid *pixels = (GLvoid *) bins[0]->base;
2325
 
 weglTexImage3D(*target,*level,*internalformat,*width,*height,*depth,*border,*format,*type,pixels);
2326
 
}; break; 
2327
 
case 5321: { // glTexSubImage3D 
2328
 
 GLenum *target = (GLenum *) bp; bp += 4;
2329
 
 GLint *level = (GLint *) bp; bp += 4;
2330
 
 GLint *xoffset = (GLint *) bp; bp += 4;
2331
 
 GLint *yoffset = (GLint *) bp; bp += 4;
2332
 
 GLint *zoffset = (GLint *) bp; bp += 4;
2333
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2334
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2335
 
 GLsizei *depth = (GLsizei *) bp; bp += 4;
2336
 
 GLenum *format = (GLenum *) bp; bp += 4;
2337
 
 GLenum *type = (GLenum *) bp; bp += 4;
2338
 
 GLvoid *pixels = (GLvoid *) * (int *) bp; bp += 4;
2339
 
 weglTexSubImage3D(*target,*level,*xoffset,*yoffset,*zoffset,*width,*height,*depth,*format,*type,pixels);
2340
 
}; break; 
2341
 
case 5322: { // glTexSubImage3D 
2342
 
 GLenum *target = (GLenum *) bp; bp += 4;
2343
 
 GLint *level = (GLint *) bp; bp += 4;
2344
 
 GLint *xoffset = (GLint *) bp; bp += 4;
2345
 
 GLint *yoffset = (GLint *) bp; bp += 4;
2346
 
 GLint *zoffset = (GLint *) bp; bp += 4;
2347
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2348
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2349
 
 GLsizei *depth = (GLsizei *) bp; bp += 4;
2350
 
 GLenum *format = (GLenum *) bp; bp += 4;
2351
 
 GLenum *type = (GLenum *) bp; bp += 4;
2352
 
 GLvoid *pixels = (GLvoid *) bins[0]->base;
2353
 
 weglTexSubImage3D(*target,*level,*xoffset,*yoffset,*zoffset,*width,*height,*depth,*format,*type,pixels);
2354
 
}; break; 
2355
 
case 5323: { // glCopyTexSubImage3D 
 
2236
}; break;
 
2237
case 5319: { // glTexImage3D
 
2238
 GLenum *target = (GLenum *) bp; bp += 4;
 
2239
 GLint *level = (GLint *) bp; bp += 4;
 
2240
 GLint *internalformat = (GLint *) bp; bp += 4;
 
2241
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2242
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2243
 GLsizei *depth = (GLsizei *) bp; bp += 4;
 
2244
 GLint *border = (GLint *) bp; bp += 4;
 
2245
 GLenum *format = (GLenum *) bp; bp += 4;
 
2246
 GLenum *type = (GLenum *) bp; bp += 4;
 
2247
 GLvoid *pixels = (GLvoid *) * (int *) bp; bp += 4;
 
2248
 weglTexImage3D(*target,*level,*internalformat,*width,*height,*depth,*border,*format,*type,pixels);
 
2249
}; break;
 
2250
case 5320: { // glTexImage3D
 
2251
 GLenum *target = (GLenum *) bp; bp += 4;
 
2252
 GLint *level = (GLint *) bp; bp += 4;
 
2253
 GLint *internalformat = (GLint *) bp; bp += 4;
 
2254
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2255
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2256
 GLsizei *depth = (GLsizei *) bp; bp += 4;
 
2257
 GLint *border = (GLint *) bp; bp += 4;
 
2258
 GLenum *format = (GLenum *) bp; bp += 4;
 
2259
 GLenum *type = (GLenum *) bp; bp += 4;
 
2260
 GLvoid *pixels = (GLvoid *) bins[0];
 
2261
 weglTexImage3D(*target,*level,*internalformat,*width,*height,*depth,*border,*format,*type,pixels);
 
2262
}; break;
 
2263
case 5321: { // glTexSubImage3D
 
2264
 GLenum *target = (GLenum *) bp; bp += 4;
 
2265
 GLint *level = (GLint *) bp; bp += 4;
 
2266
 GLint *xoffset = (GLint *) bp; bp += 4;
 
2267
 GLint *yoffset = (GLint *) bp; bp += 4;
 
2268
 GLint *zoffset = (GLint *) bp; bp += 4;
 
2269
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2270
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2271
 GLsizei *depth = (GLsizei *) bp; bp += 4;
 
2272
 GLenum *format = (GLenum *) bp; bp += 4;
 
2273
 GLenum *type = (GLenum *) bp; bp += 4;
 
2274
 GLvoid *pixels = (GLvoid *) * (int *) bp; bp += 4;
 
2275
 weglTexSubImage3D(*target,*level,*xoffset,*yoffset,*zoffset,*width,*height,*depth,*format,*type,pixels);
 
2276
}; break;
 
2277
case 5322: { // glTexSubImage3D
 
2278
 GLenum *target = (GLenum *) bp; bp += 4;
 
2279
 GLint *level = (GLint *) bp; bp += 4;
 
2280
 GLint *xoffset = (GLint *) bp; bp += 4;
 
2281
 GLint *yoffset = (GLint *) bp; bp += 4;
 
2282
 GLint *zoffset = (GLint *) bp; bp += 4;
 
2283
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2284
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2285
 GLsizei *depth = (GLsizei *) bp; bp += 4;
 
2286
 GLenum *format = (GLenum *) bp; bp += 4;
 
2287
 GLenum *type = (GLenum *) bp; bp += 4;
 
2288
 GLvoid *pixels = (GLvoid *) bins[0];
 
2289
 weglTexSubImage3D(*target,*level,*xoffset,*yoffset,*zoffset,*width,*height,*depth,*format,*type,pixels);
 
2290
}; break;
 
2291
case 5323: { // glCopyTexSubImage3D
2356
2292
 GLenum *target = (GLenum *) bp; bp += 4;
2357
2293
 GLint *level = (GLint *) bp; bp += 4;
2358
2294
 GLint *xoffset = (GLint *) bp; bp += 4;
2363
2299
 GLsizei *width = (GLsizei *) bp; bp += 4;
2364
2300
 GLsizei *height = (GLsizei *) bp; bp += 4;
2365
2301
 weglCopyTexSubImage3D(*target,*level,*xoffset,*yoffset,*zoffset,*x,*y,*width,*height);
2366
 
}; break; 
2367
 
case 5324: { // glColorTable 
 
2302
}; break;
 
2303
case 5324: { // glColorTable
2368
2304
 GLenum *target = (GLenum *) bp; bp += 4;
2369
2305
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2370
2306
 GLsizei *width = (GLsizei *) bp; bp += 4;
2372
2308
 GLenum *type = (GLenum *) bp; bp += 4;
2373
2309
 GLvoid *table = (GLvoid *) * (int *) bp; bp += 4;
2374
2310
 weglColorTable(*target,*internalformat,*width,*format,*type,table);
2375
 
}; break; 
2376
 
case 5325: { // glColorTable 
 
2311
}; break;
 
2312
case 5325: { // glColorTable
2377
2313
 GLenum *target = (GLenum *) bp; bp += 4;
2378
2314
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2379
2315
 GLsizei *width = (GLsizei *) bp; bp += 4;
2380
2316
 GLenum *format = (GLenum *) bp; bp += 4;
2381
2317
 GLenum *type = (GLenum *) bp; bp += 4;
2382
 
 GLvoid *table = (GLvoid *) bins[0]->base;
 
2318
 GLvoid *table = (GLvoid *) bins[0];
2383
2319
 weglColorTable(*target,*internalformat,*width,*format,*type,table);
2384
 
}; break; 
2385
 
case 5326: { // glColorTableParameterfv 
 
2320
}; break;
 
2321
case 5326: { // glColorTableParameterfv
2386
2322
 GLenum *target = (GLenum *) bp; bp += 4;
2387
2323
 GLenum *pname = (GLenum *) bp; bp += 4;
2388
2324
 GLfloat * params = (GLfloat *) bp; bp += 16;
2389
2325
 weglColorTableParameterfv(*target,*pname,params);
2390
 
}; break; 
2391
 
case 5327: { // glColorTableParameteriv 
 
2326
}; break;
 
2327
case 5327: { // glColorTableParameteriv
2392
2328
 GLenum *target = (GLenum *) bp; bp += 4;
2393
2329
 GLenum *pname = (GLenum *) bp; bp += 4;
2394
2330
 GLint * params = (GLint *) bp; bp += 16;
2395
2331
 weglColorTableParameteriv(*target,*pname,params);
2396
 
}; break; 
2397
 
case 5328: { // glCopyColorTable 
 
2332
}; break;
 
2333
case 5328: { // glCopyColorTable
2398
2334
 GLenum *target = (GLenum *) bp; bp += 4;
2399
2335
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2400
2336
 GLint *x = (GLint *) bp; bp += 4;
2401
2337
 GLint *y = (GLint *) bp; bp += 4;
2402
2338
 GLsizei *width = (GLsizei *) bp; bp += 4;
2403
2339
 weglCopyColorTable(*target,*internalformat,*x,*y,*width);
2404
 
}; break; 
2405
 
case 5329: { // glGetColorTable 
 
2340
}; break;
 
2341
case 5329: { // glGetColorTable
2406
2342
 GLenum *target = (GLenum *) bp; bp += 4;
2407
2343
 GLenum *format = (GLenum *) bp; bp += 4;
2408
2344
 GLenum *type = (GLenum *) bp; bp += 4;
2409
 
 GLvoid *table = (GLvoid *) bins[0]->base;
 
2345
 GLvoid *table = (GLvoid *) bins[0];
2410
2346
 weglGetColorTable(*target,*format,*type,table);
2411
2347
 int AP = 0; ErlDrvTermData rt[6];
2412
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
2348
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
2413
2349
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
2414
2350
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
2415
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
2416
 
}; break; 
2417
 
case 5330: { // glGetColorTableParameterfv 
 
2351
 driver_send_term(port,caller,rt,AP);
 
2352
}; break;
 
2353
case 5330: { // glGetColorTableParameterfv
2418
2354
 GLenum *target = (GLenum *) bp; bp += 4;
2419
2355
 GLenum *pname = (GLenum *) bp; bp += 4;
2420
2356
 GLfloat params[4] = {0.0,0.0,0.0,0.0};
2421
2357
 weglGetColorTableParameterfv(*target,*pname,params);
2422
2358
 int AP = 0; ErlDrvTermData rt[14];
2423
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
2359
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
2424
2360
 GLdouble paramsConv[4], *paramsTmp = paramsConv; 
2425
2361
 for(int i=0; i < 4; i++) paramsConv[i] = (GLdouble) params[i];
2426
2362
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
2429
2365
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
2430
2366
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
2431
2367
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
2432
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
2433
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
2434
 
}; break; 
2435
 
case 5331: { // glGetColorTableParameteriv 
 
2368
 driver_send_term(port,caller,rt,AP);
 
2369
}; break;
 
2370
case 5331: { // glGetColorTableParameteriv
2436
2371
 GLenum *target = (GLenum *) bp; bp += 4;
2437
2372
 GLenum *pname = (GLenum *) bp; bp += 4;
2438
2373
 GLint params[4] = {0,0,0,0};
2439
2374
 weglGetColorTableParameteriv(*target,*pname,params);
2440
2375
 int AP = 0; ErlDrvTermData rt[14];
2441
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
2376
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
2442
2377
 GLint *paramsTmp = params;
2443
2378
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
2444
2379
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
2446
2381
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
2447
2382
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
2448
2383
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
2449
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
2450
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
2451
 
}; break; 
2452
 
case 5332: { // glColorSubTable 
 
2384
 driver_send_term(port,caller,rt,AP);
 
2385
}; break;
 
2386
case 5332: { // glColorSubTable
2453
2387
 GLenum *target = (GLenum *) bp; bp += 4;
2454
2388
 GLsizei *start = (GLsizei *) bp; bp += 4;
2455
2389
 GLsizei *count = (GLsizei *) bp; bp += 4;
2457
2391
 GLenum *type = (GLenum *) bp; bp += 4;
2458
2392
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
2459
2393
 weglColorSubTable(*target,*start,*count,*format,*type,data);
2460
 
}; break; 
2461
 
case 5333: { // glColorSubTable 
 
2394
}; break;
 
2395
case 5333: { // glColorSubTable
2462
2396
 GLenum *target = (GLenum *) bp; bp += 4;
2463
2397
 GLsizei *start = (GLsizei *) bp; bp += 4;
2464
2398
 GLsizei *count = (GLsizei *) bp; bp += 4;
2465
2399
 GLenum *format = (GLenum *) bp; bp += 4;
2466
2400
 GLenum *type = (GLenum *) bp; bp += 4;
2467
 
 GLvoid *data = (GLvoid *) bins[0]->base;
 
2401
 GLvoid *data = (GLvoid *) bins[0];
2468
2402
 weglColorSubTable(*target,*start,*count,*format,*type,data);
2469
 
}; break; 
2470
 
case 5334: { // glCopyColorSubTable 
 
2403
}; break;
 
2404
case 5334: { // glCopyColorSubTable
2471
2405
 GLenum *target = (GLenum *) bp; bp += 4;
2472
2406
 GLsizei *start = (GLsizei *) bp; bp += 4;
2473
2407
 GLint *x = (GLint *) bp; bp += 4;
2474
2408
 GLint *y = (GLint *) bp; bp += 4;
2475
2409
 GLsizei *width = (GLsizei *) bp; bp += 4;
2476
2410
 weglCopyColorSubTable(*target,*start,*x,*y,*width);
2477
 
}; break; 
2478
 
case 5335: { // glConvolutionFilter1D 
2479
 
 GLenum *target = (GLenum *) bp; bp += 4;
2480
 
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2481
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2482
 
 GLenum *format = (GLenum *) bp; bp += 4;
2483
 
 GLenum *type = (GLenum *) bp; bp += 4;
2484
 
 GLvoid *image = (GLvoid *) * (int *) bp; bp += 4;
2485
 
 weglConvolutionFilter1D(*target,*internalformat,*width,*format,*type,image);
2486
 
}; break; 
2487
 
case 5336: { // glConvolutionFilter1D 
2488
 
 GLenum *target = (GLenum *) bp; bp += 4;
2489
 
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2490
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2491
 
 GLenum *format = (GLenum *) bp; bp += 4;
2492
 
 GLenum *type = (GLenum *) bp; bp += 4;
2493
 
 GLvoid *image = (GLvoid *) bins[0]->base;
2494
 
 weglConvolutionFilter1D(*target,*internalformat,*width,*format,*type,image);
2495
 
}; break; 
2496
 
case 5337: { // glConvolutionFilter2D 
2497
 
 GLenum *target = (GLenum *) bp; bp += 4;
2498
 
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2499
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2500
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2501
 
 GLenum *format = (GLenum *) bp; bp += 4;
2502
 
 GLenum *type = (GLenum *) bp; bp += 4;
2503
 
 GLvoid *image = (GLvoid *) * (int *) bp; bp += 4;
2504
 
 weglConvolutionFilter2D(*target,*internalformat,*width,*height,*format,*type,image);
2505
 
}; break; 
2506
 
case 5338: { // glConvolutionFilter2D 
2507
 
 GLenum *target = (GLenum *) bp; bp += 4;
2508
 
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2509
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2510
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2511
 
 GLenum *format = (GLenum *) bp; bp += 4;
2512
 
 GLenum *type = (GLenum *) bp; bp += 4;
2513
 
 GLvoid *image = (GLvoid *) bins[0]->base;
2514
 
 weglConvolutionFilter2D(*target,*internalformat,*width,*height,*format,*type,image);
2515
 
}; break; 
2516
 
case 5339: { // glConvolutionParameterfv 
 
2411
}; break;
 
2412
case 5335: { // glConvolutionFilter1D
 
2413
 GLenum *target = (GLenum *) bp; bp += 4;
 
2414
 GLenum *internalformat = (GLenum *) bp; bp += 4;
 
2415
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2416
 GLenum *format = (GLenum *) bp; bp += 4;
 
2417
 GLenum *type = (GLenum *) bp; bp += 4;
 
2418
 GLvoid *image = (GLvoid *) * (int *) bp; bp += 4;
 
2419
 weglConvolutionFilter1D(*target,*internalformat,*width,*format,*type,image);
 
2420
}; break;
 
2421
case 5336: { // glConvolutionFilter1D
 
2422
 GLenum *target = (GLenum *) bp; bp += 4;
 
2423
 GLenum *internalformat = (GLenum *) bp; bp += 4;
 
2424
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2425
 GLenum *format = (GLenum *) bp; bp += 4;
 
2426
 GLenum *type = (GLenum *) bp; bp += 4;
 
2427
 GLvoid *image = (GLvoid *) bins[0];
 
2428
 weglConvolutionFilter1D(*target,*internalformat,*width,*format,*type,image);
 
2429
}; break;
 
2430
case 5337: { // glConvolutionFilter2D
 
2431
 GLenum *target = (GLenum *) bp; bp += 4;
 
2432
 GLenum *internalformat = (GLenum *) bp; bp += 4;
 
2433
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2434
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2435
 GLenum *format = (GLenum *) bp; bp += 4;
 
2436
 GLenum *type = (GLenum *) bp; bp += 4;
 
2437
 GLvoid *image = (GLvoid *) * (int *) bp; bp += 4;
 
2438
 weglConvolutionFilter2D(*target,*internalformat,*width,*height,*format,*type,image);
 
2439
}; break;
 
2440
case 5338: { // glConvolutionFilter2D
 
2441
 GLenum *target = (GLenum *) bp; bp += 4;
 
2442
 GLenum *internalformat = (GLenum *) bp; bp += 4;
 
2443
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2444
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2445
 GLenum *format = (GLenum *) bp; bp += 4;
 
2446
 GLenum *type = (GLenum *) bp; bp += 4;
 
2447
 GLvoid *image = (GLvoid *) bins[0];
 
2448
 weglConvolutionFilter2D(*target,*internalformat,*width,*height,*format,*type,image);
 
2449
}; break;
 
2450
case 5339: { // glConvolutionParameterfv
2517
2451
 GLenum *target = (GLenum *) bp; bp += 4;
2518
2452
 GLenum *pname = (GLenum *) bp; bp += 4;
2519
2453
 int *paramsLen = (int *) bp; bp += 4;
2520
2454
 GLfloat *params = (GLfloat *) bp; bp += *paramsLen*4+((*paramsLen)+1)%2*4;
2521
2455
 weglConvolutionParameterfv(*target,*pname,params);
2522
 
}; break; 
2523
 
case 5340: { // glConvolutionParameteriv 
 
2456
}; break;
 
2457
case 5340: { // glConvolutionParameteriv
2524
2458
 GLenum *target = (GLenum *) bp; bp += 4;
2525
2459
 GLenum *pname = (GLenum *) bp; bp += 4;
2526
2460
 int *paramsLen = (int *) bp; bp += 4;
2527
2461
 GLint *params = (GLint *) bp; bp += *paramsLen*4+((*paramsLen)+1)%2*4;
2528
2462
 weglConvolutionParameteriv(*target,*pname,params);
2529
 
}; break; 
2530
 
case 5341: { // glCopyConvolutionFilter1D 
 
2463
}; break;
 
2464
case 5341: { // glCopyConvolutionFilter1D
2531
2465
 GLenum *target = (GLenum *) bp; bp += 4;
2532
2466
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2533
2467
 GLint *x = (GLint *) bp; bp += 4;
2534
2468
 GLint *y = (GLint *) bp; bp += 4;
2535
2469
 GLsizei *width = (GLsizei *) bp; bp += 4;
2536
2470
 weglCopyConvolutionFilter1D(*target,*internalformat,*x,*y,*width);
2537
 
}; break; 
2538
 
case 5342: { // glCopyConvolutionFilter2D 
 
2471
}; break;
 
2472
case 5342: { // glCopyConvolutionFilter2D
2539
2473
 GLenum *target = (GLenum *) bp; bp += 4;
2540
2474
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2541
2475
 GLint *x = (GLint *) bp; bp += 4;
2543
2477
 GLsizei *width = (GLsizei *) bp; bp += 4;
2544
2478
 GLsizei *height = (GLsizei *) bp; bp += 4;
2545
2479
 weglCopyConvolutionFilter2D(*target,*internalformat,*x,*y,*width,*height);
2546
 
}; break; 
2547
 
case 5343: { // glGetConvolutionFilter 
 
2480
}; break;
 
2481
case 5343: { // glGetConvolutionFilter
2548
2482
 GLenum *target = (GLenum *) bp; bp += 4;
2549
2483
 GLenum *format = (GLenum *) bp; bp += 4;
2550
2484
 GLenum *type = (GLenum *) bp; bp += 4;
2551
 
 GLvoid *image = (GLvoid *) bins[0]->base;
 
2485
 GLvoid *image = (GLvoid *) bins[0];
2552
2486
 weglGetConvolutionFilter(*target,*format,*type,image);
2553
2487
 int AP = 0; ErlDrvTermData rt[6];
2554
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
2488
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
2555
2489
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
2556
2490
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
2557
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
2558
 
}; break; 
2559
 
case 5344: { // glGetConvolutionParameterfv 
 
2491
 driver_send_term(port,caller,rt,AP);
 
2492
}; break;
 
2493
case 5344: { // glGetConvolutionParameterfv
2560
2494
 GLenum *target = (GLenum *) bp; bp += 4;
2561
2495
 GLenum *pname = (GLenum *) bp; bp += 4;
2562
2496
 GLfloat params[4] = {0.0,0.0,0.0,0.0};
2563
2497
 weglGetConvolutionParameterfv(*target,*pname,params);
2564
2498
 int AP = 0; ErlDrvTermData rt[14];
2565
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
2499
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
2566
2500
 GLdouble paramsConv[4], *paramsTmp = paramsConv; 
2567
2501
 for(int i=0; i < 4; i++) paramsConv[i] = (GLdouble) params[i];
2568
2502
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
2571
2505
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
2572
2506
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
2573
2507
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
2574
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
2575
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
2576
 
}; break; 
2577
 
case 5345: { // glGetConvolutionParameteriv 
 
2508
 driver_send_term(port,caller,rt,AP);
 
2509
}; break;
 
2510
case 5345: { // glGetConvolutionParameteriv
2578
2511
 GLenum *target = (GLenum *) bp; bp += 4;
2579
2512
 GLenum *pname = (GLenum *) bp; bp += 4;
2580
2513
 GLint params[4] = {0,0,0,0};
2581
2514
 weglGetConvolutionParameteriv(*target,*pname,params);
2582
2515
 int AP = 0; ErlDrvTermData rt[14];
2583
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
2516
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
2584
2517
 GLint *paramsTmp = params;
2585
2518
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
2586
2519
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
2588
2521
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
2589
2522
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
2590
2523
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
2591
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
2592
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
2593
 
}; break; 
2594
 
case 5346: { // glSeparableFilter2D 
 
2524
 driver_send_term(port,caller,rt,AP);
 
2525
}; break;
 
2526
case 5346: { // glSeparableFilter2D
2595
2527
 GLenum *target = (GLenum *) bp; bp += 4;
2596
2528
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2597
2529
 GLsizei *width = (GLsizei *) bp; bp += 4;
2601
2533
 GLvoid *row = (GLvoid *) * (int *) bp; bp += 4;
2602
2534
 GLvoid *column = (GLvoid *) * (int *) bp; bp += 4;
2603
2535
 weglSeparableFilter2D(*target,*internalformat,*width,*height,*format,*type,row,column);
2604
 
}; break; 
2605
 
case 5347: { // glSeparableFilter2D 
 
2536
}; break;
 
2537
case 5347: { // glSeparableFilter2D
2606
2538
 GLenum *target = (GLenum *) bp; bp += 4;
2607
2539
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2608
2540
 GLsizei *width = (GLsizei *) bp; bp += 4;
2609
2541
 GLsizei *height = (GLsizei *) bp; bp += 4;
2610
2542
 GLenum *format = (GLenum *) bp; bp += 4;
2611
2543
 GLenum *type = (GLenum *) bp; bp += 4;
2612
 
 GLvoid *row = (GLvoid *) bins[0]->base;
2613
 
 GLvoid *column = (GLvoid *) bins[1]->base;
 
2544
 GLvoid *row = (GLvoid *) bins[0];
 
2545
 GLvoid *column = (GLvoid *) bins[1];
2614
2546
 weglSeparableFilter2D(*target,*internalformat,*width,*height,*format,*type,row,column);
2615
 
}; break; 
2616
 
case 5348: { // glGetHistogram 
 
2547
}; break;
 
2548
case 5348: { // glGetHistogram
2617
2549
 GLenum *target = (GLenum *) bp; bp += 4;
2618
2550
 GLboolean *reset = (GLboolean *) bp; bp += 1;
2619
2551
 bp += 3;
2620
2552
 GLenum *format = (GLenum *) bp; bp += 4;
2621
2553
 GLenum *type = (GLenum *) bp; bp += 4;
2622
 
 GLvoid *values = (GLvoid *) bins[0]->base;
 
2554
 GLvoid *values = (GLvoid *) bins[0];
2623
2555
 weglGetHistogram(*target,*reset,*format,*type,values);
2624
2556
 int AP = 0; ErlDrvTermData rt[6];
2625
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
2557
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
2626
2558
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
2627
2559
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
2628
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
2629
 
}; break; 
2630
 
case 5349: { // glGetHistogramParameterfv 
 
2560
 driver_send_term(port,caller,rt,AP);
 
2561
}; break;
 
2562
case 5349: { // glGetHistogramParameterfv
2631
2563
 GLenum *target = (GLenum *) bp; bp += 4;
2632
2564
 GLenum *pname = (GLenum *) bp; bp += 4;
2633
2565
 GLfloat params[1] = {0.0};
2634
2566
 weglGetHistogramParameterfv(*target,*pname,params);
2635
2567
 int AP = 0; ErlDrvTermData rt[8];
2636
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
2568
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
2637
2569
 GLdouble paramsConv[1], *paramsTmp = paramsConv; 
2638
2570
 for(int i=0; i < 1; i++) paramsConv[i] = (GLdouble) params[i];
2639
2571
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
2640
2572
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 1;
2641
2573
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
2642
 
 if (AP != 8 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,8);
2643
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
2644
 
}; break; 
2645
 
case 5350: { // glGetHistogramParameteriv 
 
2574
 driver_send_term(port,caller,rt,AP);
 
2575
}; break;
 
2576
case 5350: { // glGetHistogramParameteriv
2646
2577
 GLenum *target = (GLenum *) bp; bp += 4;
2647
2578
 GLenum *pname = (GLenum *) bp; bp += 4;
2648
2579
 GLint params[1] = {0};
2649
2580
 weglGetHistogramParameteriv(*target,*pname,params);
2650
2581
 int AP = 0; ErlDrvTermData rt[8];
2651
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
2582
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
2652
2583
 GLint *paramsTmp = params;
2653
2584
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
2654
2585
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 1;
2655
2586
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
2656
 
 if (AP != 8 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,8);
2657
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
2658
 
}; break; 
2659
 
case 5351: { // glGetMinmax 
 
2587
 driver_send_term(port,caller,rt,AP);
 
2588
}; break;
 
2589
case 5351: { // glGetMinmax
2660
2590
 GLenum *target = (GLenum *) bp; bp += 4;
2661
2591
 GLboolean *reset = (GLboolean *) bp; bp += 1;
2662
2592
 bp += 3;
2663
2593
 GLenum *format = (GLenum *) bp; bp += 4;
2664
2594
 GLenum *type = (GLenum *) bp; bp += 4;
2665
 
 GLvoid *values = (GLvoid *) bins[0]->base;
 
2595
 GLvoid *values = (GLvoid *) bins[0];
2666
2596
 weglGetMinmax(*target,*reset,*format,*type,values);
2667
2597
 int AP = 0; ErlDrvTermData rt[6];
2668
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
2598
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
2669
2599
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
2670
2600
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
2671
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
2672
 
}; break; 
2673
 
case 5352: { // glGetMinmaxParameterfv 
 
2601
 driver_send_term(port,caller,rt,AP);
 
2602
}; break;
 
2603
case 5352: { // glGetMinmaxParameterfv
2674
2604
 GLenum *target = (GLenum *) bp; bp += 4;
2675
2605
 GLenum *pname = (GLenum *) bp; bp += 4;
2676
2606
 GLfloat params[1] = {0.0};
2677
2607
 weglGetMinmaxParameterfv(*target,*pname,params);
2678
2608
 int AP = 0; ErlDrvTermData rt[8];
2679
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
2609
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
2680
2610
 GLdouble paramsConv[1], *paramsTmp = paramsConv; 
2681
2611
 for(int i=0; i < 1; i++) paramsConv[i] = (GLdouble) params[i];
2682
2612
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
2683
2613
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 1;
2684
2614
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
2685
 
 if (AP != 8 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,8);
2686
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
2687
 
}; break; 
2688
 
case 5353: { // glGetMinmaxParameteriv 
 
2615
 driver_send_term(port,caller,rt,AP);
 
2616
}; break;
 
2617
case 5353: { // glGetMinmaxParameteriv
2689
2618
 GLenum *target = (GLenum *) bp; bp += 4;
2690
2619
 GLenum *pname = (GLenum *) bp; bp += 4;
2691
2620
 GLint params[1] = {0};
2692
2621
 weglGetMinmaxParameteriv(*target,*pname,params);
2693
2622
 int AP = 0; ErlDrvTermData rt[8];
2694
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
2623
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
2695
2624
 GLint *paramsTmp = params;
2696
2625
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
2697
2626
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 1;
2698
2627
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
2699
 
 if (AP != 8 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,8);
2700
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
2701
 
}; break; 
2702
 
case 5354: { // glHistogram 
 
2628
 driver_send_term(port,caller,rt,AP);
 
2629
}; break;
 
2630
case 5354: { // glHistogram
2703
2631
 GLenum *target = (GLenum *) bp; bp += 4;
2704
2632
 GLsizei *width = (GLsizei *) bp; bp += 4;
2705
2633
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2706
2634
 GLboolean *sink = (GLboolean *) bp; bp += 1;
2707
2635
 weglHistogram(*target,*width,*internalformat,*sink);
2708
 
}; break; 
2709
 
case 5355: { // glMinmax 
 
2636
}; break;
 
2637
case 5355: { // glMinmax
2710
2638
 GLenum *target = (GLenum *) bp; bp += 4;
2711
2639
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2712
2640
 GLboolean *sink = (GLboolean *) bp; bp += 1;
2713
2641
 weglMinmax(*target,*internalformat,*sink);
2714
 
}; break; 
2715
 
case 5356: { // glResetHistogram 
 
2642
}; break;
 
2643
case 5356: { // glResetHistogram
2716
2644
 GLenum *target = (GLenum *) bp; bp += 4;
2717
2645
 weglResetHistogram(*target);
2718
 
}; break; 
2719
 
case 5357: { // glResetMinmax 
 
2646
}; break;
 
2647
case 5357: { // glResetMinmax
2720
2648
 GLenum *target = (GLenum *) bp; bp += 4;
2721
2649
 weglResetMinmax(*target);
2722
 
}; break; 
2723
 
case 5358: { // glActiveTexture 
 
2650
}; break;
 
2651
case 5358: { // glActiveTexture
2724
2652
 GLenum *texture = (GLenum *) bp; bp += 4;
2725
2653
 weglActiveTexture(*texture);
2726
 
}; break; 
2727
 
case 5359: { // glSampleCoverage 
 
2654
}; break;
 
2655
case 5359: { // glSampleCoverage
2728
2656
 GLclampf *value = (GLclampf *) bp; bp += 4;
2729
2657
 GLboolean *invert = (GLboolean *) bp; bp += 1;
2730
2658
 weglSampleCoverage(*value,*invert);
2731
 
}; break; 
2732
 
case 5360: { // glCompressedTexImage3D 
2733
 
 GLenum *target = (GLenum *) bp; bp += 4;
2734
 
 GLint *level = (GLint *) bp; bp += 4;
2735
 
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2736
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2737
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2738
 
 GLsizei *depth = (GLsizei *) bp; bp += 4;
2739
 
 GLint *border = (GLint *) bp; bp += 4;
2740
 
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
2741
 
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
2742
 
 weglCompressedTexImage3D(*target,*level,*internalformat,*width,*height,*depth,*border,*imageSize,data);
2743
 
}; break; 
2744
 
case 5361: { // glCompressedTexImage3D 
2745
 
 GLenum *target = (GLenum *) bp; bp += 4;
2746
 
 GLint *level = (GLint *) bp; bp += 4;
2747
 
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2748
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2749
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2750
 
 GLsizei *depth = (GLsizei *) bp; bp += 4;
2751
 
 GLint *border = (GLint *) bp; bp += 4;
2752
 
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
2753
 
 GLvoid *data = (GLvoid *) bins[0]->base;
2754
 
 weglCompressedTexImage3D(*target,*level,*internalformat,*width,*height,*depth,*border,*imageSize,data);
2755
 
}; break; 
2756
 
case 5362: { // glCompressedTexImage2D 
2757
 
 GLenum *target = (GLenum *) bp; bp += 4;
2758
 
 GLint *level = (GLint *) bp; bp += 4;
2759
 
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2760
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2761
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2762
 
 GLint *border = (GLint *) bp; bp += 4;
2763
 
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
2764
 
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
2765
 
 weglCompressedTexImage2D(*target,*level,*internalformat,*width,*height,*border,*imageSize,data);
2766
 
}; break; 
2767
 
case 5363: { // glCompressedTexImage2D 
2768
 
 GLenum *target = (GLenum *) bp; bp += 4;
2769
 
 GLint *level = (GLint *) bp; bp += 4;
2770
 
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2771
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2772
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2773
 
 GLint *border = (GLint *) bp; bp += 4;
2774
 
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
2775
 
 GLvoid *data = (GLvoid *) bins[0]->base;
2776
 
 weglCompressedTexImage2D(*target,*level,*internalformat,*width,*height,*border,*imageSize,data);
2777
 
}; break; 
2778
 
case 5364: { // glCompressedTexImage1D 
2779
 
 GLenum *target = (GLenum *) bp; bp += 4;
2780
 
 GLint *level = (GLint *) bp; bp += 4;
2781
 
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2782
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2783
 
 GLint *border = (GLint *) bp; bp += 4;
2784
 
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
2785
 
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
2786
 
 weglCompressedTexImage1D(*target,*level,*internalformat,*width,*border,*imageSize,data);
2787
 
}; break; 
2788
 
case 5365: { // glCompressedTexImage1D 
2789
 
 GLenum *target = (GLenum *) bp; bp += 4;
2790
 
 GLint *level = (GLint *) bp; bp += 4;
2791
 
 GLenum *internalformat = (GLenum *) bp; bp += 4;
2792
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2793
 
 GLint *border = (GLint *) bp; bp += 4;
2794
 
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
2795
 
 GLvoid *data = (GLvoid *) bins[0]->base;
2796
 
 weglCompressedTexImage1D(*target,*level,*internalformat,*width,*border,*imageSize,data);
2797
 
}; break; 
2798
 
case 5366: { // glCompressedTexSubImage3D 
2799
 
 GLenum *target = (GLenum *) bp; bp += 4;
2800
 
 GLint *level = (GLint *) bp; bp += 4;
2801
 
 GLint *xoffset = (GLint *) bp; bp += 4;
2802
 
 GLint *yoffset = (GLint *) bp; bp += 4;
2803
 
 GLint *zoffset = (GLint *) bp; bp += 4;
2804
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2805
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2806
 
 GLsizei *depth = (GLsizei *) bp; bp += 4;
2807
 
 GLenum *format = (GLenum *) bp; bp += 4;
2808
 
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
2809
 
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
2810
 
 weglCompressedTexSubImage3D(*target,*level,*xoffset,*yoffset,*zoffset,*width,*height,*depth,*format,*imageSize,data);
2811
 
}; break; 
2812
 
case 5367: { // glCompressedTexSubImage3D 
2813
 
 GLenum *target = (GLenum *) bp; bp += 4;
2814
 
 GLint *level = (GLint *) bp; bp += 4;
2815
 
 GLint *xoffset = (GLint *) bp; bp += 4;
2816
 
 GLint *yoffset = (GLint *) bp; bp += 4;
2817
 
 GLint *zoffset = (GLint *) bp; bp += 4;
2818
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2819
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2820
 
 GLsizei *depth = (GLsizei *) bp; bp += 4;
2821
 
 GLenum *format = (GLenum *) bp; bp += 4;
2822
 
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
2823
 
 GLvoid *data = (GLvoid *) bins[0]->base;
2824
 
 weglCompressedTexSubImage3D(*target,*level,*xoffset,*yoffset,*zoffset,*width,*height,*depth,*format,*imageSize,data);
2825
 
}; break; 
2826
 
case 5368: { // glCompressedTexSubImage2D 
2827
 
 GLenum *target = (GLenum *) bp; bp += 4;
2828
 
 GLint *level = (GLint *) bp; bp += 4;
2829
 
 GLint *xoffset = (GLint *) bp; bp += 4;
2830
 
 GLint *yoffset = (GLint *) bp; bp += 4;
2831
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2832
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2833
 
 GLenum *format = (GLenum *) bp; bp += 4;
2834
 
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
2835
 
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
2836
 
 weglCompressedTexSubImage2D(*target,*level,*xoffset,*yoffset,*width,*height,*format,*imageSize,data);
2837
 
}; break; 
2838
 
case 5369: { // glCompressedTexSubImage2D 
2839
 
 GLenum *target = (GLenum *) bp; bp += 4;
2840
 
 GLint *level = (GLint *) bp; bp += 4;
2841
 
 GLint *xoffset = (GLint *) bp; bp += 4;
2842
 
 GLint *yoffset = (GLint *) bp; bp += 4;
2843
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2844
 
 GLsizei *height = (GLsizei *) bp; bp += 4;
2845
 
 GLenum *format = (GLenum *) bp; bp += 4;
2846
 
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
2847
 
 GLvoid *data = (GLvoid *) bins[0]->base;
2848
 
 weglCompressedTexSubImage2D(*target,*level,*xoffset,*yoffset,*width,*height,*format,*imageSize,data);
2849
 
}; break; 
2850
 
case 5370: { // glCompressedTexSubImage1D 
2851
 
 GLenum *target = (GLenum *) bp; bp += 4;
2852
 
 GLint *level = (GLint *) bp; bp += 4;
2853
 
 GLint *xoffset = (GLint *) bp; bp += 4;
2854
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2855
 
 GLenum *format = (GLenum *) bp; bp += 4;
2856
 
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
2857
 
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
2858
 
 weglCompressedTexSubImage1D(*target,*level,*xoffset,*width,*format,*imageSize,data);
2859
 
}; break; 
2860
 
case 5371: { // glCompressedTexSubImage1D 
2861
 
 GLenum *target = (GLenum *) bp; bp += 4;
2862
 
 GLint *level = (GLint *) bp; bp += 4;
2863
 
 GLint *xoffset = (GLint *) bp; bp += 4;
2864
 
 GLsizei *width = (GLsizei *) bp; bp += 4;
2865
 
 GLenum *format = (GLenum *) bp; bp += 4;
2866
 
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
2867
 
 GLvoid *data = (GLvoid *) bins[0]->base;
2868
 
 weglCompressedTexSubImage1D(*target,*level,*xoffset,*width,*format,*imageSize,data);
2869
 
}; break; 
2870
 
case 5372: { // glGetCompressedTexImage 
2871
 
 GLenum *target = (GLenum *) bp; bp += 4;
2872
 
 GLint *level = (GLint *) bp; bp += 4;
2873
 
 GLvoid *img = (GLvoid *) bins[0]->base;
 
2659
}; break;
 
2660
case 5360: { // glCompressedTexImage3D
 
2661
 GLenum *target = (GLenum *) bp; bp += 4;
 
2662
 GLint *level = (GLint *) bp; bp += 4;
 
2663
 GLenum *internalformat = (GLenum *) bp; bp += 4;
 
2664
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2665
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2666
 GLsizei *depth = (GLsizei *) bp; bp += 4;
 
2667
 GLint *border = (GLint *) bp; bp += 4;
 
2668
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
 
2669
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
 
2670
 weglCompressedTexImage3D(*target,*level,*internalformat,*width,*height,*depth,*border,*imageSize,data);
 
2671
}; break;
 
2672
case 5361: { // glCompressedTexImage3D
 
2673
 GLenum *target = (GLenum *) bp; bp += 4;
 
2674
 GLint *level = (GLint *) bp; bp += 4;
 
2675
 GLenum *internalformat = (GLenum *) bp; bp += 4;
 
2676
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2677
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2678
 GLsizei *depth = (GLsizei *) bp; bp += 4;
 
2679
 GLint *border = (GLint *) bp; bp += 4;
 
2680
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
 
2681
 GLvoid *data = (GLvoid *) bins[0];
 
2682
 weglCompressedTexImage3D(*target,*level,*internalformat,*width,*height,*depth,*border,*imageSize,data);
 
2683
}; break;
 
2684
case 5362: { // glCompressedTexImage2D
 
2685
 GLenum *target = (GLenum *) bp; bp += 4;
 
2686
 GLint *level = (GLint *) bp; bp += 4;
 
2687
 GLenum *internalformat = (GLenum *) bp; bp += 4;
 
2688
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2689
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2690
 GLint *border = (GLint *) bp; bp += 4;
 
2691
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
 
2692
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
 
2693
 weglCompressedTexImage2D(*target,*level,*internalformat,*width,*height,*border,*imageSize,data);
 
2694
}; break;
 
2695
case 5363: { // glCompressedTexImage2D
 
2696
 GLenum *target = (GLenum *) bp; bp += 4;
 
2697
 GLint *level = (GLint *) bp; bp += 4;
 
2698
 GLenum *internalformat = (GLenum *) bp; bp += 4;
 
2699
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2700
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2701
 GLint *border = (GLint *) bp; bp += 4;
 
2702
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
 
2703
 GLvoid *data = (GLvoid *) bins[0];
 
2704
 weglCompressedTexImage2D(*target,*level,*internalformat,*width,*height,*border,*imageSize,data);
 
2705
}; break;
 
2706
case 5364: { // glCompressedTexImage1D
 
2707
 GLenum *target = (GLenum *) bp; bp += 4;
 
2708
 GLint *level = (GLint *) bp; bp += 4;
 
2709
 GLenum *internalformat = (GLenum *) bp; bp += 4;
 
2710
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2711
 GLint *border = (GLint *) bp; bp += 4;
 
2712
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
 
2713
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
 
2714
 weglCompressedTexImage1D(*target,*level,*internalformat,*width,*border,*imageSize,data);
 
2715
}; break;
 
2716
case 5365: { // glCompressedTexImage1D
 
2717
 GLenum *target = (GLenum *) bp; bp += 4;
 
2718
 GLint *level = (GLint *) bp; bp += 4;
 
2719
 GLenum *internalformat = (GLenum *) bp; bp += 4;
 
2720
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2721
 GLint *border = (GLint *) bp; bp += 4;
 
2722
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
 
2723
 GLvoid *data = (GLvoid *) bins[0];
 
2724
 weglCompressedTexImage1D(*target,*level,*internalformat,*width,*border,*imageSize,data);
 
2725
}; break;
 
2726
case 5366: { // glCompressedTexSubImage3D
 
2727
 GLenum *target = (GLenum *) bp; bp += 4;
 
2728
 GLint *level = (GLint *) bp; bp += 4;
 
2729
 GLint *xoffset = (GLint *) bp; bp += 4;
 
2730
 GLint *yoffset = (GLint *) bp; bp += 4;
 
2731
 GLint *zoffset = (GLint *) bp; bp += 4;
 
2732
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2733
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2734
 GLsizei *depth = (GLsizei *) bp; bp += 4;
 
2735
 GLenum *format = (GLenum *) bp; bp += 4;
 
2736
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
 
2737
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
 
2738
 weglCompressedTexSubImage3D(*target,*level,*xoffset,*yoffset,*zoffset,*width,*height,*depth,*format,*imageSize,data);
 
2739
}; break;
 
2740
case 5367: { // glCompressedTexSubImage3D
 
2741
 GLenum *target = (GLenum *) bp; bp += 4;
 
2742
 GLint *level = (GLint *) bp; bp += 4;
 
2743
 GLint *xoffset = (GLint *) bp; bp += 4;
 
2744
 GLint *yoffset = (GLint *) bp; bp += 4;
 
2745
 GLint *zoffset = (GLint *) bp; bp += 4;
 
2746
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2747
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2748
 GLsizei *depth = (GLsizei *) bp; bp += 4;
 
2749
 GLenum *format = (GLenum *) bp; bp += 4;
 
2750
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
 
2751
 GLvoid *data = (GLvoid *) bins[0];
 
2752
 weglCompressedTexSubImage3D(*target,*level,*xoffset,*yoffset,*zoffset,*width,*height,*depth,*format,*imageSize,data);
 
2753
}; break;
 
2754
case 5368: { // glCompressedTexSubImage2D
 
2755
 GLenum *target = (GLenum *) bp; bp += 4;
 
2756
 GLint *level = (GLint *) bp; bp += 4;
 
2757
 GLint *xoffset = (GLint *) bp; bp += 4;
 
2758
 GLint *yoffset = (GLint *) bp; bp += 4;
 
2759
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2760
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2761
 GLenum *format = (GLenum *) bp; bp += 4;
 
2762
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
 
2763
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
 
2764
 weglCompressedTexSubImage2D(*target,*level,*xoffset,*yoffset,*width,*height,*format,*imageSize,data);
 
2765
}; break;
 
2766
case 5369: { // glCompressedTexSubImage2D
 
2767
 GLenum *target = (GLenum *) bp; bp += 4;
 
2768
 GLint *level = (GLint *) bp; bp += 4;
 
2769
 GLint *xoffset = (GLint *) bp; bp += 4;
 
2770
 GLint *yoffset = (GLint *) bp; bp += 4;
 
2771
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2772
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
2773
 GLenum *format = (GLenum *) bp; bp += 4;
 
2774
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
 
2775
 GLvoid *data = (GLvoid *) bins[0];
 
2776
 weglCompressedTexSubImage2D(*target,*level,*xoffset,*yoffset,*width,*height,*format,*imageSize,data);
 
2777
}; break;
 
2778
case 5370: { // glCompressedTexSubImage1D
 
2779
 GLenum *target = (GLenum *) bp; bp += 4;
 
2780
 GLint *level = (GLint *) bp; bp += 4;
 
2781
 GLint *xoffset = (GLint *) bp; bp += 4;
 
2782
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2783
 GLenum *format = (GLenum *) bp; bp += 4;
 
2784
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
 
2785
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
 
2786
 weglCompressedTexSubImage1D(*target,*level,*xoffset,*width,*format,*imageSize,data);
 
2787
}; break;
 
2788
case 5371: { // glCompressedTexSubImage1D
 
2789
 GLenum *target = (GLenum *) bp; bp += 4;
 
2790
 GLint *level = (GLint *) bp; bp += 4;
 
2791
 GLint *xoffset = (GLint *) bp; bp += 4;
 
2792
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
2793
 GLenum *format = (GLenum *) bp; bp += 4;
 
2794
 GLsizei *imageSize = (GLsizei *) bp; bp += 4;
 
2795
 GLvoid *data = (GLvoid *) bins[0];
 
2796
 weglCompressedTexSubImage1D(*target,*level,*xoffset,*width,*format,*imageSize,data);
 
2797
}; break;
 
2798
case 5372: { // glGetCompressedTexImage
 
2799
 GLenum *target = (GLenum *) bp; bp += 4;
 
2800
 GLint *level = (GLint *) bp; bp += 4;
 
2801
 GLvoid *img = (GLvoid *) bins[0];
2874
2802
 weglGetCompressedTexImage(*target,*level,img);
2875
2803
 int AP = 0; ErlDrvTermData rt[6];
2876
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
2804
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
2877
2805
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
2878
2806
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
2879
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
2880
 
}; break; 
2881
 
case 5373: { // glClientActiveTexture 
 
2807
 driver_send_term(port,caller,rt,AP);
 
2808
}; break;
 
2809
case 5373: { // glClientActiveTexture
2882
2810
 GLenum *texture = (GLenum *) bp; bp += 4;
2883
2811
 weglClientActiveTexture(*texture);
2884
 
}; break; 
2885
 
case 5374: { // glMultiTexCoord1dv 
 
2812
}; break;
 
2813
case 5374: { // glMultiTexCoord1dv
2886
2814
 GLenum *target = (GLenum *) bp; bp += 4;
2887
2815
 bp += 4;
2888
2816
 GLdouble *v = (GLdouble *) bp; bp += 8;
2889
2817
 weglMultiTexCoord1dv(*target,v);
2890
 
}; break; 
2891
 
case 5375: { // glMultiTexCoord1fv 
 
2818
}; break;
 
2819
case 5375: { // glMultiTexCoord1fv
2892
2820
 GLenum *target = (GLenum *) bp; bp += 4;
2893
2821
 GLfloat *v = (GLfloat *) bp; bp += 4;
2894
2822
 weglMultiTexCoord1fv(*target,v);
2895
 
}; break; 
2896
 
case 5376: { // glMultiTexCoord1iv 
 
2823
}; break;
 
2824
case 5376: { // glMultiTexCoord1iv
2897
2825
 GLenum *target = (GLenum *) bp; bp += 4;
2898
2826
 GLint *v = (GLint *) bp; bp += 4;
2899
2827
 weglMultiTexCoord1iv(*target,v);
2900
 
}; break; 
2901
 
case 5377: { // glMultiTexCoord1sv 
 
2828
}; break;
 
2829
case 5377: { // glMultiTexCoord1sv
2902
2830
 GLenum *target = (GLenum *) bp; bp += 4;
2903
2831
 GLshort *v = (GLshort *) bp; bp += 2;
2904
2832
 weglMultiTexCoord1sv(*target,v);
2905
 
}; break; 
2906
 
case 5378: { // glMultiTexCoord2dv 
 
2833
}; break;
 
2834
case 5378: { // glMultiTexCoord2dv
2907
2835
 GLenum *target = (GLenum *) bp; bp += 4;
2908
2836
 bp += 4;
2909
2837
 GLdouble *v = (GLdouble *) bp; bp += 8;
2910
2838
 weglMultiTexCoord2dv(*target,v);
2911
 
}; break; 
2912
 
case 5379: { // glMultiTexCoord2fv 
 
2839
}; break;
 
2840
case 5379: { // glMultiTexCoord2fv
2913
2841
 GLenum *target = (GLenum *) bp; bp += 4;
2914
2842
 GLfloat *v = (GLfloat *) bp; bp += 4;
2915
2843
 weglMultiTexCoord2fv(*target,v);
2916
 
}; break; 
2917
 
case 5380: { // glMultiTexCoord2iv 
 
2844
}; break;
 
2845
case 5380: { // glMultiTexCoord2iv
2918
2846
 GLenum *target = (GLenum *) bp; bp += 4;
2919
2847
 GLint *v = (GLint *) bp; bp += 4;
2920
2848
 weglMultiTexCoord2iv(*target,v);
2921
 
}; break; 
2922
 
case 5381: { // glMultiTexCoord2sv 
 
2849
}; break;
 
2850
case 5381: { // glMultiTexCoord2sv
2923
2851
 GLenum *target = (GLenum *) bp; bp += 4;
2924
2852
 GLshort *v = (GLshort *) bp; bp += 2;
2925
2853
 weglMultiTexCoord2sv(*target,v);
2926
 
}; break; 
2927
 
case 5382: { // glMultiTexCoord3dv 
 
2854
}; break;
 
2855
case 5382: { // glMultiTexCoord3dv
2928
2856
 GLenum *target = (GLenum *) bp; bp += 4;
2929
2857
 bp += 4;
2930
2858
 GLdouble *v = (GLdouble *) bp; bp += 8;
2931
2859
 weglMultiTexCoord3dv(*target,v);
2932
 
}; break; 
2933
 
case 5383: { // glMultiTexCoord3fv 
 
2860
}; break;
 
2861
case 5383: { // glMultiTexCoord3fv
2934
2862
 GLenum *target = (GLenum *) bp; bp += 4;
2935
2863
 GLfloat *v = (GLfloat *) bp; bp += 4;
2936
2864
 weglMultiTexCoord3fv(*target,v);
2937
 
}; break; 
2938
 
case 5384: { // glMultiTexCoord3iv 
 
2865
}; break;
 
2866
case 5384: { // glMultiTexCoord3iv
2939
2867
 GLenum *target = (GLenum *) bp; bp += 4;
2940
2868
 GLint *v = (GLint *) bp; bp += 4;
2941
2869
 weglMultiTexCoord3iv(*target,v);
2942
 
}; break; 
2943
 
case 5385: { // glMultiTexCoord3sv 
 
2870
}; break;
 
2871
case 5385: { // glMultiTexCoord3sv
2944
2872
 GLenum *target = (GLenum *) bp; bp += 4;
2945
2873
 GLshort *v = (GLshort *) bp; bp += 2;
2946
2874
 weglMultiTexCoord3sv(*target,v);
2947
 
}; break; 
2948
 
case 5386: { // glMultiTexCoord4dv 
 
2875
}; break;
 
2876
case 5386: { // glMultiTexCoord4dv
2949
2877
 GLenum *target = (GLenum *) bp; bp += 4;
2950
2878
 bp += 4;
2951
2879
 GLdouble *v = (GLdouble *) bp; bp += 8;
2952
2880
 weglMultiTexCoord4dv(*target,v);
2953
 
}; break; 
2954
 
case 5387: { // glMultiTexCoord4fv 
 
2881
}; break;
 
2882
case 5387: { // glMultiTexCoord4fv
2955
2883
 GLenum *target = (GLenum *) bp; bp += 4;
2956
2884
 GLfloat *v = (GLfloat *) bp; bp += 4;
2957
2885
 weglMultiTexCoord4fv(*target,v);
2958
 
}; break; 
2959
 
case 5388: { // glMultiTexCoord4iv 
 
2886
}; break;
 
2887
case 5388: { // glMultiTexCoord4iv
2960
2888
 GLenum *target = (GLenum *) bp; bp += 4;
2961
2889
 GLint *v = (GLint *) bp; bp += 4;
2962
2890
 weglMultiTexCoord4iv(*target,v);
2963
 
}; break; 
2964
 
case 5389: { // glMultiTexCoord4sv 
 
2891
}; break;
 
2892
case 5389: { // glMultiTexCoord4sv
2965
2893
 GLenum *target = (GLenum *) bp; bp += 4;
2966
2894
 GLshort *v = (GLshort *) bp; bp += 2;
2967
2895
 weglMultiTexCoord4sv(*target,v);
2968
 
}; break; 
2969
 
case 5390: { // glLoadTransposeMatrixf 
 
2896
}; break;
 
2897
case 5390: { // glLoadTransposeMatrixf
2970
2898
 GLfloat * m = (GLfloat *) bp; bp += 64;
2971
2899
 weglLoadTransposeMatrixf(m);
2972
 
}; break; 
2973
 
case 5391: { // glLoadTransposeMatrixd 
 
2900
}; break;
 
2901
case 5391: { // glLoadTransposeMatrixd
2974
2902
 GLdouble * m = (GLdouble *) bp; bp += 128;
2975
2903
 weglLoadTransposeMatrixd(m);
2976
 
}; break; 
2977
 
case 5392: { // glMultTransposeMatrixf 
 
2904
}; break;
 
2905
case 5392: { // glMultTransposeMatrixf
2978
2906
 GLfloat * m = (GLfloat *) bp; bp += 64;
2979
2907
 weglMultTransposeMatrixf(m);
2980
 
}; break; 
2981
 
case 5393: { // glMultTransposeMatrixd 
 
2908
}; break;
 
2909
case 5393: { // glMultTransposeMatrixd
2982
2910
 GLdouble * m = (GLdouble *) bp; bp += 128;
2983
2911
 weglMultTransposeMatrixd(m);
2984
 
}; break; 
2985
 
case 5394: { // glBlendFuncSeparate 
 
2912
}; break;
 
2913
case 5394: { // glBlendFuncSeparate
2986
2914
 GLenum *sfactorRGB = (GLenum *) bp; bp += 4;
2987
2915
 GLenum *dfactorRGB = (GLenum *) bp; bp += 4;
2988
2916
 GLenum *sfactorAlpha = (GLenum *) bp; bp += 4;
2989
2917
 GLenum *dfactorAlpha = (GLenum *) bp; bp += 4;
2990
2918
 weglBlendFuncSeparate(*sfactorRGB,*dfactorRGB,*sfactorAlpha,*dfactorAlpha);
2991
 
}; break; 
2992
 
case 5395: { // glMultiDrawArrays 
 
2919
}; break;
 
2920
case 5395: { // glMultiDrawArrays
2993
2921
 GLenum *mode = (GLenum *) bp; bp += 4;
2994
2922
 int * firstLen = (int *) bp; bp += 4;
2995
2923
 GLint * first = (GLint *) bp;  bp += (8-((*firstLen*4+0)%8))%8;
2996
2924
 int * countLen = (int *) bp; bp += 4;
2997
2925
 GLsizei * count = (GLsizei *) bp;  bp += (8-((*countLen*4+4)%8))%8;
2998
2926
 weglMultiDrawArrays(*mode,first,count,*firstLen);
2999
 
}; break; 
3000
 
case 5396: { // glPointParameterf 
 
2927
}; break;
 
2928
case 5396: { // glPointParameterf
3001
2929
 GLenum *pname = (GLenum *) bp; bp += 4;
3002
2930
 GLfloat *param = (GLfloat *) bp; bp += 4;
3003
2931
 weglPointParameterf(*pname,*param);
3004
 
}; break; 
3005
 
case 5397: { // glPointParameterfv 
 
2932
}; break;
 
2933
case 5397: { // glPointParameterfv
3006
2934
 GLenum *pname = (GLenum *) bp; bp += 4;
3007
2935
 int *paramsLen = (int *) bp; bp += 4;
3008
2936
 GLfloat *params = (GLfloat *) bp; bp += *paramsLen*4+((*paramsLen)+0)%2*4;
3009
2937
 weglPointParameterfv(*pname,params);
3010
 
}; break; 
3011
 
case 5398: { // glPointParameteri 
 
2938
}; break;
 
2939
case 5398: { // glPointParameteri
3012
2940
 GLenum *pname = (GLenum *) bp; bp += 4;
3013
2941
 GLint *param = (GLint *) bp; bp += 4;
3014
2942
 weglPointParameteri(*pname,*param);
3015
 
}; break; 
3016
 
case 5399: { // glPointParameteriv 
 
2943
}; break;
 
2944
case 5399: { // glPointParameteriv
3017
2945
 GLenum *pname = (GLenum *) bp; bp += 4;
3018
2946
 int *paramsLen = (int *) bp; bp += 4;
3019
2947
 GLint *params = (GLint *) bp; bp += *paramsLen*4+((*paramsLen)+0)%2*4;
3020
2948
 weglPointParameteriv(*pname,params);
3021
 
}; break; 
3022
 
case 5400: { // glFogCoordfv 
 
2949
}; break;
 
2950
case 5400: { // glFogCoordfv
3023
2951
 GLfloat *coord = (GLfloat *) bp; bp += 4;
3024
2952
 weglFogCoordfv(coord);
3025
 
}; break; 
3026
 
case 5401: { // glFogCoorddv 
 
2953
}; break;
 
2954
case 5401: { // glFogCoorddv
3027
2955
 GLdouble *coord = (GLdouble *) bp; bp += 8;
3028
2956
 weglFogCoorddv(coord);
3029
 
}; break; 
3030
 
case 5402: { // glFogCoordPointer 
 
2957
}; break;
 
2958
case 5402: { // glFogCoordPointer
3031
2959
 GLenum *type = (GLenum *) bp; bp += 4;
3032
2960
 GLsizei *stride = (GLsizei *) bp; bp += 4;
3033
2961
 GLvoid *pointer = (GLvoid *) * (int *) bp; bp += 4;
3034
2962
 weglFogCoordPointer(*type,*stride,pointer);
3035
 
}; break; 
3036
 
case 5403: { // glFogCoordPointer 
 
2963
}; break;
 
2964
case 5403: { // glFogCoordPointer
3037
2965
 GLenum *type = (GLenum *) bp; bp += 4;
3038
2966
 GLsizei *stride = (GLsizei *) bp; bp += 4;
3039
 
 GLvoid *pointer = (GLvoid *) bins[0]->base;
 
2967
 GLvoid *pointer = (GLvoid *) bins[0];
3040
2968
 weglFogCoordPointer(*type,*stride,pointer);
3041
 
}; break; 
3042
 
case 5404: { // glSecondaryColor3bv 
 
2969
}; break;
 
2970
case 5404: { // glSecondaryColor3bv
3043
2971
 GLbyte *v = (GLbyte *) bp; bp += 1;
3044
2972
 weglSecondaryColor3bv(v);
3045
 
}; break; 
3046
 
case 5405: { // glSecondaryColor3dv 
 
2973
}; break;
 
2974
case 5405: { // glSecondaryColor3dv
3047
2975
 GLdouble *v = (GLdouble *) bp; bp += 8;
3048
2976
 weglSecondaryColor3dv(v);
3049
 
}; break; 
3050
 
case 5406: { // glSecondaryColor3fv 
 
2977
}; break;
 
2978
case 5406: { // glSecondaryColor3fv
3051
2979
 GLfloat *v = (GLfloat *) bp; bp += 4;
3052
2980
 weglSecondaryColor3fv(v);
3053
 
}; break; 
3054
 
case 5407: { // glSecondaryColor3iv 
 
2981
}; break;
 
2982
case 5407: { // glSecondaryColor3iv
3055
2983
 GLint *v = (GLint *) bp; bp += 4;
3056
2984
 weglSecondaryColor3iv(v);
3057
 
}; break; 
3058
 
case 5408: { // glSecondaryColor3sv 
 
2985
}; break;
 
2986
case 5408: { // glSecondaryColor3sv
3059
2987
 GLshort *v = (GLshort *) bp; bp += 2;
3060
2988
 weglSecondaryColor3sv(v);
3061
 
}; break; 
3062
 
case 5409: { // glSecondaryColor3ubv 
 
2989
}; break;
 
2990
case 5409: { // glSecondaryColor3ubv
3063
2991
 GLubyte *v = (GLubyte *) bp; bp += 1;
3064
2992
 weglSecondaryColor3ubv(v);
3065
 
}; break; 
3066
 
case 5410: { // glSecondaryColor3uiv 
 
2993
}; break;
 
2994
case 5410: { // glSecondaryColor3uiv
3067
2995
 GLuint *v = (GLuint *) bp; bp += 4;
3068
2996
 weglSecondaryColor3uiv(v);
3069
 
}; break; 
3070
 
case 5411: { // glSecondaryColor3usv 
 
2997
}; break;
 
2998
case 5411: { // glSecondaryColor3usv
3071
2999
 GLushort *v = (GLushort *) bp; bp += 2;
3072
3000
 weglSecondaryColor3usv(v);
3073
 
}; break; 
3074
 
case 5412: { // glSecondaryColorPointer 
 
3001
}; break;
 
3002
case 5412: { // glSecondaryColorPointer
3075
3003
 GLint *size = (GLint *) bp; bp += 4;
3076
3004
 GLenum *type = (GLenum *) bp; bp += 4;
3077
3005
 GLsizei *stride = (GLsizei *) bp; bp += 4;
3078
3006
 GLvoid *pointer = (GLvoid *) * (int *) bp; bp += 4;
3079
3007
 weglSecondaryColorPointer(*size,*type,*stride,pointer);
3080
 
}; break; 
3081
 
case 5413: { // glSecondaryColorPointer 
 
3008
}; break;
 
3009
case 5413: { // glSecondaryColorPointer
3082
3010
 GLint *size = (GLint *) bp; bp += 4;
3083
3011
 GLenum *type = (GLenum *) bp; bp += 4;
3084
3012
 GLsizei *stride = (GLsizei *) bp; bp += 4;
3085
 
 GLvoid *pointer = (GLvoid *) bins[0]->base;
 
3013
 GLvoid *pointer = (GLvoid *) bins[0];
3086
3014
 weglSecondaryColorPointer(*size,*type,*stride,pointer);
3087
 
}; break; 
3088
 
case 5414: { // glWindowPos2dv 
 
3015
}; break;
 
3016
case 5414: { // glWindowPos2dv
3089
3017
 GLdouble *v = (GLdouble *) bp; bp += 8;
3090
3018
 weglWindowPos2dv(v);
3091
 
}; break; 
3092
 
case 5415: { // glWindowPos2fv 
 
3019
}; break;
 
3020
case 5415: { // glWindowPos2fv
3093
3021
 GLfloat *v = (GLfloat *) bp; bp += 4;
3094
3022
 weglWindowPos2fv(v);
3095
 
}; break; 
3096
 
case 5416: { // glWindowPos2iv 
 
3023
}; break;
 
3024
case 5416: { // glWindowPos2iv
3097
3025
 GLint *v = (GLint *) bp; bp += 4;
3098
3026
 weglWindowPos2iv(v);
3099
 
}; break; 
3100
 
case 5417: { // glWindowPos2sv 
 
3027
}; break;
 
3028
case 5417: { // glWindowPos2sv
3101
3029
 GLshort *v = (GLshort *) bp; bp += 2;
3102
3030
 weglWindowPos2sv(v);
3103
 
}; break; 
3104
 
case 5418: { // glWindowPos3dv 
 
3031
}; break;
 
3032
case 5418: { // glWindowPos3dv
3105
3033
 GLdouble *v = (GLdouble *) bp; bp += 8;
3106
3034
 weglWindowPos3dv(v);
3107
 
}; break; 
3108
 
case 5419: { // glWindowPos3fv 
 
3035
}; break;
 
3036
case 5419: { // glWindowPos3fv
3109
3037
 GLfloat *v = (GLfloat *) bp; bp += 4;
3110
3038
 weglWindowPos3fv(v);
3111
 
}; break; 
3112
 
case 5420: { // glWindowPos3iv 
 
3039
}; break;
 
3040
case 5420: { // glWindowPos3iv
3113
3041
 GLint *v = (GLint *) bp; bp += 4;
3114
3042
 weglWindowPos3iv(v);
3115
 
}; break; 
3116
 
case 5421: { // glWindowPos3sv 
 
3043
}; break;
 
3044
case 5421: { // glWindowPos3sv
3117
3045
 GLshort *v = (GLshort *) bp; bp += 2;
3118
3046
 weglWindowPos3sv(v);
3119
 
}; break; 
3120
 
case 5422: { // glGenQueries 
 
3047
}; break;
 
3048
case 5422: { // glGenQueries
3121
3049
 GLsizei *n = (GLsizei *) bp; bp += 4;
3122
3050
 GLuint *ids;
3123
3051
 ids = (GLuint *) driver_alloc(sizeof(GLuint) * *n);
3124
3052
 weglGenQueries(*n,ids);
3125
3053
 int AP = 0; ErlDrvTermData *rt;
3126
3054
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*n)*2));
3127
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3055
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3128
3056
 for(int i=0; i < *n; i++) {
3129
3057
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) ids[i];}
3130
3058
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*n)+1;
3131
3059
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3132
 
 if (AP != 7 + (*n)*2 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7 + (*n)*2);
3133
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3134
 
 driver_free(rt); 
 
3060
 driver_send_term(port,caller,rt,AP);
 
3061
 driver_free(rt);
3135
3062
 driver_free(ids);
3136
 
}; break; 
3137
 
case 5423: { // glDeleteQueries 
 
3063
}; break;
 
3064
case 5423: { // glDeleteQueries
3138
3065
 int * idsLen = (int *) bp; bp += 4;
3139
3066
 GLuint * ids = (GLuint *) bp;  bp += (8-((*idsLen*4+4)%8))%8;
3140
3067
 weglDeleteQueries(*idsLen,ids);
3141
 
}; break; 
3142
 
case 5424: { // glIsQuery 
 
3068
}; break;
 
3069
case 5424: { // glIsQuery
3143
3070
 GLuint *id = (GLuint *) bp; bp += 4;
3144
3071
 GLboolean result = weglIsQuery(*id);
3145
3072
 int AP = 0; ErlDrvTermData rt[6];
3146
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3073
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3147
3074
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
3148
3075
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3149
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
3150
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3151
 
}; break; 
3152
 
case 5425: { // glBeginQuery 
 
3076
 driver_send_term(port,caller,rt,AP);
 
3077
}; break;
 
3078
case 5425: { // glBeginQuery
3153
3079
 GLenum *target = (GLenum *) bp; bp += 4;
3154
3080
 GLuint *id = (GLuint *) bp; bp += 4;
3155
3081
 weglBeginQuery(*target,*id);
3156
 
}; break; 
3157
 
case 5426: { // glEndQuery 
 
3082
}; break;
 
3083
case 5426: { // glEndQuery
3158
3084
 GLenum *target = (GLenum *) bp; bp += 4;
3159
3085
 weglEndQuery(*target);
3160
 
}; break; 
3161
 
case 5427: { // glGetQueryiv 
 
3086
}; break;
 
3087
case 5427: { // glGetQueryiv
3162
3088
 GLenum *target = (GLenum *) bp; bp += 4;
3163
3089
 GLenum *pname = (GLenum *) bp; bp += 4;
3164
3090
 GLint params[1] = {0};
3165
3091
 weglGetQueryiv(*target,*pname,params);
3166
3092
 int AP = 0; ErlDrvTermData rt[6];
3167
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3093
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3168
3094
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *params;
3169
3095
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3170
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
3171
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3172
 
}; break; 
3173
 
case 5428: { // glGetQueryObjectiv 
 
3096
 driver_send_term(port,caller,rt,AP);
 
3097
}; break;
 
3098
case 5428: { // glGetQueryObjectiv
3174
3099
 GLuint *id = (GLuint *) bp; bp += 4;
3175
3100
 GLenum *pname = (GLenum *) bp; bp += 4;
3176
3101
 GLint params[1] = {0};
3177
3102
 weglGetQueryObjectiv(*id,*pname,params);
3178
3103
 int AP = 0; ErlDrvTermData rt[6];
3179
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3104
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3180
3105
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *params;
3181
3106
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3182
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
3183
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3184
 
}; break; 
3185
 
case 5429: { // glGetQueryObjectuiv 
 
3107
 driver_send_term(port,caller,rt,AP);
 
3108
}; break;
 
3109
case 5429: { // glGetQueryObjectuiv
3186
3110
 GLuint *id = (GLuint *) bp; bp += 4;
3187
3111
 GLenum *pname = (GLenum *) bp; bp += 4;
3188
3112
 GLuint params[1] = {0};
3189
3113
 weglGetQueryObjectuiv(*id,*pname,params);
3190
3114
 int AP = 0; ErlDrvTermData rt[6];
3191
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3115
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3192
3116
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *params;
3193
3117
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3194
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
3195
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3196
 
}; break; 
3197
 
case 5430: { // glBindBuffer 
 
3118
 driver_send_term(port,caller,rt,AP);
 
3119
}; break;
 
3120
case 5430: { // glBindBuffer
3198
3121
 GLenum *target = (GLenum *) bp; bp += 4;
3199
3122
 GLuint *buffer = (GLuint *) bp; bp += 4;
3200
3123
 weglBindBuffer(*target,*buffer);
3201
 
}; break; 
3202
 
case 5431: { // glDeleteBuffers 
 
3124
}; break;
 
3125
case 5431: { // glDeleteBuffers
3203
3126
 int * buffersLen = (int *) bp; bp += 4;
3204
3127
 GLuint * buffers = (GLuint *) bp;  bp += (8-((*buffersLen*4+4)%8))%8;
3205
3128
 weglDeleteBuffers(*buffersLen,buffers);
3206
 
}; break; 
3207
 
case 5432: { // glGenBuffers 
 
3129
}; break;
 
3130
case 5432: { // glGenBuffers
3208
3131
 GLsizei *n = (GLsizei *) bp; bp += 4;
3209
3132
 GLuint *buffers;
3210
3133
 buffers = (GLuint *) driver_alloc(sizeof(GLuint) * *n);
3211
3134
 weglGenBuffers(*n,buffers);
3212
3135
 int AP = 0; ErlDrvTermData *rt;
3213
3136
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*n)*2));
3214
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3137
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3215
3138
 for(int i=0; i < *n; i++) {
3216
3139
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) buffers[i];}
3217
3140
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*n)+1;
3218
3141
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3219
 
 if (AP != 7 + (*n)*2 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7 + (*n)*2);
3220
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3221
 
 driver_free(rt); 
 
3142
 driver_send_term(port,caller,rt,AP);
 
3143
 driver_free(rt);
3222
3144
 driver_free(buffers);
3223
 
}; break; 
3224
 
case 5433: { // glIsBuffer 
 
3145
}; break;
 
3146
case 5433: { // glIsBuffer
3225
3147
 GLuint *buffer = (GLuint *) bp; bp += 4;
3226
3148
 GLboolean result = weglIsBuffer(*buffer);
3227
3149
 int AP = 0; ErlDrvTermData rt[6];
3228
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3150
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3229
3151
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
3230
3152
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3231
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
3232
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3233
 
}; break; 
3234
 
case 5434: { // glBufferData 
3235
 
 GLenum *target = (GLenum *) bp; bp += 4;
3236
 
 bp += 4;
3237
 
 GLsizeiptr size = (GLsizeiptr) * (GLuint64EXT *) bp; bp += 8;
3238
 
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
3239
 
 GLenum *usage = (GLenum *) bp; bp += 4;
3240
 
 weglBufferData(*target,size,data,*usage);
3241
 
}; break; 
3242
 
case 5435: { // glBufferData 
3243
 
 GLenum *target = (GLenum *) bp; bp += 4;
3244
 
 bp += 4;
3245
 
 GLsizeiptr size = (GLsizeiptr) * (GLuint64EXT *) bp; bp += 8;
3246
 
 GLvoid *data = (GLvoid *) bins[0]->base;
3247
 
 GLenum *usage = (GLenum *) bp; bp += 4;
3248
 
 weglBufferData(*target,size,data,*usage);
3249
 
}; break; 
3250
 
case 5436: { // glBufferSubData 
3251
 
 GLenum *target = (GLenum *) bp; bp += 4;
3252
 
 bp += 4;
3253
 
 GLintptr offset = (GLintptr) * (GLuint64EXT *) bp; bp += 8;
3254
 
 GLsizeiptr size = (GLsizeiptr) * (GLuint64EXT *) bp; bp += 8;
3255
 
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
3256
 
 weglBufferSubData(*target,offset,size,data);
3257
 
}; break; 
3258
 
case 5437: { // glBufferSubData 
3259
 
 GLenum *target = (GLenum *) bp; bp += 4;
3260
 
 bp += 4;
3261
 
 GLintptr offset = (GLintptr) * (GLuint64EXT *) bp; bp += 8;
3262
 
 GLsizeiptr size = (GLsizeiptr) * (GLuint64EXT *) bp; bp += 8;
3263
 
 GLvoid *data = (GLvoid *) bins[0]->base;
3264
 
 weglBufferSubData(*target,offset,size,data);
3265
 
}; break; 
3266
 
case 5438: { // glGetBufferSubData 
3267
 
 GLenum *target = (GLenum *) bp; bp += 4;
3268
 
 bp += 4;
3269
 
 GLintptr offset = (GLintptr) * (GLuint64EXT *) bp; bp += 8;
3270
 
 GLsizeiptr size = (GLsizeiptr) * (GLuint64EXT *) bp; bp += 8;
3271
 
 GLvoid *data = (GLvoid *) bins[0]->base;
 
3153
 driver_send_term(port,caller,rt,AP);
 
3154
}; break;
 
3155
case 5434: { // glBufferData
 
3156
 GLenum *target = (GLenum *) bp; bp += 4;
 
3157
 bp += 4;
 
3158
 GLsizeiptr size = (GLsizeiptr) * (GLuint64EXT *) bp; bp += 8;
 
3159
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
 
3160
 GLenum *usage = (GLenum *) bp; bp += 4;
 
3161
 weglBufferData(*target,size,data,*usage);
 
3162
}; break;
 
3163
case 5435: { // glBufferData
 
3164
 GLenum *target = (GLenum *) bp; bp += 4;
 
3165
 bp += 4;
 
3166
 GLsizeiptr size = (GLsizeiptr) * (GLuint64EXT *) bp; bp += 8;
 
3167
 GLvoid *data = (GLvoid *) bins[0];
 
3168
 GLenum *usage = (GLenum *) bp; bp += 4;
 
3169
 weglBufferData(*target,size,data,*usage);
 
3170
}; break;
 
3171
case 5436: { // glBufferSubData
 
3172
 GLenum *target = (GLenum *) bp; bp += 4;
 
3173
 bp += 4;
 
3174
 GLintptr offset = (GLintptr) * (GLuint64EXT *) bp; bp += 8;
 
3175
 GLsizeiptr size = (GLsizeiptr) * (GLuint64EXT *) bp; bp += 8;
 
3176
 GLvoid *data = (GLvoid *) * (int *) bp; bp += 4;
 
3177
 weglBufferSubData(*target,offset,size,data);
 
3178
}; break;
 
3179
case 5437: { // glBufferSubData
 
3180
 GLenum *target = (GLenum *) bp; bp += 4;
 
3181
 bp += 4;
 
3182
 GLintptr offset = (GLintptr) * (GLuint64EXT *) bp; bp += 8;
 
3183
 GLsizeiptr size = (GLsizeiptr) * (GLuint64EXT *) bp; bp += 8;
 
3184
 GLvoid *data = (GLvoid *) bins[0];
 
3185
 weglBufferSubData(*target,offset,size,data);
 
3186
}; break;
 
3187
case 5438: { // glGetBufferSubData
 
3188
 GLenum *target = (GLenum *) bp; bp += 4;
 
3189
 bp += 4;
 
3190
 GLintptr offset = (GLintptr) * (GLuint64EXT *) bp; bp += 8;
 
3191
 GLsizeiptr size = (GLsizeiptr) * (GLuint64EXT *) bp; bp += 8;
 
3192
 GLvoid *data = (GLvoid *) bins[0];
3272
3193
 weglGetBufferSubData(*target,offset,size,data);
3273
3194
 int AP = 0; ErlDrvTermData rt[6];
3274
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3195
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3275
3196
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
3276
3197
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3277
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3278
 
}; break; 
3279
 
case 5439: { // glGetBufferParameteriv 
 
3198
 driver_send_term(port,caller,rt,AP);
 
3199
}; break;
 
3200
case 5439: { // glGetBufferParameteriv
3280
3201
 GLenum *target = (GLenum *) bp; bp += 4;
3281
3202
 GLenum *pname = (GLenum *) bp; bp += 4;
3282
3203
 GLint params[1] = {0};
3283
3204
 weglGetBufferParameteriv(*target,*pname,params);
3284
3205
 int AP = 0; ErlDrvTermData rt[6];
3285
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3206
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3286
3207
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *params;
3287
3208
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3288
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
3289
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3290
 
}; break; 
3291
 
case 5440: { // glBlendEquationSeparate 
 
3209
 driver_send_term(port,caller,rt,AP);
 
3210
}; break;
 
3211
case 5440: { // glBlendEquationSeparate
3292
3212
 GLenum *modeRGB = (GLenum *) bp; bp += 4;
3293
3213
 GLenum *modeAlpha = (GLenum *) bp; bp += 4;
3294
3214
 weglBlendEquationSeparate(*modeRGB,*modeAlpha);
3295
 
}; break; 
3296
 
case 5441: { // glDrawBuffers 
 
3215
}; break;
 
3216
case 5441: { // glDrawBuffers
3297
3217
 int * bufsLen = (int *) bp; bp += 4;
3298
3218
 GLenum * bufs = (GLenum *) bp;  bp += (8-((*bufsLen*4+4)%8))%8;
3299
3219
 weglDrawBuffers(*bufsLen,bufs);
3300
 
}; break; 
3301
 
case 5442: { // glStencilOpSeparate 
 
3220
}; break;
 
3221
case 5442: { // glStencilOpSeparate
3302
3222
 GLenum *face = (GLenum *) bp; bp += 4;
3303
3223
 GLenum *sfail = (GLenum *) bp; bp += 4;
3304
3224
 GLenum *dpfail = (GLenum *) bp; bp += 4;
3305
3225
 GLenum *dppass = (GLenum *) bp; bp += 4;
3306
3226
 weglStencilOpSeparate(*face,*sfail,*dpfail,*dppass);
3307
 
}; break; 
3308
 
case 5443: { // glStencilFuncSeparate 
3309
 
 GLenum *frontfunc = (GLenum *) bp; bp += 4;
3310
 
 GLenum *backfunc = (GLenum *) bp; bp += 4;
 
3227
}; break;
 
3228
case 5443: { // glStencilFuncSeparate
 
3229
 GLenum *face = (GLenum *) bp; bp += 4;
 
3230
 GLenum *func = (GLenum *) bp; bp += 4;
3311
3231
 GLint *ref = (GLint *) bp; bp += 4;
3312
3232
 GLuint *mask = (GLuint *) bp; bp += 4;
3313
 
 weglStencilFuncSeparate(*frontfunc,*backfunc,*ref,*mask);
3314
 
}; break; 
3315
 
case 5444: { // glStencilMaskSeparate 
 
3233
 weglStencilFuncSeparate(*face,*func,*ref,*mask);
 
3234
}; break;
 
3235
case 5444: { // glStencilMaskSeparate
3316
3236
 GLenum *face = (GLenum *) bp; bp += 4;
3317
3237
 GLuint *mask = (GLuint *) bp; bp += 4;
3318
3238
 weglStencilMaskSeparate(*face,*mask);
3319
 
}; break; 
3320
 
case 5445: { // glAttachShader 
 
3239
}; break;
 
3240
case 5445: { // glAttachShader
3321
3241
 GLuint *program = (GLuint *) bp; bp += 4;
3322
3242
 GLuint *shader = (GLuint *) bp; bp += 4;
3323
3243
 weglAttachShader(*program,*shader);
3324
 
}; break; 
3325
 
case 5446: { // glBindAttribLocation 
 
3244
}; break;
 
3245
case 5446: { // glBindAttribLocation
3326
3246
 GLuint *program = (GLuint *) bp; bp += 4;
3327
3247
 GLuint *index = (GLuint *) bp; bp += 4;
3328
3248
 GLchar *name = (GLchar *) bp;
3329
 
 int nameLen = strlen((char *)name); bp += nameLen+1+((8-((1+nameLen+0)%8))%8);
 
3249
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+0)%8))%8);
3330
3250
 weglBindAttribLocation(*program,*index,name);
3331
 
}; break; 
3332
 
case 5447: { // glCompileShader 
 
3251
}; break;
 
3252
case 5447: { // glCompileShader
3333
3253
 GLuint *shader = (GLuint *) bp; bp += 4;
3334
3254
 weglCompileShader(*shader);
3335
 
}; break; 
3336
 
case 5448: { // glCreateProgram 
 
3255
}; break;
 
3256
case 5448: { // glCreateProgram
3337
3257
 GLuint result = weglCreateProgram();
3338
3258
 int AP = 0; ErlDrvTermData rt[6];
3339
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3259
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3340
3260
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
3341
3261
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3342
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
3343
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3344
 
}; break; 
3345
 
case 5449: { // glCreateShader 
 
3262
 driver_send_term(port,caller,rt,AP);
 
3263
}; break;
 
3264
case 5449: { // glCreateShader
3346
3265
 GLenum *type = (GLenum *) bp; bp += 4;
3347
3266
 GLuint result = weglCreateShader(*type);
3348
3267
 int AP = 0; ErlDrvTermData rt[6];
3349
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3268
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3350
3269
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
3351
3270
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3352
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
3353
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3354
 
}; break; 
3355
 
case 5450: { // glDeleteProgram 
 
3271
 driver_send_term(port,caller,rt,AP);
 
3272
}; break;
 
3273
case 5450: { // glDeleteProgram
3356
3274
 GLuint *program = (GLuint *) bp; bp += 4;
3357
3275
 weglDeleteProgram(*program);
3358
 
}; break; 
3359
 
case 5451: { // glDeleteShader 
 
3276
}; break;
 
3277
case 5451: { // glDeleteShader
3360
3278
 GLuint *shader = (GLuint *) bp; bp += 4;
3361
3279
 weglDeleteShader(*shader);
3362
 
}; break; 
3363
 
case 5452: { // glDetachShader 
 
3280
}; break;
 
3281
case 5452: { // glDetachShader
3364
3282
 GLuint *program = (GLuint *) bp; bp += 4;
3365
3283
 GLuint *shader = (GLuint *) bp; bp += 4;
3366
3284
 weglDetachShader(*program,*shader);
3367
 
}; break; 
3368
 
case 5453: { // glDisableVertexAttribArray 
 
3285
}; break;
 
3286
case 5453: { // glDisableVertexAttribArray
3369
3287
 GLuint *index = (GLuint *) bp; bp += 4;
3370
3288
 weglDisableVertexAttribArray(*index);
3371
 
}; break; 
3372
 
case 5454: { // glEnableVertexAttribArray 
 
3289
}; break;
 
3290
case 5454: { // glEnableVertexAttribArray
3373
3291
 GLuint *index = (GLuint *) bp; bp += 4;
3374
3292
 weglEnableVertexAttribArray(*index);
3375
 
}; break; 
3376
 
case 5455: { // glGetActiveAttrib 
 
3293
}; break;
 
3294
case 5455: { // glGetActiveAttrib
3377
3295
 GLuint *program = (GLuint *) bp; bp += 4;
3378
3296
 GLuint *index = (GLuint *) bp; bp += 4;
3379
3297
 GLsizei *bufSize = (GLsizei *) bp; bp += 4;
3384
3302
 name = (GLchar *) driver_alloc(sizeof(GLchar) * *bufSize);
3385
3303
 weglGetActiveAttrib(*program,*index,*bufSize,length,size,type,name);
3386
3304
 int AP = 0; ErlDrvTermData rt[13];
3387
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3305
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3388
3306
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *size;
3389
3307
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *type;
3390
3308
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) name; rt[AP++] = *length;
3391
3309
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 3;
3392
3310
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3393
 
 if (AP != 13 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,13);
3394
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
 
3311
 driver_send_term(port,caller,rt,AP);
3395
3312
 driver_free(name);
3396
 
}; break; 
3397
 
case 5456: { // glGetActiveUniform 
 
3313
}; break;
 
3314
case 5456: { // glGetActiveUniform
3398
3315
 GLuint *program = (GLuint *) bp; bp += 4;
3399
3316
 GLuint *index = (GLuint *) bp; bp += 4;
3400
3317
 GLsizei *bufSize = (GLsizei *) bp; bp += 4;
3405
3322
 name = (GLchar *) driver_alloc(sizeof(GLchar) * *bufSize);
3406
3323
 weglGetActiveUniform(*program,*index,*bufSize,length,size,type,name);
3407
3324
 int AP = 0; ErlDrvTermData rt[13];
3408
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3325
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3409
3326
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *size;
3410
3327
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *type;
3411
3328
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) name; rt[AP++] = *length;
3412
3329
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 3;
3413
3330
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3414
 
 if (AP != 13 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,13);
3415
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
 
3331
 driver_send_term(port,caller,rt,AP);
3416
3332
 driver_free(name);
3417
 
}; break; 
3418
 
case 5457: { // glGetAttachedShaders 
 
3333
}; break;
 
3334
case 5457: { // glGetAttachedShaders
3419
3335
 GLuint *program = (GLuint *) bp; bp += 4;
3420
3336
 GLsizei *maxCount = (GLsizei *) bp; bp += 4;
3421
3337
 GLsizei count[1] = {0};
3424
3340
 weglGetAttachedShaders(*program,*maxCount,count,obj);
3425
3341
 int AP = 0; ErlDrvTermData *rt;
3426
3342
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*count)*2));
3427
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3343
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3428
3344
 for(int i=0; i < *count; i++) {
3429
3345
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) obj[i];}
3430
3346
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*count)+1;
3431
3347
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3432
 
 if (AP != 7 + (*count)*2 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7 + (*count)*2);
3433
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3434
 
 driver_free(rt); 
 
3348
 driver_send_term(port,caller,rt,AP);
 
3349
 driver_free(rt);
3435
3350
 driver_free(obj);
3436
 
}; break; 
3437
 
case 5458: { // glGetAttribLocation 
 
3351
}; break;
 
3352
case 5458: { // glGetAttribLocation
3438
3353
 GLuint *program = (GLuint *) bp; bp += 4;
3439
3354
 GLchar *name = (GLchar *) bp;
3440
 
 int nameLen = strlen((char *)name); bp += nameLen+1+((8-((1+nameLen+4)%8))%8);
 
3355
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+4)%8))%8);
3441
3356
 GLint result = weglGetAttribLocation(*program,name);
3442
3357
 int AP = 0; ErlDrvTermData rt[6];
3443
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3358
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3444
3359
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
3445
3360
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3446
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
3447
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3448
 
}; break; 
3449
 
case 5459: { // glGetProgramiv 
 
3361
 driver_send_term(port,caller,rt,AP);
 
3362
}; break;
 
3363
case 5459: { // glGetProgramiv
3450
3364
 GLuint *program = (GLuint *) bp; bp += 4;
3451
3365
 GLenum *pname = (GLenum *) bp; bp += 4;
3452
3366
 GLint params[1] = {0};
3453
3367
 weglGetProgramiv(*program,*pname,params);
3454
3368
 int AP = 0; ErlDrvTermData rt[6];
3455
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3369
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3456
3370
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *params;
3457
3371
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3458
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
3459
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3460
 
}; break; 
3461
 
case 5460: { // glGetProgramInfoLog 
 
3372
 driver_send_term(port,caller,rt,AP);
 
3373
}; break;
 
3374
case 5460: { // glGetProgramInfoLog
3462
3375
 GLuint *program = (GLuint *) bp; bp += 4;
3463
3376
 GLsizei *bufSize = (GLsizei *) bp; bp += 4;
3464
3377
 GLsizei length[1] = {0};
3466
3379
 infoLog = (GLchar *) driver_alloc(sizeof(GLchar) * *bufSize);
3467
3380
 weglGetProgramInfoLog(*program,*bufSize,length,infoLog);
3468
3381
 int AP = 0; ErlDrvTermData rt[7];
3469
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3382
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3470
3383
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) infoLog; rt[AP++] = *length;
3471
3384
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3472
 
 if (AP != 7 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7);
3473
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
 
3385
 driver_send_term(port,caller,rt,AP);
3474
3386
 driver_free(infoLog);
3475
 
}; break; 
3476
 
case 5461: { // glGetShaderiv 
 
3387
}; break;
 
3388
case 5461: { // glGetShaderiv
3477
3389
 GLuint *shader = (GLuint *) bp; bp += 4;
3478
3390
 GLenum *pname = (GLenum *) bp; bp += 4;
3479
3391
 GLint params[1] = {0};
3480
3392
 weglGetShaderiv(*shader,*pname,params);
3481
3393
 int AP = 0; ErlDrvTermData rt[6];
3482
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3394
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3483
3395
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *params;
3484
3396
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3485
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
3486
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3487
 
}; break; 
3488
 
case 5462: { // glGetShaderInfoLog 
 
3397
 driver_send_term(port,caller,rt,AP);
 
3398
}; break;
 
3399
case 5462: { // glGetShaderInfoLog
3489
3400
 GLuint *shader = (GLuint *) bp; bp += 4;
3490
3401
 GLsizei *bufSize = (GLsizei *) bp; bp += 4;
3491
3402
 GLsizei length[1] = {0};
3493
3404
 infoLog = (GLchar *) driver_alloc(sizeof(GLchar) * *bufSize);
3494
3405
 weglGetShaderInfoLog(*shader,*bufSize,length,infoLog);
3495
3406
 int AP = 0; ErlDrvTermData rt[7];
3496
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3407
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3497
3408
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) infoLog; rt[AP++] = *length;
3498
3409
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3499
 
 if (AP != 7 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7);
3500
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
 
3410
 driver_send_term(port,caller,rt,AP);
3501
3411
 driver_free(infoLog);
3502
 
}; break; 
3503
 
case 5463: { // glGetShaderSource 
 
3412
}; break;
 
3413
case 5463: { // glGetShaderSource
3504
3414
 GLuint *shader = (GLuint *) bp; bp += 4;
3505
3415
 GLsizei *bufSize = (GLsizei *) bp; bp += 4;
3506
3416
 GLsizei length[1] = {0};
3508
3418
 source = (GLchar *) driver_alloc(sizeof(GLchar) * *bufSize);
3509
3419
 weglGetShaderSource(*shader,*bufSize,length,source);
3510
3420
 int AP = 0; ErlDrvTermData rt[7];
3511
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3421
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3512
3422
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) source; rt[AP++] = *length;
3513
3423
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3514
 
 if (AP != 7 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7);
3515
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
 
3424
 driver_send_term(port,caller,rt,AP);
3516
3425
 driver_free(source);
3517
 
}; break; 
3518
 
case 5464: { // glGetUniformLocation 
 
3426
}; break;
 
3427
case 5464: { // glGetUniformLocation
3519
3428
 GLuint *program = (GLuint *) bp; bp += 4;
3520
3429
 GLchar *name = (GLchar *) bp;
3521
 
 int nameLen = strlen((char *)name); bp += nameLen+1+((8-((1+nameLen+4)%8))%8);
 
3430
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+4)%8))%8);
3522
3431
 GLint result = weglGetUniformLocation(*program,name);
3523
3432
 int AP = 0; ErlDrvTermData rt[6];
3524
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3433
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3525
3434
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
3526
3435
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3527
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
3528
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3529
 
}; break; 
3530
 
case 5465: { // glGetUniformfv 
 
3436
 driver_send_term(port,caller,rt,AP);
 
3437
}; break;
 
3438
case 5465: { // glGetUniformfv
3531
3439
 GLuint *program = (GLuint *) bp; bp += 4;
3532
3440
 GLint *location = (GLint *) bp; bp += 4;
3533
3441
 GLfloat params[16] = {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
3534
3442
 weglGetUniformfv(*program,*location,params);
3535
3443
 int AP = 0; ErlDrvTermData rt[38];
3536
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3444
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3537
3445
 GLdouble paramsConv[16], *paramsTmp = paramsConv; 
3538
3446
 for(int i=0; i < 16; i++) paramsConv[i] = (GLdouble) params[i];
3539
3447
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
3554
3462
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
3555
3463
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 16;
3556
3464
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3557
 
 if (AP != 38 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,38);
3558
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3559
 
}; break; 
3560
 
case 5466: { // glGetUniformiv 
 
3465
 driver_send_term(port,caller,rt,AP);
 
3466
}; break;
 
3467
case 5466: { // glGetUniformiv
3561
3468
 GLuint *program = (GLuint *) bp; bp += 4;
3562
3469
 GLint *location = (GLint *) bp; bp += 4;
3563
3470
 GLint params[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
3564
3471
 weglGetUniformiv(*program,*location,params);
3565
3472
 int AP = 0; ErlDrvTermData rt[38];
3566
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3473
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3567
3474
 GLint *paramsTmp = params;
3568
3475
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
3569
3476
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
3583
3490
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
3584
3491
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 16;
3585
3492
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3586
 
 if (AP != 38 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,38);
3587
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3588
 
}; break; 
3589
 
case 5467: { // glGetVertexAttribdv 
 
3493
 driver_send_term(port,caller,rt,AP);
 
3494
}; break;
 
3495
case 5467: { // glGetVertexAttribdv
3590
3496
 GLuint *index = (GLuint *) bp; bp += 4;
3591
3497
 GLenum *pname = (GLenum *) bp; bp += 4;
3592
3498
 GLdouble params[4] = {0.0,0.0,0.0,0.0};
3593
3499
 weglGetVertexAttribdv(*index,*pname,params);
3594
3500
 int AP = 0; ErlDrvTermData rt[14];
3595
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3501
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3596
3502
 GLdouble *paramsTmp = params;
3597
3503
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
3598
3504
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
3600
3506
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
3601
3507
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
3602
3508
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3603
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
3604
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3605
 
}; break; 
3606
 
case 5468: { // glGetVertexAttribfv 
 
3509
 driver_send_term(port,caller,rt,AP);
 
3510
}; break;
 
3511
case 5468: { // glGetVertexAttribfv
3607
3512
 GLuint *index = (GLuint *) bp; bp += 4;
3608
3513
 GLenum *pname = (GLenum *) bp; bp += 4;
3609
3514
 GLfloat params[4] = {0.0,0.0,0.0,0.0};
3610
3515
 weglGetVertexAttribfv(*index,*pname,params);
3611
3516
 int AP = 0; ErlDrvTermData rt[14];
3612
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3517
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3613
3518
 GLdouble paramsConv[4], *paramsTmp = paramsConv; 
3614
3519
 for(int i=0; i < 4; i++) paramsConv[i] = (GLdouble) params[i];
3615
3520
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
3618
3523
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
3619
3524
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
3620
3525
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3621
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
3622
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3623
 
}; break; 
3624
 
case 5469: { // glGetVertexAttribiv 
 
3526
 driver_send_term(port,caller,rt,AP);
 
3527
}; break;
 
3528
case 5469: { // glGetVertexAttribiv
3625
3529
 GLuint *index = (GLuint *) bp; bp += 4;
3626
3530
 GLenum *pname = (GLenum *) bp; bp += 4;
3627
3531
 GLint params[4] = {0,0,0,0};
3628
3532
 weglGetVertexAttribiv(*index,*pname,params);
3629
3533
 int AP = 0; ErlDrvTermData rt[14];
3630
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3534
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3631
3535
 GLint *paramsTmp = params;
3632
3536
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
3633
3537
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
3635
3539
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
3636
3540
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
3637
3541
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3638
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
3639
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3640
 
}; break; 
3641
 
case 5470: { // glIsProgram 
 
3542
 driver_send_term(port,caller,rt,AP);
 
3543
}; break;
 
3544
case 5470: { // glIsProgram
3642
3545
 GLuint *program = (GLuint *) bp; bp += 4;
3643
3546
 GLboolean result = weglIsProgram(*program);
3644
3547
 int AP = 0; ErlDrvTermData rt[6];
3645
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3548
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3646
3549
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
3647
3550
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3648
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
3649
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3650
 
}; break; 
3651
 
case 5471: { // glIsShader 
 
3551
 driver_send_term(port,caller,rt,AP);
 
3552
}; break;
 
3553
case 5471: { // glIsShader
3652
3554
 GLuint *shader = (GLuint *) bp; bp += 4;
3653
3555
 GLboolean result = weglIsShader(*shader);
3654
3556
 int AP = 0; ErlDrvTermData rt[6];
3655
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3557
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
3656
3558
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
3657
3559
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
3658
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
3659
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
3660
 
}; break; 
3661
 
case 5472: { // glLinkProgram 
 
3560
 driver_send_term(port,caller,rt,AP);
 
3561
}; break;
 
3562
case 5472: { // glLinkProgram
3662
3563
 GLuint *program = (GLuint *) bp; bp += 4;
3663
3564
 weglLinkProgram(*program);
3664
 
}; break; 
3665
 
case 5473: { // glShaderSource 
 
3565
}; break;
 
3566
case 5473: { // glShaderSource
3666
3567
 GLuint *shader = (GLuint *) bp; bp += 4;
3667
3568
 int * stringLen = (int *) bp; bp += 4;
3668
3569
 int * stringTotSize = (int *) bp; bp += 4;
3669
3570
 GLchar **string;
3670
 
 string = (GLchar **) driver_alloc(sizeof(GLchar *) * *stringLen); 
 
3571
 string = (GLchar **) driver_alloc(sizeof(GLchar *) * *stringLen);
3671
3572
 for(int i=0;i<*stringLen;i++) {
3672
3573
    string[i] = (GLchar *) bp; bp += 1+strlen(bp);};
3673
3574
 bp += (8 - ((0 + *stringTotSize) % 8)) % 8;
3674
3575
 weglShaderSource(*shader,*stringLen,(const GLchar **) string,NULL);
3675
3576
 driver_free(string);
3676
 
}; break; 
3677
 
case 5474: { // glUseProgram 
 
3577
}; break;
 
3578
case 5474: { // glUseProgram
3678
3579
 GLuint *program = (GLuint *) bp; bp += 4;
3679
3580
 weglUseProgram(*program);
3680
 
}; break; 
3681
 
case 5475: { // glUniform1f 
 
3581
}; break;
 
3582
case 5475: { // glUniform1f
3682
3583
 GLint *location = (GLint *) bp; bp += 4;
3683
3584
 GLfloat *v0 = (GLfloat *) bp; bp += 4;
3684
3585
 weglUniform1f(*location,*v0);
3685
 
}; break; 
3686
 
case 5476: { // glUniform2f 
 
3586
}; break;
 
3587
case 5476: { // glUniform2f
3687
3588
 GLint *location = (GLint *) bp; bp += 4;
3688
3589
 GLfloat *v0 = (GLfloat *) bp; bp += 4;
3689
3590
 GLfloat *v1 = (GLfloat *) bp; bp += 4;
3690
3591
 weglUniform2f(*location,*v0,*v1);
3691
 
}; break; 
3692
 
case 5477: { // glUniform3f 
 
3592
}; break;
 
3593
case 5477: { // glUniform3f
3693
3594
 GLint *location = (GLint *) bp; bp += 4;
3694
3595
 GLfloat *v0 = (GLfloat *) bp; bp += 4;
3695
3596
 GLfloat *v1 = (GLfloat *) bp; bp += 4;
3696
3597
 GLfloat *v2 = (GLfloat *) bp; bp += 4;
3697
3598
 weglUniform3f(*location,*v0,*v1,*v2);
3698
 
}; break; 
3699
 
case 5478: { // glUniform4f 
 
3599
}; break;
 
3600
case 5478: { // glUniform4f
3700
3601
 GLint *location = (GLint *) bp; bp += 4;
3701
3602
 GLfloat *v0 = (GLfloat *) bp; bp += 4;
3702
3603
 GLfloat *v1 = (GLfloat *) bp; bp += 4;
3703
3604
 GLfloat *v2 = (GLfloat *) bp; bp += 4;
3704
3605
 GLfloat *v3 = (GLfloat *) bp; bp += 4;
3705
3606
 weglUniform4f(*location,*v0,*v1,*v2,*v3);
3706
 
}; break; 
3707
 
case 5479: { // glUniform1i 
 
3607
}; break;
 
3608
case 5479: { // glUniform1i
3708
3609
 GLint *location = (GLint *) bp; bp += 4;
3709
3610
 GLint *v0 = (GLint *) bp; bp += 4;
3710
3611
 weglUniform1i(*location,*v0);
3711
 
}; break; 
3712
 
case 5480: { // glUniform2i 
 
3612
}; break;
 
3613
case 5480: { // glUniform2i
3713
3614
 GLint *location = (GLint *) bp; bp += 4;
3714
3615
 GLint *v0 = (GLint *) bp; bp += 4;
3715
3616
 GLint *v1 = (GLint *) bp; bp += 4;
3716
3617
 weglUniform2i(*location,*v0,*v1);
3717
 
}; break; 
3718
 
case 5481: { // glUniform3i 
 
3618
}; break;
 
3619
case 5481: { // glUniform3i
3719
3620
 GLint *location = (GLint *) bp; bp += 4;
3720
3621
 GLint *v0 = (GLint *) bp; bp += 4;
3721
3622
 GLint *v1 = (GLint *) bp; bp += 4;
3722
3623
 GLint *v2 = (GLint *) bp; bp += 4;
3723
3624
 weglUniform3i(*location,*v0,*v1,*v2);
3724
 
}; break; 
3725
 
case 5482: { // glUniform4i 
 
3625
}; break;
 
3626
case 5482: { // glUniform4i
3726
3627
 GLint *location = (GLint *) bp; bp += 4;
3727
3628
 GLint *v0 = (GLint *) bp; bp += 4;
3728
3629
 GLint *v1 = (GLint *) bp; bp += 4;
3729
3630
 GLint *v2 = (GLint *) bp; bp += 4;
3730
3631
 GLint *v3 = (GLint *) bp; bp += 4;
3731
3632
 weglUniform4i(*location,*v0,*v1,*v2,*v3);
3732
 
}; break; 
3733
 
case 5483: { // glUniform1fv 
 
3633
}; break;
 
3634
case 5483: { // glUniform1fv
3734
3635
 GLint *location = (GLint *) bp; bp += 4;
3735
3636
 int * valueLen = (int *) bp; bp += 4;
3736
3637
 GLfloat * value = (GLfloat *) bp;  bp += (8-((*valueLen*4+0)%8))%8;
3737
3638
 weglUniform1fv(*location,*valueLen,value);
3738
 
}; break; 
3739
 
case 5484: { // glUniform2fv 
 
3639
}; break;
 
3640
case 5484: { // glUniform2fv
3740
3641
 GLint *location = (GLint *) bp; bp += 4;
3741
3642
 int *valueLen = (int *) bp; bp += 4;
3742
3643
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*8;
3743
3644
 weglUniform2fv(*location,*valueLen,value);
3744
 
}; break; 
3745
 
case 5485: { // glUniform3fv 
 
3645
}; break;
 
3646
case 5485: { // glUniform3fv
3746
3647
 GLint *location = (GLint *) bp; bp += 4;
3747
3648
 int *valueLen = (int *) bp; bp += 4;
3748
3649
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*12;
3749
3650
 weglUniform3fv(*location,*valueLen,value);
3750
 
}; break; 
3751
 
case 5486: { // glUniform4fv 
 
3651
}; break;
 
3652
case 5486: { // glUniform4fv
3752
3653
 GLint *location = (GLint *) bp; bp += 4;
3753
3654
 int *valueLen = (int *) bp; bp += 4;
3754
3655
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*16;
3755
3656
 weglUniform4fv(*location,*valueLen,value);
3756
 
}; break; 
3757
 
case 5487: { // glUniform1iv 
 
3657
}; break;
 
3658
case 5487: { // glUniform1iv
3758
3659
 GLint *location = (GLint *) bp; bp += 4;
3759
3660
 int * valueLen = (int *) bp; bp += 4;
3760
3661
 GLint * value = (GLint *) bp;  bp += (8-((*valueLen*4+0)%8))%8;
3761
3662
 weglUniform1iv(*location,*valueLen,value);
3762
 
}; break; 
3763
 
case 5488: { // glUniform2iv 
 
3663
}; break;
 
3664
case 5488: { // glUniform2iv
3764
3665
 GLint *location = (GLint *) bp; bp += 4;
3765
3666
 int *valueLen = (int *) bp; bp += 4;
3766
3667
 GLint * value = (GLint *) bp; bp += *valueLen*8;
3767
3668
 weglUniform2iv(*location,*valueLen,value);
3768
 
}; break; 
3769
 
case 5489: { // glUniform3iv 
 
3669
}; break;
 
3670
case 5489: { // glUniform3iv
3770
3671
 GLint *location = (GLint *) bp; bp += 4;
3771
3672
 int *valueLen = (int *) bp; bp += 4;
3772
3673
 GLint * value = (GLint *) bp; bp += *valueLen*12;
3773
3674
 weglUniform3iv(*location,*valueLen,value);
3774
 
}; break; 
3775
 
case 5490: { // glUniform4iv 
 
3675
}; break;
 
3676
case 5490: { // glUniform4iv
3776
3677
 GLint *location = (GLint *) bp; bp += 4;
3777
3678
 int *valueLen = (int *) bp; bp += 4;
3778
3679
 GLint * value = (GLint *) bp; bp += *valueLen*16;
3779
3680
 weglUniform4iv(*location,*valueLen,value);
3780
 
}; break; 
3781
 
case 5491: { // glUniformMatrix2fv 
 
3681
}; break;
 
3682
case 5491: { // glUniformMatrix2fv
3782
3683
 GLint *location = (GLint *) bp; bp += 4;
3783
3684
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
3784
3685
 bp += 3;
3785
3686
 int *valueLen = (int *) bp; bp += 4;
3786
3687
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*16;
3787
3688
 weglUniformMatrix2fv(*location,*valueLen,*transpose,value);
3788
 
}; break; 
3789
 
case 5492: { // glUniformMatrix3fv 
 
3689
}; break;
 
3690
case 5492: { // glUniformMatrix3fv
3790
3691
 GLint *location = (GLint *) bp; bp += 4;
3791
3692
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
3792
3693
 bp += 3;
3793
3694
 int *valueLen = (int *) bp; bp += 4;
3794
3695
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*36;
3795
3696
 weglUniformMatrix3fv(*location,*valueLen,*transpose,value);
3796
 
}; break; 
3797
 
case 5493: { // glUniformMatrix4fv 
 
3697
}; break;
 
3698
case 5493: { // glUniformMatrix4fv
3798
3699
 GLint *location = (GLint *) bp; bp += 4;
3799
3700
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
3800
3701
 bp += 3;
3801
3702
 int *valueLen = (int *) bp; bp += 4;
3802
3703
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*64;
3803
3704
 weglUniformMatrix4fv(*location,*valueLen,*transpose,value);
3804
 
}; break; 
3805
 
case 5494: { // glValidateProgram 
 
3705
}; break;
 
3706
case 5494: { // glValidateProgram
3806
3707
 GLuint *program = (GLuint *) bp; bp += 4;
3807
3708
 weglValidateProgram(*program);
3808
 
}; break; 
3809
 
case 5495: { // glVertexAttrib1dv 
 
3709
}; break;
 
3710
case 5495: { // glVertexAttrib1dv
3810
3711
 GLuint *index = (GLuint *) bp; bp += 4;
3811
3712
 bp += 4;
3812
3713
 GLdouble *v = (GLdouble *) bp; bp += 8;
3813
3714
 weglVertexAttrib1dv(*index,v);
3814
 
}; break; 
3815
 
case 5496: { // glVertexAttrib1fv 
 
3715
}; break;
 
3716
case 5496: { // glVertexAttrib1fv
3816
3717
 GLuint *index = (GLuint *) bp; bp += 4;
3817
3718
 GLfloat *v = (GLfloat *) bp; bp += 4;
3818
3719
 weglVertexAttrib1fv(*index,v);
3819
 
}; break; 
3820
 
case 5497: { // glVertexAttrib1sv 
 
3720
}; break;
 
3721
case 5497: { // glVertexAttrib1sv
3821
3722
 GLuint *index = (GLuint *) bp; bp += 4;
3822
3723
 GLshort *v = (GLshort *) bp; bp += 2;
3823
3724
 weglVertexAttrib1sv(*index,v);
3824
 
}; break; 
3825
 
case 5498: { // glVertexAttrib2dv 
 
3725
}; break;
 
3726
case 5498: { // glVertexAttrib2dv
3826
3727
 GLuint *index = (GLuint *) bp; bp += 4;
3827
3728
 bp += 4;
3828
3729
 GLdouble *v = (GLdouble *) bp; bp += 8;
3829
3730
 weglVertexAttrib2dv(*index,v);
3830
 
}; break; 
3831
 
case 5499: { // glVertexAttrib2fv 
 
3731
}; break;
 
3732
case 5499: { // glVertexAttrib2fv
3832
3733
 GLuint *index = (GLuint *) bp; bp += 4;
3833
3734
 GLfloat *v = (GLfloat *) bp; bp += 4;
3834
3735
 weglVertexAttrib2fv(*index,v);
3835
 
}; break; 
3836
 
case 5500: { // glVertexAttrib2sv 
 
3736
}; break;
 
3737
case 5500: { // glVertexAttrib2sv
3837
3738
 GLuint *index = (GLuint *) bp; bp += 4;
3838
3739
 GLshort *v = (GLshort *) bp; bp += 2;
3839
3740
 weglVertexAttrib2sv(*index,v);
3840
 
}; break; 
3841
 
case 5501: { // glVertexAttrib3dv 
 
3741
}; break;
 
3742
case 5501: { // glVertexAttrib3dv
3842
3743
 GLuint *index = (GLuint *) bp; bp += 4;
3843
3744
 bp += 4;
3844
3745
 GLdouble *v = (GLdouble *) bp; bp += 8;
3845
3746
 weglVertexAttrib3dv(*index,v);
3846
 
}; break; 
3847
 
case 5502: { // glVertexAttrib3fv 
 
3747
}; break;
 
3748
case 5502: { // glVertexAttrib3fv
3848
3749
 GLuint *index = (GLuint *) bp; bp += 4;
3849
3750
 GLfloat *v = (GLfloat *) bp; bp += 4;
3850
3751
 weglVertexAttrib3fv(*index,v);
3851
 
}; break; 
3852
 
case 5503: { // glVertexAttrib3sv 
 
3752
}; break;
 
3753
case 5503: { // glVertexAttrib3sv
3853
3754
 GLuint *index = (GLuint *) bp; bp += 4;
3854
3755
 GLshort *v = (GLshort *) bp; bp += 2;
3855
3756
 weglVertexAttrib3sv(*index,v);
3856
 
}; break; 
3857
 
case 5504: { // glVertexAttrib4Nbv 
 
3757
}; break;
 
3758
case 5504: { // glVertexAttrib4Nbv
3858
3759
 GLuint *index = (GLuint *) bp; bp += 4;
3859
3760
 GLbyte * v = (GLbyte *) bp; bp += 4;
3860
3761
 weglVertexAttrib4Nbv(*index,v);
3861
 
}; break; 
3862
 
case 5505: { // glVertexAttrib4Niv 
 
3762
}; break;
 
3763
case 5505: { // glVertexAttrib4Niv
3863
3764
 GLuint *index = (GLuint *) bp; bp += 4;
3864
3765
 GLint * v = (GLint *) bp; bp += 16;
3865
3766
 weglVertexAttrib4Niv(*index,v);
3866
 
}; break; 
3867
 
case 5506: { // glVertexAttrib4Nsv 
 
3767
}; break;
 
3768
case 5506: { // glVertexAttrib4Nsv
3868
3769
 GLuint *index = (GLuint *) bp; bp += 4;
3869
3770
 GLshort * v = (GLshort *) bp; bp += 8;
3870
3771
 weglVertexAttrib4Nsv(*index,v);
3871
 
}; break; 
3872
 
case 5507: { // glVertexAttrib4Nubv 
 
3772
}; break;
 
3773
case 5507: { // glVertexAttrib4Nubv
3873
3774
 GLuint *index = (GLuint *) bp; bp += 4;
3874
3775
 GLubyte * v = (GLubyte *) bp; bp += 4;
3875
3776
 weglVertexAttrib4Nubv(*index,v);
3876
 
}; break; 
3877
 
case 5508: { // glVertexAttrib4Nuiv 
 
3777
}; break;
 
3778
case 5508: { // glVertexAttrib4Nuiv
3878
3779
 GLuint *index = (GLuint *) bp; bp += 4;
3879
3780
 GLuint * v = (GLuint *) bp; bp += 16;
3880
3781
 weglVertexAttrib4Nuiv(*index,v);
3881
 
}; break; 
3882
 
case 5509: { // glVertexAttrib4Nusv 
 
3782
}; break;
 
3783
case 5509: { // glVertexAttrib4Nusv
3883
3784
 GLuint *index = (GLuint *) bp; bp += 4;
3884
3785
 GLushort * v = (GLushort *) bp; bp += 8;
3885
3786
 weglVertexAttrib4Nusv(*index,v);
3886
 
}; break; 
3887
 
case 5510: { // glVertexAttrib4bv 
 
3787
}; break;
 
3788
case 5510: { // glVertexAttrib4bv
3888
3789
 GLuint *index = (GLuint *) bp; bp += 4;
3889
3790
 GLbyte * v = (GLbyte *) bp; bp += 4;
3890
3791
 weglVertexAttrib4bv(*index,v);
3891
 
}; break; 
3892
 
case 5511: { // glVertexAttrib4dv 
 
3792
}; break;
 
3793
case 5511: { // glVertexAttrib4dv
3893
3794
 GLuint *index = (GLuint *) bp; bp += 4;
3894
3795
 bp += 4;
3895
3796
 GLdouble * v = (GLdouble *) bp; bp += 32;
3896
3797
 weglVertexAttrib4dv(*index,v);
3897
 
}; break; 
3898
 
case 5512: { // glVertexAttrib4fv 
 
3798
}; break;
 
3799
case 5512: { // glVertexAttrib4fv
3899
3800
 GLuint *index = (GLuint *) bp; bp += 4;
3900
3801
 GLfloat * v = (GLfloat *) bp; bp += 16;
3901
3802
 weglVertexAttrib4fv(*index,v);
3902
 
}; break; 
3903
 
case 5513: { // glVertexAttrib4iv 
 
3803
}; break;
 
3804
case 5513: { // glVertexAttrib4iv
3904
3805
 GLuint *index = (GLuint *) bp; bp += 4;
3905
3806
 GLint * v = (GLint *) bp; bp += 16;
3906
3807
 weglVertexAttrib4iv(*index,v);
3907
 
}; break; 
3908
 
case 5514: { // glVertexAttrib4sv 
 
3808
}; break;
 
3809
case 5514: { // glVertexAttrib4sv
3909
3810
 GLuint *index = (GLuint *) bp; bp += 4;
3910
3811
 GLshort * v = (GLshort *) bp; bp += 8;
3911
3812
 weglVertexAttrib4sv(*index,v);
3912
 
}; break; 
3913
 
case 5515: { // glVertexAttrib4ubv 
 
3813
}; break;
 
3814
case 5515: { // glVertexAttrib4ubv
3914
3815
 GLuint *index = (GLuint *) bp; bp += 4;
3915
3816
 GLubyte * v = (GLubyte *) bp; bp += 4;
3916
3817
 weglVertexAttrib4ubv(*index,v);
3917
 
}; break; 
3918
 
case 5516: { // glVertexAttrib4uiv 
 
3818
}; break;
 
3819
case 5516: { // glVertexAttrib4uiv
3919
3820
 GLuint *index = (GLuint *) bp; bp += 4;
3920
3821
 GLuint * v = (GLuint *) bp; bp += 16;
3921
3822
 weglVertexAttrib4uiv(*index,v);
3922
 
}; break; 
3923
 
case 5517: { // glVertexAttrib4usv 
 
3823
}; break;
 
3824
case 5517: { // glVertexAttrib4usv
3924
3825
 GLuint *index = (GLuint *) bp; bp += 4;
3925
3826
 GLushort * v = (GLushort *) bp; bp += 8;
3926
3827
 weglVertexAttrib4usv(*index,v);
3927
 
}; break; 
3928
 
case 5518: { // glVertexAttribPointer 
 
3828
}; break;
 
3829
case 5518: { // glVertexAttribPointer
3929
3830
 GLuint *index = (GLuint *) bp; bp += 4;
3930
3831
 GLint *size = (GLint *) bp; bp += 4;
3931
3832
 GLenum *type = (GLenum *) bp; bp += 4;
3934
3835
 GLsizei *stride = (GLsizei *) bp; bp += 4;
3935
3836
 GLvoid *pointer = (GLvoid *) * (int *) bp; bp += 4;
3936
3837
 weglVertexAttribPointer(*index,*size,*type,*normalized,*stride,pointer);
3937
 
}; break; 
3938
 
case 5519: { // glVertexAttribPointer 
 
3838
}; break;
 
3839
case 5519: { // glVertexAttribPointer
3939
3840
 GLuint *index = (GLuint *) bp; bp += 4;
3940
3841
 GLint *size = (GLint *) bp; bp += 4;
3941
3842
 GLenum *type = (GLenum *) bp; bp += 4;
3942
3843
 GLboolean *normalized = (GLboolean *) bp; bp += 1;
3943
3844
 bp += 3;
3944
3845
 GLsizei *stride = (GLsizei *) bp; bp += 4;
3945
 
 GLvoid *pointer = (GLvoid *) bins[0]->base;
 
3846
 GLvoid *pointer = (GLvoid *) bins[0];
3946
3847
 weglVertexAttribPointer(*index,*size,*type,*normalized,*stride,pointer);
3947
 
}; break; 
3948
 
case 5520: { // glUniformMatrix2x3fv 
 
3848
}; break;
 
3849
case 5520: { // glUniformMatrix2x3fv
3949
3850
 GLint *location = (GLint *) bp; bp += 4;
3950
3851
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
3951
3852
 bp += 3;
3952
3853
 int *valueLen = (int *) bp; bp += 4;
3953
3854
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*24;
3954
3855
 weglUniformMatrix2x3fv(*location,*valueLen,*transpose,value);
3955
 
}; break; 
3956
 
case 5521: { // glUniformMatrix3x2fv 
 
3856
}; break;
 
3857
case 5521: { // glUniformMatrix3x2fv
3957
3858
 GLint *location = (GLint *) bp; bp += 4;
3958
3859
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
3959
3860
 bp += 3;
3960
3861
 int *valueLen = (int *) bp; bp += 4;
3961
3862
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*24;
3962
3863
 weglUniformMatrix3x2fv(*location,*valueLen,*transpose,value);
3963
 
}; break; 
3964
 
case 5522: { // glUniformMatrix2x4fv 
 
3864
}; break;
 
3865
case 5522: { // glUniformMatrix2x4fv
3965
3866
 GLint *location = (GLint *) bp; bp += 4;
3966
3867
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
3967
3868
 bp += 3;
3968
3869
 int *valueLen = (int *) bp; bp += 4;
3969
3870
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*32;
3970
3871
 weglUniformMatrix2x4fv(*location,*valueLen,*transpose,value);
3971
 
}; break; 
3972
 
case 5523: { // glUniformMatrix4x2fv 
 
3872
}; break;
 
3873
case 5523: { // glUniformMatrix4x2fv
3973
3874
 GLint *location = (GLint *) bp; bp += 4;
3974
3875
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
3975
3876
 bp += 3;
3976
3877
 int *valueLen = (int *) bp; bp += 4;
3977
3878
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*32;
3978
3879
 weglUniformMatrix4x2fv(*location,*valueLen,*transpose,value);
3979
 
}; break; 
3980
 
case 5524: { // glUniformMatrix3x4fv 
 
3880
}; break;
 
3881
case 5524: { // glUniformMatrix3x4fv
3981
3882
 GLint *location = (GLint *) bp; bp += 4;
3982
3883
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
3983
3884
 bp += 3;
3984
3885
 int *valueLen = (int *) bp; bp += 4;
3985
3886
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*48;
3986
3887
 weglUniformMatrix3x4fv(*location,*valueLen,*transpose,value);
3987
 
}; break; 
3988
 
case 5525: { // glUniformMatrix4x3fv 
 
3888
}; break;
 
3889
case 5525: { // glUniformMatrix4x3fv
3989
3890
 GLint *location = (GLint *) bp; bp += 4;
3990
3891
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
3991
3892
 bp += 3;
3992
3893
 int *valueLen = (int *) bp; bp += 4;
3993
3894
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*48;
3994
3895
 weglUniformMatrix4x3fv(*location,*valueLen,*transpose,value);
3995
 
}; break; 
3996
 
case 5526: { // glColorMaski 
 
3896
}; break;
 
3897
case 5526: { // glColorMaski
3997
3898
 GLuint *index = (GLuint *) bp; bp += 4;
3998
3899
 GLboolean *r = (GLboolean *) bp; bp += 1;
3999
3900
 GLboolean *g = (GLboolean *) bp; bp += 1;
4000
3901
 GLboolean *b = (GLboolean *) bp; bp += 1;
4001
3902
 GLboolean *a = (GLboolean *) bp; bp += 1;
4002
3903
 weglColorMaski(*index,*r,*g,*b,*a);
4003
 
}; break; 
4004
 
case 5527: { // glGetBooleani_v 
 
3904
}; break;
 
3905
case 5527: { // glGetBooleani_v
4005
3906
 GLenum *target = (GLenum *) bp; bp += 4;
4006
3907
 GLuint *index = (GLuint *) bp; bp += 4;
4007
3908
 GLboolean data[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
4008
3909
 weglGetBooleani_v(*target,*index,data);
4009
3910
 int AP = 0; ErlDrvTermData rt[39];
4010
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3911
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4011
3912
 GLboolean *dataTmp = data;
4012
3913
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
4013
3914
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
4027
3928
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
4028
3929
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 16+1;
4029
3930
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4030
 
 if (AP != 39 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,39);
4031
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4032
 
}; break; 
4033
 
case 5528: { // glGetIntegeri_v 
 
3931
 driver_send_term(port,caller,rt,AP);
 
3932
}; break;
 
3933
case 5528: { // glGetIntegeri_v
4034
3934
 GLenum *target = (GLenum *) bp; bp += 4;
4035
3935
 GLuint *index = (GLuint *) bp; bp += 4;
4036
3936
 GLint data[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
4037
3937
 weglGetIntegeri_v(*target,*index,data);
4038
3938
 int AP = 0; ErlDrvTermData rt[39];
4039
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3939
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4040
3940
 GLint *dataTmp = data;
4041
3941
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
4042
3942
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
4056
3956
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
4057
3957
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 16+1;
4058
3958
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4059
 
 if (AP != 39 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,39);
4060
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4061
 
}; break; 
4062
 
case 5529: { // glEnablei 
 
3959
 driver_send_term(port,caller,rt,AP);
 
3960
}; break;
 
3961
case 5529: { // glEnablei
4063
3962
 GLenum *target = (GLenum *) bp; bp += 4;
4064
3963
 GLuint *index = (GLuint *) bp; bp += 4;
4065
3964
 weglEnablei(*target,*index);
4066
 
}; break; 
4067
 
case 5530: { // glDisablei 
 
3965
}; break;
 
3966
case 5530: { // glDisablei
4068
3967
 GLenum *target = (GLenum *) bp; bp += 4;
4069
3968
 GLuint *index = (GLuint *) bp; bp += 4;
4070
3969
 weglDisablei(*target,*index);
4071
 
}; break; 
4072
 
case 5531: { // glIsEnabledi 
 
3970
}; break;
 
3971
case 5531: { // glIsEnabledi
4073
3972
 GLenum *target = (GLenum *) bp; bp += 4;
4074
3973
 GLuint *index = (GLuint *) bp; bp += 4;
4075
3974
 GLboolean result = weglIsEnabledi(*target,*index);
4076
3975
 int AP = 0; ErlDrvTermData rt[6];
4077
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
3976
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4078
3977
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
4079
3978
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4080
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
4081
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4082
 
}; break; 
4083
 
case 5532: { // glBeginTransformFeedback 
 
3979
 driver_send_term(port,caller,rt,AP);
 
3980
}; break;
 
3981
case 5532: { // glBeginTransformFeedback
4084
3982
 GLenum *primitiveMode = (GLenum *) bp; bp += 4;
4085
3983
 weglBeginTransformFeedback(*primitiveMode);
4086
 
}; break; 
4087
 
case 5533: { // glEndTransformFeedback 
 
3984
}; break;
 
3985
case 5533: { // glEndTransformFeedback
4088
3986
 weglEndTransformFeedback();
4089
 
}; break; 
4090
 
case 5534: { // glBindBufferRange 
 
3987
}; break;
 
3988
case 5534: { // glBindBufferRange
4091
3989
 GLenum *target = (GLenum *) bp; bp += 4;
4092
3990
 GLuint *index = (GLuint *) bp; bp += 4;
4093
3991
 GLuint *buffer = (GLuint *) bp; bp += 4;
4095
3993
 GLintptr offset = (GLintptr) * (GLuint64EXT *) bp; bp += 8;
4096
3994
 GLsizeiptr size = (GLsizeiptr) * (GLuint64EXT *) bp; bp += 8;
4097
3995
 weglBindBufferRange(*target,*index,*buffer,offset,size);
4098
 
}; break; 
4099
 
case 5535: { // glBindBufferBase 
 
3996
}; break;
 
3997
case 5535: { // glBindBufferBase
4100
3998
 GLenum *target = (GLenum *) bp; bp += 4;
4101
3999
 GLuint *index = (GLuint *) bp; bp += 4;
4102
4000
 GLuint *buffer = (GLuint *) bp; bp += 4;
4103
4001
 weglBindBufferBase(*target,*index,*buffer);
4104
 
}; break; 
4105
 
case 5536: { // glTransformFeedbackVaryings 
 
4002
}; break;
 
4003
case 5536: { // glTransformFeedbackVaryings
4106
4004
 GLuint *program = (GLuint *) bp; bp += 4;
4107
4005
 int * varyingsLen = (int *) bp; bp += 4;
4108
4006
 int * varyingsTotSize = (int *) bp; bp += 4;
4109
4007
 GLchar **varyings;
4110
 
 varyings = (GLchar **) driver_alloc(sizeof(GLchar *) * *varyingsLen); 
 
4008
 varyings = (GLchar **) driver_alloc(sizeof(GLchar *) * *varyingsLen);
4111
4009
 for(int i=0;i<*varyingsLen;i++) {
4112
4010
    varyings[i] = (GLchar *) bp; bp += 1+strlen(bp);};
4113
4011
 bp += (8 - ((0 + *varyingsTotSize) % 8)) % 8;
4114
4012
 GLenum *bufferMode = (GLenum *) bp; bp += 4;
4115
4013
 weglTransformFeedbackVaryings(*program,*varyingsLen,(const GLchar **) varyings,*bufferMode);
4116
4014
 driver_free(varyings);
4117
 
}; break; 
4118
 
case 5537: { // glGetTransformFeedbackVarying 
 
4015
}; break;
 
4016
case 5537: { // glGetTransformFeedbackVarying
4119
4017
 GLuint *program = (GLuint *) bp; bp += 4;
4120
4018
 GLuint *index = (GLuint *) bp; bp += 4;
4121
4019
 GLsizei *bufSize = (GLsizei *) bp; bp += 4;
4126
4024
 name = (GLchar *) driver_alloc(sizeof(GLchar) * *bufSize);
4127
4025
 weglGetTransformFeedbackVarying(*program,*index,*bufSize,length,size,type,name);
4128
4026
 int AP = 0; ErlDrvTermData rt[13];
4129
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4027
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4130
4028
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *size;
4131
4029
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *type;
4132
4030
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) name; rt[AP++] = *length;
4133
4031
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 3;
4134
4032
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4135
 
 if (AP != 13 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,13);
4136
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
 
4033
 driver_send_term(port,caller,rt,AP);
4137
4034
 driver_free(name);
4138
 
}; break; 
4139
 
case 5538: { // glClampColor 
 
4035
}; break;
 
4036
case 5538: { // glClampColor
4140
4037
 GLenum *target = (GLenum *) bp; bp += 4;
4141
4038
 GLenum *clamp = (GLenum *) bp; bp += 4;
4142
4039
 weglClampColor(*target,*clamp);
4143
 
}; break; 
4144
 
case 5539: { // glBeginConditionalRender 
 
4040
}; break;
 
4041
case 5539: { // glBeginConditionalRender
4145
4042
 GLuint *id = (GLuint *) bp; bp += 4;
4146
4043
 GLenum *mode = (GLenum *) bp; bp += 4;
4147
4044
 weglBeginConditionalRender(*id,*mode);
4148
 
}; break; 
4149
 
case 5540: { // glEndConditionalRender 
 
4045
}; break;
 
4046
case 5540: { // glEndConditionalRender
4150
4047
 weglEndConditionalRender();
4151
 
}; break; 
4152
 
case 5541: { // glVertexAttribIPointer 
 
4048
}; break;
 
4049
case 5541: { // glVertexAttribIPointer
4153
4050
 GLuint *index = (GLuint *) bp; bp += 4;
4154
4051
 GLint *size = (GLint *) bp; bp += 4;
4155
4052
 GLenum *type = (GLenum *) bp; bp += 4;
4156
4053
 GLsizei *stride = (GLsizei *) bp; bp += 4;
4157
4054
 GLvoid *pointer = (GLvoid *) * (int *) bp; bp += 4;
4158
4055
 weglVertexAttribIPointer(*index,*size,*type,*stride,pointer);
4159
 
}; break; 
4160
 
case 5542: { // glVertexAttribIPointer 
 
4056
}; break;
 
4057
case 5542: { // glVertexAttribIPointer
4161
4058
 GLuint *index = (GLuint *) bp; bp += 4;
4162
4059
 GLint *size = (GLint *) bp; bp += 4;
4163
4060
 GLenum *type = (GLenum *) bp; bp += 4;
4164
4061
 GLsizei *stride = (GLsizei *) bp; bp += 4;
4165
 
 GLvoid *pointer = (GLvoid *) bins[0]->base;
 
4062
 GLvoid *pointer = (GLvoid *) bins[0];
4166
4063
 weglVertexAttribIPointer(*index,*size,*type,*stride,pointer);
4167
 
}; break; 
4168
 
case 5543: { // glGetVertexAttribIiv 
 
4064
}; break;
 
4065
case 5543: { // glGetVertexAttribIiv
4169
4066
 GLuint *index = (GLuint *) bp; bp += 4;
4170
4067
 GLenum *pname = (GLenum *) bp; bp += 4;
4171
4068
 GLint params[4] = {0,0,0,0};
4172
4069
 weglGetVertexAttribIiv(*index,*pname,params);
4173
4070
 int AP = 0; ErlDrvTermData rt[14];
4174
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4071
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4175
4072
 GLint *paramsTmp = params;
4176
4073
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4177
4074
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4179
4076
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4180
4077
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
4181
4078
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4182
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
4183
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4184
 
}; break; 
4185
 
case 5544: { // glGetVertexAttribIuiv 
 
4079
 driver_send_term(port,caller,rt,AP);
 
4080
}; break;
 
4081
case 5544: { // glGetVertexAttribIuiv
4186
4082
 GLuint *index = (GLuint *) bp; bp += 4;
4187
4083
 GLenum *pname = (GLenum *) bp; bp += 4;
4188
4084
 GLuint params[4] = {0,0,0,0};
4189
4085
 weglGetVertexAttribIuiv(*index,*pname,params);
4190
4086
 int AP = 0; ErlDrvTermData rt[14];
4191
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4087
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4192
4088
 GLuint *paramsTmp = params;
4193
4089
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4194
4090
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4196
4092
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4197
4093
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
4198
4094
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4199
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
4200
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4201
 
}; break; 
4202
 
case 5545: { // glGetUniformuiv 
 
4095
 driver_send_term(port,caller,rt,AP);
 
4096
}; break;
 
4097
case 5545: { // glVertexAttribI1iv
 
4098
 GLuint *index = (GLuint *) bp; bp += 4;
 
4099
 GLint *v = (GLint *) bp; bp += 4;
 
4100
 weglVertexAttribI1iv(*index,v);
 
4101
}; break;
 
4102
case 5546: { // glVertexAttribI2iv
 
4103
 GLuint *index = (GLuint *) bp; bp += 4;
 
4104
 GLint *v = (GLint *) bp; bp += 4;
 
4105
 weglVertexAttribI2iv(*index,v);
 
4106
}; break;
 
4107
case 5547: { // glVertexAttribI3iv
 
4108
 GLuint *index = (GLuint *) bp; bp += 4;
 
4109
 GLint *v = (GLint *) bp; bp += 4;
 
4110
 weglVertexAttribI3iv(*index,v);
 
4111
}; break;
 
4112
case 5548: { // glVertexAttribI4iv
 
4113
 GLuint *index = (GLuint *) bp; bp += 4;
 
4114
 GLint * v = (GLint *) bp; bp += 16;
 
4115
 weglVertexAttribI4iv(*index,v);
 
4116
}; break;
 
4117
case 5549: { // glVertexAttribI1uiv
 
4118
 GLuint *index = (GLuint *) bp; bp += 4;
 
4119
 GLuint *v = (GLuint *) bp; bp += 4;
 
4120
 weglVertexAttribI1uiv(*index,v);
 
4121
}; break;
 
4122
case 5550: { // glVertexAttribI2uiv
 
4123
 GLuint *index = (GLuint *) bp; bp += 4;
 
4124
 GLuint *v = (GLuint *) bp; bp += 4;
 
4125
 weglVertexAttribI2uiv(*index,v);
 
4126
}; break;
 
4127
case 5551: { // glVertexAttribI3uiv
 
4128
 GLuint *index = (GLuint *) bp; bp += 4;
 
4129
 GLuint *v = (GLuint *) bp; bp += 4;
 
4130
 weglVertexAttribI3uiv(*index,v);
 
4131
}; break;
 
4132
case 5552: { // glVertexAttribI4uiv
 
4133
 GLuint *index = (GLuint *) bp; bp += 4;
 
4134
 GLuint * v = (GLuint *) bp; bp += 16;
 
4135
 weglVertexAttribI4uiv(*index,v);
 
4136
}; break;
 
4137
case 5553: { // glVertexAttribI4bv
 
4138
 GLuint *index = (GLuint *) bp; bp += 4;
 
4139
 GLbyte * v = (GLbyte *) bp; bp += 4;
 
4140
 weglVertexAttribI4bv(*index,v);
 
4141
}; break;
 
4142
case 5554: { // glVertexAttribI4sv
 
4143
 GLuint *index = (GLuint *) bp; bp += 4;
 
4144
 GLshort * v = (GLshort *) bp; bp += 8;
 
4145
 weglVertexAttribI4sv(*index,v);
 
4146
}; break;
 
4147
case 5555: { // glVertexAttribI4ubv
 
4148
 GLuint *index = (GLuint *) bp; bp += 4;
 
4149
 GLubyte * v = (GLubyte *) bp; bp += 4;
 
4150
 weglVertexAttribI4ubv(*index,v);
 
4151
}; break;
 
4152
case 5556: { // glVertexAttribI4usv
 
4153
 GLuint *index = (GLuint *) bp; bp += 4;
 
4154
 GLushort * v = (GLushort *) bp; bp += 8;
 
4155
 weglVertexAttribI4usv(*index,v);
 
4156
}; break;
 
4157
case 5557: { // glGetUniformuiv
4203
4158
 GLuint *program = (GLuint *) bp; bp += 4;
4204
4159
 GLint *location = (GLint *) bp; bp += 4;
4205
4160
 GLuint params[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
4206
4161
 weglGetUniformuiv(*program,*location,params);
4207
4162
 int AP = 0; ErlDrvTermData rt[38];
4208
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4163
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4209
4164
 GLuint *paramsTmp = params;
4210
4165
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4211
4166
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4225
4180
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4226
4181
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 16;
4227
4182
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4228
 
 if (AP != 38 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,38);
4229
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4230
 
}; break; 
4231
 
case 5546: { // glBindFragDataLocation 
 
4183
 driver_send_term(port,caller,rt,AP);
 
4184
}; break;
 
4185
case 5558: { // glBindFragDataLocation
4232
4186
 GLuint *program = (GLuint *) bp; bp += 4;
4233
4187
 GLuint *color = (GLuint *) bp; bp += 4;
4234
4188
 GLchar *name = (GLchar *) bp;
4235
 
 int nameLen = strlen((char *)name); bp += nameLen+1+((8-((1+nameLen+0)%8))%8);
 
4189
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+0)%8))%8);
4236
4190
 weglBindFragDataLocation(*program,*color,name);
4237
 
}; break; 
4238
 
case 5547: { // glGetFragDataLocation 
 
4191
}; break;
 
4192
case 5559: { // glGetFragDataLocation
4239
4193
 GLuint *program = (GLuint *) bp; bp += 4;
4240
4194
 GLchar *name = (GLchar *) bp;
4241
 
 int nameLen = strlen((char *)name); bp += nameLen+1+((8-((1+nameLen+4)%8))%8);
 
4195
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+4)%8))%8);
4242
4196
 GLint result = weglGetFragDataLocation(*program,name);
4243
4197
 int AP = 0; ErlDrvTermData rt[6];
4244
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4198
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4245
4199
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
4246
4200
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4247
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
4248
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4249
 
}; break; 
4250
 
case 5548: { // glUniform1ui 
 
4201
 driver_send_term(port,caller,rt,AP);
 
4202
}; break;
 
4203
case 5560: { // glUniform1ui
4251
4204
 GLint *location = (GLint *) bp; bp += 4;
4252
4205
 GLuint *v0 = (GLuint *) bp; bp += 4;
4253
4206
 weglUniform1ui(*location,*v0);
4254
 
}; break; 
4255
 
case 5549: { // glUniform2ui 
 
4207
}; break;
 
4208
case 5561: { // glUniform2ui
4256
4209
 GLint *location = (GLint *) bp; bp += 4;
4257
4210
 GLuint *v0 = (GLuint *) bp; bp += 4;
4258
4211
 GLuint *v1 = (GLuint *) bp; bp += 4;
4259
4212
 weglUniform2ui(*location,*v0,*v1);
4260
 
}; break; 
4261
 
case 5550: { // glUniform3ui 
 
4213
}; break;
 
4214
case 5562: { // glUniform3ui
4262
4215
 GLint *location = (GLint *) bp; bp += 4;
4263
4216
 GLuint *v0 = (GLuint *) bp; bp += 4;
4264
4217
 GLuint *v1 = (GLuint *) bp; bp += 4;
4265
4218
 GLuint *v2 = (GLuint *) bp; bp += 4;
4266
4219
 weglUniform3ui(*location,*v0,*v1,*v2);
4267
 
}; break; 
4268
 
case 5551: { // glUniform4ui 
 
4220
}; break;
 
4221
case 5563: { // glUniform4ui
4269
4222
 GLint *location = (GLint *) bp; bp += 4;
4270
4223
 GLuint *v0 = (GLuint *) bp; bp += 4;
4271
4224
 GLuint *v1 = (GLuint *) bp; bp += 4;
4272
4225
 GLuint *v2 = (GLuint *) bp; bp += 4;
4273
4226
 GLuint *v3 = (GLuint *) bp; bp += 4;
4274
4227
 weglUniform4ui(*location,*v0,*v1,*v2,*v3);
4275
 
}; break; 
4276
 
case 5552: { // glUniform1uiv 
 
4228
}; break;
 
4229
case 5564: { // glUniform1uiv
4277
4230
 GLint *location = (GLint *) bp; bp += 4;
4278
4231
 int * valueLen = (int *) bp; bp += 4;
4279
4232
 GLuint * value = (GLuint *) bp;  bp += (8-((*valueLen*4+0)%8))%8;
4280
4233
 weglUniform1uiv(*location,*valueLen,value);
4281
 
}; break; 
4282
 
case 5553: { // glUniform2uiv 
 
4234
}; break;
 
4235
case 5565: { // glUniform2uiv
4283
4236
 GLint *location = (GLint *) bp; bp += 4;
4284
4237
 int *valueLen = (int *) bp; bp += 4;
4285
4238
 GLuint * value = (GLuint *) bp; bp += *valueLen*8;
4286
4239
 weglUniform2uiv(*location,*valueLen,value);
4287
 
}; break; 
4288
 
case 5554: { // glUniform3uiv 
 
4240
}; break;
 
4241
case 5566: { // glUniform3uiv
4289
4242
 GLint *location = (GLint *) bp; bp += 4;
4290
4243
 int *valueLen = (int *) bp; bp += 4;
4291
4244
 GLuint * value = (GLuint *) bp; bp += *valueLen*12;
4292
4245
 weglUniform3uiv(*location,*valueLen,value);
4293
 
}; break; 
4294
 
case 5555: { // glUniform4uiv 
 
4246
}; break;
 
4247
case 5567: { // glUniform4uiv
4295
4248
 GLint *location = (GLint *) bp; bp += 4;
4296
4249
 int *valueLen = (int *) bp; bp += 4;
4297
4250
 GLuint * value = (GLuint *) bp; bp += *valueLen*16;
4298
4251
 weglUniform4uiv(*location,*valueLen,value);
4299
 
}; break; 
4300
 
case 5556: { // glTexParameterIiv 
 
4252
}; break;
 
4253
case 5568: { // glTexParameterIiv
4301
4254
 GLenum *target = (GLenum *) bp; bp += 4;
4302
4255
 GLenum *pname = (GLenum *) bp; bp += 4;
4303
4256
 int *paramsLen = (int *) bp; bp += 4;
4304
4257
 GLint *params = (GLint *) bp; bp += *paramsLen*4+((*paramsLen)+1)%2*4;
4305
4258
 weglTexParameterIiv(*target,*pname,params);
4306
 
}; break; 
4307
 
case 5557: { // glTexParameterIuiv 
 
4259
}; break;
 
4260
case 5569: { // glTexParameterIuiv
4308
4261
 GLenum *target = (GLenum *) bp; bp += 4;
4309
4262
 GLenum *pname = (GLenum *) bp; bp += 4;
4310
4263
 int *paramsLen = (int *) bp; bp += 4;
4311
4264
 GLuint *params = (GLuint *) bp; bp += *paramsLen*4+((*paramsLen)+1)%2*4;
4312
4265
 weglTexParameterIuiv(*target,*pname,params);
4313
 
}; break; 
4314
 
case 5558: { // glGetTexParameterIiv 
 
4266
}; break;
 
4267
case 5570: { // glGetTexParameterIiv
4315
4268
 GLenum *target = (GLenum *) bp; bp += 4;
4316
4269
 GLenum *pname = (GLenum *) bp; bp += 4;
4317
4270
 GLint params[4] = {0,0,0,0};
4318
4271
 weglGetTexParameterIiv(*target,*pname,params);
4319
4272
 int AP = 0; ErlDrvTermData rt[14];
4320
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4273
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4321
4274
 GLint *paramsTmp = params;
4322
4275
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4323
4276
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4325
4278
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4326
4279
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
4327
4280
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4328
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
4329
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4330
 
}; break; 
4331
 
case 5559: { // glGetTexParameterIuiv 
 
4281
 driver_send_term(port,caller,rt,AP);
 
4282
}; break;
 
4283
case 5571: { // glGetTexParameterIuiv
4332
4284
 GLenum *target = (GLenum *) bp; bp += 4;
4333
4285
 GLenum *pname = (GLenum *) bp; bp += 4;
4334
4286
 GLuint params[4] = {0,0,0,0};
4335
4287
 weglGetTexParameterIuiv(*target,*pname,params);
4336
4288
 int AP = 0; ErlDrvTermData rt[14];
4337
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4289
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4338
4290
 GLuint *paramsTmp = params;
4339
4291
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4340
4292
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4342
4294
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4343
4295
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
4344
4296
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4345
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
4346
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4347
 
}; break; 
4348
 
case 5560: { // glClearBufferiv 
 
4297
 driver_send_term(port,caller,rt,AP);
 
4298
}; break;
 
4299
case 5572: { // glClearBufferiv
4349
4300
 GLenum *buffer = (GLenum *) bp; bp += 4;
4350
4301
 GLint *drawbuffer = (GLint *) bp; bp += 4;
4351
4302
 int *valueLen = (int *) bp; bp += 4;
4352
4303
 GLint *value = (GLint *) bp; bp += *valueLen*4+((*valueLen)+1)%2*4;
4353
4304
 weglClearBufferiv(*buffer,*drawbuffer,value);
4354
 
}; break; 
4355
 
case 5561: { // glClearBufferuiv 
 
4305
}; break;
 
4306
case 5573: { // glClearBufferuiv
4356
4307
 GLenum *buffer = (GLenum *) bp; bp += 4;
4357
4308
 GLint *drawbuffer = (GLint *) bp; bp += 4;
4358
4309
 int *valueLen = (int *) bp; bp += 4;
4359
4310
 GLuint *value = (GLuint *) bp; bp += *valueLen*4+((*valueLen)+1)%2*4;
4360
4311
 weglClearBufferuiv(*buffer,*drawbuffer,value);
4361
 
}; break; 
4362
 
case 5562: { // glClearBufferfv 
 
4312
}; break;
 
4313
case 5574: { // glClearBufferfv
4363
4314
 GLenum *buffer = (GLenum *) bp; bp += 4;
4364
4315
 GLint *drawbuffer = (GLint *) bp; bp += 4;
4365
4316
 int *valueLen = (int *) bp; bp += 4;
4366
4317
 GLfloat *value = (GLfloat *) bp; bp += *valueLen*4+((*valueLen)+1)%2*4;
4367
4318
 weglClearBufferfv(*buffer,*drawbuffer,value);
4368
 
}; break; 
4369
 
case 5563: { // glClearBufferfi 
 
4319
}; break;
 
4320
case 5575: { // glClearBufferfi
4370
4321
 GLenum *buffer = (GLenum *) bp; bp += 4;
4371
4322
 GLint *drawbuffer = (GLint *) bp; bp += 4;
4372
4323
 GLfloat *depth = (GLfloat *) bp; bp += 4;
4373
4324
 GLint *stencil = (GLint *) bp; bp += 4;
4374
4325
 weglClearBufferfi(*buffer,*drawbuffer,*depth,*stencil);
4375
 
}; break; 
4376
 
case 5564: { // glGetStringi 
 
4326
}; break;
 
4327
case 5576: { // glGetStringi
4377
4328
 GLenum *name = (GLenum *) bp; bp += 4;
4378
4329
 GLuint *index = (GLuint *) bp; bp += 4;
4379
4330
 const GLubyte *  result = weglGetStringi(*name,*index);
4380
4331
 int AP = 0; ErlDrvTermData rt[7];
4381
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4332
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4382
4333
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) result; rt[AP++] = strlen((char *) result);
4383
4334
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4384
 
 if (AP != 7 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7);
4385
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4386
 
}; break; 
4387
 
case 5565: { // glVertexAttribI1iv 
4388
 
 GLuint *index = (GLuint *) bp; bp += 4;
4389
 
 GLint *v = (GLint *) bp; bp += 4;
4390
 
 weglVertexAttribI1iv(*index,v);
4391
 
}; break; 
4392
 
case 5566: { // glVertexAttribI2iv 
4393
 
 GLuint *index = (GLuint *) bp; bp += 4;
4394
 
 GLint *v = (GLint *) bp; bp += 4;
4395
 
 weglVertexAttribI2iv(*index,v);
4396
 
}; break; 
4397
 
case 5567: { // glVertexAttribI3iv 
4398
 
 GLuint *index = (GLuint *) bp; bp += 4;
4399
 
 GLint *v = (GLint *) bp; bp += 4;
4400
 
 weglVertexAttribI3iv(*index,v);
4401
 
}; break; 
4402
 
case 5568: { // glVertexAttribI4iv 
4403
 
 GLuint *index = (GLuint *) bp; bp += 4;
4404
 
 GLint * v = (GLint *) bp; bp += 16;
4405
 
 weglVertexAttribI4iv(*index,v);
4406
 
}; break; 
4407
 
case 5569: { // glVertexAttribI1uiv 
4408
 
 GLuint *index = (GLuint *) bp; bp += 4;
4409
 
 GLuint *v = (GLuint *) bp; bp += 4;
4410
 
 weglVertexAttribI1uiv(*index,v);
4411
 
}; break; 
4412
 
case 5570: { // glVertexAttribI2uiv 
4413
 
 GLuint *index = (GLuint *) bp; bp += 4;
4414
 
 GLuint *v = (GLuint *) bp; bp += 4;
4415
 
 weglVertexAttribI2uiv(*index,v);
4416
 
}; break; 
4417
 
case 5571: { // glVertexAttribI3uiv 
4418
 
 GLuint *index = (GLuint *) bp; bp += 4;
4419
 
 GLuint *v = (GLuint *) bp; bp += 4;
4420
 
 weglVertexAttribI3uiv(*index,v);
4421
 
}; break; 
4422
 
case 5572: { // glVertexAttribI4uiv 
4423
 
 GLuint *index = (GLuint *) bp; bp += 4;
4424
 
 GLuint * v = (GLuint *) bp; bp += 16;
4425
 
 weglVertexAttribI4uiv(*index,v);
4426
 
}; break; 
4427
 
case 5573: { // glVertexAttribI4bv 
4428
 
 GLuint *index = (GLuint *) bp; bp += 4;
4429
 
 GLbyte * v = (GLbyte *) bp; bp += 4;
4430
 
 weglVertexAttribI4bv(*index,v);
4431
 
}; break; 
4432
 
case 5574: { // glVertexAttribI4sv 
4433
 
 GLuint *index = (GLuint *) bp; bp += 4;
4434
 
 GLshort * v = (GLshort *) bp; bp += 8;
4435
 
 weglVertexAttribI4sv(*index,v);
4436
 
}; break; 
4437
 
case 5575: { // glVertexAttribI4ubv 
4438
 
 GLuint *index = (GLuint *) bp; bp += 4;
4439
 
 GLubyte * v = (GLubyte *) bp; bp += 4;
4440
 
 weglVertexAttribI4ubv(*index,v);
4441
 
}; break; 
4442
 
case 5576: { // glVertexAttribI4usv 
4443
 
 GLuint *index = (GLuint *) bp; bp += 4;
4444
 
 GLushort * v = (GLushort *) bp; bp += 8;
4445
 
 weglVertexAttribI4usv(*index,v);
4446
 
}; break; 
4447
 
case 5577: { // glDrawArraysInstanced 
 
4335
 driver_send_term(port,caller,rt,AP);
 
4336
}; break;
 
4337
case 5577: { // glDrawArraysInstanced
4448
4338
 GLenum *mode = (GLenum *) bp; bp += 4;
4449
4339
 GLint *first = (GLint *) bp; bp += 4;
4450
4340
 GLsizei *count = (GLsizei *) bp; bp += 4;
4451
4341
 GLsizei *primcount = (GLsizei *) bp; bp += 4;
4452
4342
 weglDrawArraysInstanced(*mode,*first,*count,*primcount);
4453
 
}; break; 
4454
 
case 5578: { // glDrawElementsInstanced 
 
4343
}; break;
 
4344
case 5578: { // glDrawElementsInstanced
4455
4345
 GLenum *mode = (GLenum *) bp; bp += 4;
4456
4346
 GLsizei *count = (GLsizei *) bp; bp += 4;
4457
4347
 GLenum *type = (GLenum *) bp; bp += 4;
4458
4348
 GLvoid *indices = (GLvoid *) * (int *) bp; bp += 4;
4459
4349
 GLsizei *primcount = (GLsizei *) bp; bp += 4;
4460
4350
 weglDrawElementsInstanced(*mode,*count,*type,indices,*primcount);
4461
 
}; break; 
4462
 
case 5579: { // glDrawElementsInstanced 
 
4351
}; break;
 
4352
case 5579: { // glDrawElementsInstanced
4463
4353
 GLenum *mode = (GLenum *) bp; bp += 4;
4464
4354
 GLsizei *count = (GLsizei *) bp; bp += 4;
4465
4355
 GLenum *type = (GLenum *) bp; bp += 4;
4466
 
 GLvoid *indices = (GLvoid *) bins[0]->base;
 
4356
 GLvoid *indices = (GLvoid *) bins[0];
4467
4357
 GLsizei *primcount = (GLsizei *) bp; bp += 4;
4468
4358
 weglDrawElementsInstanced(*mode,*count,*type,indices,*primcount);
4469
 
}; break; 
4470
 
case 5580: { // glTexBuffer 
 
4359
}; break;
 
4360
case 5580: { // glTexBuffer
4471
4361
 GLenum *target = (GLenum *) bp; bp += 4;
4472
4362
 GLenum *internalformat = (GLenum *) bp; bp += 4;
4473
4363
 GLuint *buffer = (GLuint *) bp; bp += 4;
4474
4364
 weglTexBuffer(*target,*internalformat,*buffer);
4475
 
}; break; 
4476
 
case 5581: { // glPrimitiveRestartIndex 
 
4365
}; break;
 
4366
case 5581: { // glPrimitiveRestartIndex
4477
4367
 GLuint *index = (GLuint *) bp; bp += 4;
4478
4368
 weglPrimitiveRestartIndex(*index);
4479
 
}; break; 
4480
 
case 5582: { // glLoadTransposeMatrixfARB 
 
4369
}; break;
 
4370
case 5582: { // glGetInteger64i_v
 
4371
 GLenum *target = (GLenum *) bp; bp += 4;
 
4372
 GLuint *index = (GLuint *) bp; bp += 4;
 
4373
 GLint64 data[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 
4374
 weglGetInteger64i_v(*target,*index,data);
 
4375
 int AP = 0; ErlDrvTermData rt[39];
 
4376
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
4377
 GLint64 *dataTmp = data;
 
4378
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4379
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4380
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4381
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4382
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4383
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4384
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4385
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4386
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4387
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4388
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4389
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4390
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4391
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4392
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4393
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *dataTmp++;
 
4394
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 16+1;
 
4395
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
4396
 driver_send_term(port,caller,rt,AP);
 
4397
}; break;
 
4398
case 5583: { // glGetBufferParameteri64v
 
4399
 GLenum *target = (GLenum *) bp; bp += 4;
 
4400
 GLenum *pname = (GLenum *) bp; bp += 4;
 
4401
 GLint64 params[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 
4402
 weglGetBufferParameteri64v(*target,*pname,params);
 
4403
 int AP = 0; ErlDrvTermData rt[39];
 
4404
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
4405
 GLint64 *paramsTmp = params;
 
4406
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4407
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4408
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4409
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4410
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4411
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4412
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4413
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4414
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4415
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4416
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4417
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4418
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4419
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4420
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4421
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4422
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 16+1;
 
4423
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
4424
 driver_send_term(port,caller,rt,AP);
 
4425
}; break;
 
4426
case 5584: { // glFramebufferTexture
 
4427
 GLenum *target = (GLenum *) bp; bp += 4;
 
4428
 GLenum *attachment = (GLenum *) bp; bp += 4;
 
4429
 GLuint *texture = (GLuint *) bp; bp += 4;
 
4430
 GLint *level = (GLint *) bp; bp += 4;
 
4431
 weglFramebufferTexture(*target,*attachment,*texture,*level);
 
4432
}; break;
 
4433
case 5585: { // glVertexAttribDivisor
 
4434
 GLuint *index = (GLuint *) bp; bp += 4;
 
4435
 GLuint *divisor = (GLuint *) bp; bp += 4;
 
4436
 weglVertexAttribDivisor(*index,*divisor);
 
4437
}; break;
 
4438
case 5586: { // glMinSampleShading
 
4439
 GLclampf *value = (GLclampf *) bp; bp += 4;
 
4440
 weglMinSampleShading(*value);
 
4441
}; break;
 
4442
case 5587: { // glBlendEquationi
 
4443
 GLuint *buf = (GLuint *) bp; bp += 4;
 
4444
 GLenum *mode = (GLenum *) bp; bp += 4;
 
4445
 weglBlendEquationi(*buf,*mode);
 
4446
}; break;
 
4447
case 5588: { // glBlendEquationSeparatei
 
4448
 GLuint *buf = (GLuint *) bp; bp += 4;
 
4449
 GLenum *modeRGB = (GLenum *) bp; bp += 4;
 
4450
 GLenum *modeAlpha = (GLenum *) bp; bp += 4;
 
4451
 weglBlendEquationSeparatei(*buf,*modeRGB,*modeAlpha);
 
4452
}; break;
 
4453
case 5589: { // glBlendFunci
 
4454
 GLuint *buf = (GLuint *) bp; bp += 4;
 
4455
 GLenum *src = (GLenum *) bp; bp += 4;
 
4456
 GLenum *dst = (GLenum *) bp; bp += 4;
 
4457
 weglBlendFunci(*buf,*src,*dst);
 
4458
}; break;
 
4459
case 5590: { // glBlendFuncSeparatei
 
4460
 GLuint *buf = (GLuint *) bp; bp += 4;
 
4461
 GLenum *srcRGB = (GLenum *) bp; bp += 4;
 
4462
 GLenum *dstRGB = (GLenum *) bp; bp += 4;
 
4463
 GLenum *srcAlpha = (GLenum *) bp; bp += 4;
 
4464
 GLenum *dstAlpha = (GLenum *) bp; bp += 4;
 
4465
 weglBlendFuncSeparatei(*buf,*srcRGB,*dstRGB,*srcAlpha,*dstAlpha);
 
4466
}; break;
 
4467
case 5591: { // glLoadTransposeMatrixfARB
4481
4468
 GLfloat * m = (GLfloat *) bp; bp += 64;
4482
4469
 weglLoadTransposeMatrixfARB(m);
4483
 
}; break; 
4484
 
case 5583: { // glLoadTransposeMatrixdARB 
 
4470
}; break;
 
4471
case 5592: { // glLoadTransposeMatrixdARB
4485
4472
 GLdouble * m = (GLdouble *) bp; bp += 128;
4486
4473
 weglLoadTransposeMatrixdARB(m);
4487
 
}; break; 
4488
 
case 5584: { // glMultTransposeMatrixfARB 
 
4474
}; break;
 
4475
case 5593: { // glMultTransposeMatrixfARB
4489
4476
 GLfloat * m = (GLfloat *) bp; bp += 64;
4490
4477
 weglMultTransposeMatrixfARB(m);
4491
 
}; break; 
4492
 
case 5585: { // glMultTransposeMatrixdARB 
 
4478
}; break;
 
4479
case 5594: { // glMultTransposeMatrixdARB
4493
4480
 GLdouble * m = (GLdouble *) bp; bp += 128;
4494
4481
 weglMultTransposeMatrixdARB(m);
4495
 
}; break; 
4496
 
case 5586: { // glWeightbvARB 
 
4482
}; break;
 
4483
case 5595: { // glWeightbvARB
4497
4484
 int * weightsLen = (int *) bp; bp += 4;
4498
4485
 GLbyte * weights = (GLbyte *) bp;  bp += (8-((*weightsLen*1+4)%8))%8;
4499
4486
 weglWeightbvARB(*weightsLen,weights);
4500
 
}; break; 
4501
 
case 5587: { // glWeightsvARB 
 
4487
}; break;
 
4488
case 5596: { // glWeightsvARB
4502
4489
 int * weightsLen = (int *) bp; bp += 4;
4503
4490
 GLshort * weights = (GLshort *) bp;  bp += (8-((*weightsLen*2+4)%8))%8;
4504
4491
 weglWeightsvARB(*weightsLen,weights);
4505
 
}; break; 
4506
 
case 5588: { // glWeightivARB 
 
4492
}; break;
 
4493
case 5597: { // glWeightivARB
4507
4494
 int * weightsLen = (int *) bp; bp += 4;
4508
4495
 GLint * weights = (GLint *) bp;  bp += (8-((*weightsLen*4+4)%8))%8;
4509
4496
 weglWeightivARB(*weightsLen,weights);
4510
 
}; break; 
4511
 
case 5589: { // glWeightfvARB 
 
4497
}; break;
 
4498
case 5598: { // glWeightfvARB
4512
4499
 int * weightsLen = (int *) bp; bp += 4;
4513
4500
 GLfloat * weights = (GLfloat *) bp;  bp += (8-((*weightsLen*4+4)%8))%8;
4514
4501
 weglWeightfvARB(*weightsLen,weights);
4515
 
}; break; 
4516
 
case 5590: { // glWeightdvARB 
 
4502
}; break;
 
4503
case 5599: { // glWeightdvARB
4517
4504
 int * weightsLen = (int *) bp; bp += 8;
4518
4505
 GLdouble * weights = (GLdouble *) bp;  bp += (8-((*weightsLen*8+0)%8))%8;
4519
4506
 weglWeightdvARB(*weightsLen,weights);
4520
 
}; break; 
4521
 
case 5591: { // glWeightubvARB 
 
4507
}; break;
 
4508
case 5600: { // glWeightubvARB
4522
4509
 int * weightsLen = (int *) bp; bp += 4;
4523
4510
 GLubyte * weights = (GLubyte *) bp;  bp += (8-((*weightsLen*1+4)%8))%8;
4524
4511
 weglWeightubvARB(*weightsLen,weights);
4525
 
}; break; 
4526
 
case 5592: { // glWeightusvARB 
 
4512
}; break;
 
4513
case 5601: { // glWeightusvARB
4527
4514
 int * weightsLen = (int *) bp; bp += 4;
4528
4515
 GLushort * weights = (GLushort *) bp;  bp += (8-((*weightsLen*2+4)%8))%8;
4529
4516
 weglWeightusvARB(*weightsLen,weights);
4530
 
}; break; 
4531
 
case 5593: { // glWeightuivARB 
 
4517
}; break;
 
4518
case 5602: { // glWeightuivARB
4532
4519
 int * weightsLen = (int *) bp; bp += 4;
4533
4520
 GLuint * weights = (GLuint *) bp;  bp += (8-((*weightsLen*4+4)%8))%8;
4534
4521
 weglWeightuivARB(*weightsLen,weights);
4535
 
}; break; 
4536
 
case 5594: { // glVertexBlendARB 
 
4522
}; break;
 
4523
case 5603: { // glVertexBlendARB
4537
4524
 GLint *count = (GLint *) bp; bp += 4;
4538
4525
 weglVertexBlendARB(*count);
4539
 
}; break; 
4540
 
case 5595: { // glCurrentPaletteMatrixARB 
 
4526
}; break;
 
4527
case 5604: { // glCurrentPaletteMatrixARB
4541
4528
 GLint *index = (GLint *) bp; bp += 4;
4542
4529
 weglCurrentPaletteMatrixARB(*index);
4543
 
}; break; 
4544
 
case 5596: { // glMatrixIndexubvARB 
 
4530
}; break;
 
4531
case 5605: { // glMatrixIndexubvARB
4545
4532
 int * indicesLen = (int *) bp; bp += 4;
4546
4533
 GLubyte * indices = (GLubyte *) bp;  bp += (8-((*indicesLen*1+4)%8))%8;
4547
4534
 weglMatrixIndexubvARB(*indicesLen,indices);
4548
 
}; break; 
4549
 
case 5597: { // glMatrixIndexusvARB 
 
4535
}; break;
 
4536
case 5606: { // glMatrixIndexusvARB
4550
4537
 int * indicesLen = (int *) bp; bp += 4;
4551
4538
 GLushort * indices = (GLushort *) bp;  bp += (8-((*indicesLen*2+4)%8))%8;
4552
4539
 weglMatrixIndexusvARB(*indicesLen,indices);
4553
 
}; break; 
4554
 
case 5598: { // glMatrixIndexuivARB 
 
4540
}; break;
 
4541
case 5607: { // glMatrixIndexuivARB
4555
4542
 int * indicesLen = (int *) bp; bp += 4;
4556
4543
 GLuint * indices = (GLuint *) bp;  bp += (8-((*indicesLen*4+4)%8))%8;
4557
4544
 weglMatrixIndexuivARB(*indicesLen,indices);
4558
 
}; break; 
4559
 
case 5599: { // glProgramStringARB 
 
4545
}; break;
 
4546
case 5608: { // glProgramStringARB
4560
4547
 GLenum *target = (GLenum *) bp; bp += 4;
4561
4548
 GLenum *format = (GLenum *) bp; bp += 4;
4562
4549
 GLvoid *string = (GLvoid *) bp;
4563
 
 int stringLen = strlen((char *)string); bp += stringLen+1+((8-((1+stringLen+0)%8))%8);
4564
 
 weglProgramStringARB(*target,*format,stringLen,string);
4565
 
}; break; 
4566
 
case 5600: { // glBindProgramARB 
 
4550
 int stringLen[1] = {strlen((char *)string)}; bp += stringLen[0]+1+((8-((1+stringLen[0]+0)%8))%8);
 
4551
 weglProgramStringARB(*target,*format,*stringLen,string);
 
4552
}; break;
 
4553
case 5609: { // glBindProgramARB
4567
4554
 GLenum *target = (GLenum *) bp; bp += 4;
4568
4555
 GLuint *program = (GLuint *) bp; bp += 4;
4569
4556
 weglBindProgramARB(*target,*program);
4570
 
}; break; 
4571
 
case 5601: { // glDeleteProgramsARB 
 
4557
}; break;
 
4558
case 5610: { // glDeleteProgramsARB
4572
4559
 int * programsLen = (int *) bp; bp += 4;
4573
4560
 GLuint * programs = (GLuint *) bp;  bp += (8-((*programsLen*4+4)%8))%8;
4574
4561
 weglDeleteProgramsARB(*programsLen,programs);
4575
 
}; break; 
4576
 
case 5602: { // glGenProgramsARB 
 
4562
}; break;
 
4563
case 5611: { // glGenProgramsARB
4577
4564
 GLsizei *n = (GLsizei *) bp; bp += 4;
4578
4565
 GLuint *programs;
4579
4566
 programs = (GLuint *) driver_alloc(sizeof(GLuint) * *n);
4580
4567
 weglGenProgramsARB(*n,programs);
4581
4568
 int AP = 0; ErlDrvTermData *rt;
4582
4569
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*n)*2));
4583
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4570
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4584
4571
 for(int i=0; i < *n; i++) {
4585
4572
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) programs[i];}
4586
4573
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*n)+1;
4587
4574
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4588
 
 if (AP != 7 + (*n)*2 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7 + (*n)*2);
4589
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4590
 
 driver_free(rt); 
 
4575
 driver_send_term(port,caller,rt,AP);
 
4576
 driver_free(rt);
4591
4577
 driver_free(programs);
4592
 
}; break; 
4593
 
case 5603: { // glProgramEnvParameter4dARB 
 
4578
}; break;
 
4579
case 5612: { // glProgramEnvParameter4dARB
4594
4580
 GLenum *target = (GLenum *) bp; bp += 4;
4595
4581
 GLuint *index = (GLuint *) bp; bp += 4;
4596
4582
 GLdouble *x = (GLdouble *) bp; bp += 8;
4598
4584
 GLdouble *z = (GLdouble *) bp; bp += 8;
4599
4585
 GLdouble *w = (GLdouble *) bp; bp += 8;
4600
4586
 weglProgramEnvParameter4dARB(*target,*index,*x,*y,*z,*w);
4601
 
}; break; 
4602
 
case 5604: { // glProgramEnvParameter4dvARB 
 
4587
}; break;
 
4588
case 5613: { // glProgramEnvParameter4dvARB
4603
4589
 GLenum *target = (GLenum *) bp; bp += 4;
4604
4590
 GLuint *index = (GLuint *) bp; bp += 4;
4605
4591
 GLdouble * params = (GLdouble *) bp; bp += 32;
4606
4592
 weglProgramEnvParameter4dvARB(*target,*index,params);
4607
 
}; break; 
4608
 
case 5605: { // glProgramEnvParameter4fARB 
 
4593
}; break;
 
4594
case 5614: { // glProgramEnvParameter4fARB
4609
4595
 GLenum *target = (GLenum *) bp; bp += 4;
4610
4596
 GLuint *index = (GLuint *) bp; bp += 4;
4611
4597
 GLfloat *x = (GLfloat *) bp; bp += 4;
4613
4599
 GLfloat *z = (GLfloat *) bp; bp += 4;
4614
4600
 GLfloat *w = (GLfloat *) bp; bp += 4;
4615
4601
 weglProgramEnvParameter4fARB(*target,*index,*x,*y,*z,*w);
4616
 
}; break; 
4617
 
case 5606: { // glProgramEnvParameter4fvARB 
 
4602
}; break;
 
4603
case 5615: { // glProgramEnvParameter4fvARB
4618
4604
 GLenum *target = (GLenum *) bp; bp += 4;
4619
4605
 GLuint *index = (GLuint *) bp; bp += 4;
4620
4606
 GLfloat * params = (GLfloat *) bp; bp += 16;
4621
4607
 weglProgramEnvParameter4fvARB(*target,*index,params);
4622
 
}; break; 
4623
 
case 5607: { // glProgramLocalParameter4dARB 
 
4608
}; break;
 
4609
case 5616: { // glProgramLocalParameter4dARB
4624
4610
 GLenum *target = (GLenum *) bp; bp += 4;
4625
4611
 GLuint *index = (GLuint *) bp; bp += 4;
4626
4612
 GLdouble *x = (GLdouble *) bp; bp += 8;
4628
4614
 GLdouble *z = (GLdouble *) bp; bp += 8;
4629
4615
 GLdouble *w = (GLdouble *) bp; bp += 8;
4630
4616
 weglProgramLocalParameter4dARB(*target,*index,*x,*y,*z,*w);
4631
 
}; break; 
4632
 
case 5608: { // glProgramLocalParameter4dvARB 
 
4617
}; break;
 
4618
case 5617: { // glProgramLocalParameter4dvARB
4633
4619
 GLenum *target = (GLenum *) bp; bp += 4;
4634
4620
 GLuint *index = (GLuint *) bp; bp += 4;
4635
4621
 GLdouble * params = (GLdouble *) bp; bp += 32;
4636
4622
 weglProgramLocalParameter4dvARB(*target,*index,params);
4637
 
}; break; 
4638
 
case 5609: { // glProgramLocalParameter4fARB 
 
4623
}; break;
 
4624
case 5618: { // glProgramLocalParameter4fARB
4639
4625
 GLenum *target = (GLenum *) bp; bp += 4;
4640
4626
 GLuint *index = (GLuint *) bp; bp += 4;
4641
4627
 GLfloat *x = (GLfloat *) bp; bp += 4;
4643
4629
 GLfloat *z = (GLfloat *) bp; bp += 4;
4644
4630
 GLfloat *w = (GLfloat *) bp; bp += 4;
4645
4631
 weglProgramLocalParameter4fARB(*target,*index,*x,*y,*z,*w);
4646
 
}; break; 
4647
 
case 5610: { // glProgramLocalParameter4fvARB 
 
4632
}; break;
 
4633
case 5619: { // glProgramLocalParameter4fvARB
4648
4634
 GLenum *target = (GLenum *) bp; bp += 4;
4649
4635
 GLuint *index = (GLuint *) bp; bp += 4;
4650
4636
 GLfloat * params = (GLfloat *) bp; bp += 16;
4651
4637
 weglProgramLocalParameter4fvARB(*target,*index,params);
4652
 
}; break; 
4653
 
case 5611: { // glGetProgramEnvParameterdvARB 
 
4638
}; break;
 
4639
case 5620: { // glGetProgramEnvParameterdvARB
4654
4640
 GLenum *target = (GLenum *) bp; bp += 4;
4655
4641
 GLuint *index = (GLuint *) bp; bp += 4;
4656
4642
 GLdouble params[4] = {0.0,0.0,0.0,0.0};
4657
4643
 weglGetProgramEnvParameterdvARB(*target,*index,params);
4658
4644
 int AP = 0; ErlDrvTermData rt[14];
4659
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4645
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4660
4646
 GLdouble *paramsTmp = params;
4661
4647
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
4662
4648
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
4664
4650
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
4665
4651
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
4666
4652
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4667
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
4668
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4669
 
}; break; 
4670
 
case 5612: { // glGetProgramEnvParameterfvARB 
 
4653
 driver_send_term(port,caller,rt,AP);
 
4654
}; break;
 
4655
case 5621: { // glGetProgramEnvParameterfvARB
4671
4656
 GLenum *target = (GLenum *) bp; bp += 4;
4672
4657
 GLuint *index = (GLuint *) bp; bp += 4;
4673
4658
 GLfloat params[4] = {0.0,0.0,0.0,0.0};
4674
4659
 weglGetProgramEnvParameterfvARB(*target,*index,params);
4675
4660
 int AP = 0; ErlDrvTermData rt[14];
4676
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4661
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4677
4662
 GLdouble paramsConv[4], *paramsTmp = paramsConv; 
4678
4663
 for(int i=0; i < 4; i++) paramsConv[i] = (GLdouble) params[i];
4679
4664
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
4682
4667
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
4683
4668
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
4684
4669
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4685
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
4686
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4687
 
}; break; 
4688
 
case 5613: { // glGetProgramLocalParameterdvARB 
 
4670
 driver_send_term(port,caller,rt,AP);
 
4671
}; break;
 
4672
case 5622: { // glGetProgramLocalParameterdvARB
4689
4673
 GLenum *target = (GLenum *) bp; bp += 4;
4690
4674
 GLuint *index = (GLuint *) bp; bp += 4;
4691
4675
 GLdouble params[4] = {0.0,0.0,0.0,0.0};
4692
4676
 weglGetProgramLocalParameterdvARB(*target,*index,params);
4693
4677
 int AP = 0; ErlDrvTermData rt[14];
4694
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4678
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4695
4679
 GLdouble *paramsTmp = params;
4696
4680
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
4697
4681
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
4699
4683
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
4700
4684
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
4701
4685
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4702
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
4703
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4704
 
}; break; 
4705
 
case 5614: { // glGetProgramLocalParameterfvARB 
 
4686
 driver_send_term(port,caller,rt,AP);
 
4687
}; break;
 
4688
case 5623: { // glGetProgramLocalParameterfvARB
4706
4689
 GLenum *target = (GLenum *) bp; bp += 4;
4707
4690
 GLuint *index = (GLuint *) bp; bp += 4;
4708
4691
 GLfloat params[4] = {0.0,0.0,0.0,0.0};
4709
4692
 weglGetProgramLocalParameterfvARB(*target,*index,params);
4710
4693
 int AP = 0; ErlDrvTermData rt[14];
4711
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4694
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4712
4695
 GLdouble paramsConv[4], *paramsTmp = paramsConv; 
4713
4696
 for(int i=0; i < 4; i++) paramsConv[i] = (GLdouble) params[i];
4714
4697
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
4717
4700
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
4718
4701
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
4719
4702
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4720
 
 if (AP != 14 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,14);
4721
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4722
 
}; break; 
4723
 
case 5615: { // glGetProgramStringARB 
 
4703
 driver_send_term(port,caller,rt,AP);
 
4704
}; break;
 
4705
case 5624: { // glGetProgramStringARB
4724
4706
 GLenum *target = (GLenum *) bp; bp += 4;
4725
4707
 GLenum *pname = (GLenum *) bp; bp += 4;
4726
 
 GLvoid *string = (GLvoid *) bins[0]->base;
 
4708
 GLvoid *string = (GLvoid *) bins[0];
4727
4709
 weglGetProgramStringARB(*target,*pname,string);
4728
4710
 int AP = 0; ErlDrvTermData rt[6];
4729
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4711
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4730
4712
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
4731
4713
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4732
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4733
 
}; break; 
4734
 
case 5616: { // glDeleteObjectARB 
 
4714
 driver_send_term(port,caller,rt,AP);
 
4715
}; break;
 
4716
case 5625: { // glGetBufferParameterivARB
 
4717
 GLenum *target = (GLenum *) bp; bp += 4;
 
4718
 GLenum *pname = (GLenum *) bp; bp += 4;
 
4719
 GLint params[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 
4720
 weglGetBufferParameterivARB(*target,*pname,params);
 
4721
 int AP = 0; ErlDrvTermData rt[39];
 
4722
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
4723
 GLint *paramsTmp = params;
 
4724
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4725
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4726
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4727
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4728
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4729
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4730
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4731
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4732
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4733
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4734
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4735
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4736
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4737
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4738
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4739
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
4740
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 16+1;
 
4741
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
4742
 driver_send_term(port,caller,rt,AP);
 
4743
}; break;
 
4744
case 5626: { // glDeleteObjectARB
4735
4745
 GLhandleARB obj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4736
4746
 weglDeleteObjectARB(obj);
4737
 
}; break; 
4738
 
case 5617: { // glGetHandleARB 
 
4747
}; break;
 
4748
case 5627: { // glGetHandleARB
4739
4749
 GLenum *pname = (GLenum *) bp; bp += 4;
4740
4750
 GLhandleARB result = weglGetHandleARB(*pname);
4741
4751
 int AP = 0; ErlDrvTermData rt[6];
4742
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4752
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4743
4753
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
4744
4754
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4745
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
4746
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4747
 
}; break; 
4748
 
case 5618: { // glDetachObjectARB 
 
4755
 driver_send_term(port,caller,rt,AP);
 
4756
}; break;
 
4757
case 5628: { // glDetachObjectARB
4749
4758
 GLhandleARB containerObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4750
4759
 GLhandleARB attachedObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4751
4760
 weglDetachObjectARB(containerObj,attachedObj);
4752
 
}; break; 
4753
 
case 5619: { // glCreateShaderObjectARB 
 
4761
}; break;
 
4762
case 5629: { // glCreateShaderObjectARB
4754
4763
 GLenum *shaderType = (GLenum *) bp; bp += 4;
4755
4764
 GLhandleARB result = weglCreateShaderObjectARB(*shaderType);
4756
4765
 int AP = 0; ErlDrvTermData rt[6];
4757
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4766
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4758
4767
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
4759
4768
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4760
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
4761
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4762
 
}; break; 
4763
 
case 5620: { // glShaderSourceARB 
 
4769
 driver_send_term(port,caller,rt,AP);
 
4770
}; break;
 
4771
case 5630: { // glShaderSourceARB
4764
4772
 GLhandleARB shaderObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4765
4773
 int * stringLen = (int *) bp; bp += 4;
4766
4774
 int * stringTotSize = (int *) bp; bp += 4;
4767
4775
 GLchar **string;
4768
 
 string = (GLchar **) driver_alloc(sizeof(GLchar *) * *stringLen); 
 
4776
 string = (GLchar **) driver_alloc(sizeof(GLchar *) * *stringLen);
4769
4777
 for(int i=0;i<*stringLen;i++) {
4770
4778
    string[i] = (GLchar *) bp; bp += 1+strlen(bp);};
4771
4779
 bp += (8 - ((4 + *stringTotSize) % 8)) % 8;
4772
4780
 weglShaderSourceARB(shaderObj,*stringLen,(const GLchar **) string,NULL);
4773
4781
 driver_free(string);
4774
 
}; break; 
4775
 
case 5621: { // glCompileShaderARB 
 
4782
}; break;
 
4783
case 5631: { // glCompileShaderARB
4776
4784
 GLhandleARB shaderObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4777
4785
 weglCompileShaderARB(shaderObj);
4778
 
}; break; 
4779
 
case 5622: { // glCreateProgramObjectARB 
 
4786
}; break;
 
4787
case 5632: { // glCreateProgramObjectARB
4780
4788
 GLhandleARB result = weglCreateProgramObjectARB();
4781
4789
 int AP = 0; ErlDrvTermData rt[6];
4782
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4790
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4783
4791
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
4784
4792
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4785
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
4786
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4787
 
}; break; 
4788
 
case 5623: { // glAttachObjectARB 
 
4793
 driver_send_term(port,caller,rt,AP);
 
4794
}; break;
 
4795
case 5633: { // glAttachObjectARB
4789
4796
 GLhandleARB containerObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4790
4797
 GLhandleARB obj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4791
4798
 weglAttachObjectARB(containerObj,obj);
4792
 
}; break; 
4793
 
case 5624: { // glLinkProgramARB 
 
4799
}; break;
 
4800
case 5634: { // glLinkProgramARB
4794
4801
 GLhandleARB programObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4795
4802
 weglLinkProgramARB(programObj);
4796
 
}; break; 
4797
 
case 5625: { // glUseProgramObjectARB 
 
4803
}; break;
 
4804
case 5635: { // glUseProgramObjectARB
4798
4805
 GLhandleARB programObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4799
4806
 weglUseProgramObjectARB(programObj);
4800
 
}; break; 
4801
 
case 5626: { // glValidateProgramARB 
 
4807
}; break;
 
4808
case 5636: { // glValidateProgramARB
4802
4809
 GLhandleARB programObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4803
4810
 weglValidateProgramARB(programObj);
4804
 
}; break; 
4805
 
case 5627: { // glGetObjectParameterfvARB 
 
4811
}; break;
 
4812
case 5637: { // glGetObjectParameterfvARB
4806
4813
 GLhandleARB obj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4807
4814
 GLenum *pname = (GLenum *) bp; bp += 4;
4808
4815
 GLfloat params[1] = {0.0};
4809
4816
 weglGetObjectParameterfvARB(obj,*pname,params);
4810
4817
 int AP = 0; ErlDrvTermData rt[6];
4811
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4818
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4812
4819
 GLdouble paramsConv = (double) *params; 
4813
4820
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) &paramsConv;
4814
4821
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4815
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
4816
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4817
 
}; break; 
4818
 
case 5628: { // glGetObjectParameterivARB 
 
4822
 driver_send_term(port,caller,rt,AP);
 
4823
}; break;
 
4824
case 5638: { // glGetObjectParameterivARB
4819
4825
 GLhandleARB obj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4820
4826
 GLenum *pname = (GLenum *) bp; bp += 4;
4821
4827
 GLint params[1] = {0};
4822
4828
 weglGetObjectParameterivARB(obj,*pname,params);
4823
4829
 int AP = 0; ErlDrvTermData rt[6];
4824
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4830
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4825
4831
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *params;
4826
4832
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4827
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
4828
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4829
 
}; break; 
4830
 
case 5629: { // glGetInfoLogARB 
 
4833
 driver_send_term(port,caller,rt,AP);
 
4834
}; break;
 
4835
case 5639: { // glGetInfoLogARB
4831
4836
 GLhandleARB obj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4832
4837
 GLsizei *maxLength = (GLsizei *) bp; bp += 4;
4833
4838
 GLsizei length[1] = {0};
4835
4840
 infoLog = (GLchar *) driver_alloc(sizeof(GLchar) * *maxLength);
4836
4841
 weglGetInfoLogARB(obj,*maxLength,length,infoLog);
4837
4842
 int AP = 0; ErlDrvTermData rt[7];
4838
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4843
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4839
4844
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) infoLog; rt[AP++] = *length;
4840
4845
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4841
 
 if (AP != 7 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7);
4842
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
 
4846
 driver_send_term(port,caller,rt,AP);
4843
4847
 driver_free(infoLog);
4844
 
}; break; 
4845
 
case 5630: { // glGetAttachedObjectsARB 
 
4848
}; break;
 
4849
case 5640: { // glGetAttachedObjectsARB
4846
4850
 GLhandleARB containerObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4847
4851
 GLsizei *maxCount = (GLsizei *) bp; bp += 4;
4848
4852
 GLsizei count[1] = {0};
4851
4855
 weglGetAttachedObjectsARB(containerObj,*maxCount,count,obj);
4852
4856
 int AP = 0; ErlDrvTermData *rt;
4853
4857
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*count)*2));
4854
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4858
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4855
4859
 for(int i=0; i < *count; i++) {
4856
4860
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) obj[i];}
4857
4861
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*count)+1;
4858
4862
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4859
 
 if (AP != 7 + (*count)*2 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7 + (*count)*2);
4860
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4861
 
 driver_free(rt); 
 
4863
 driver_send_term(port,caller,rt,AP);
 
4864
 driver_free(rt);
4862
4865
 driver_free(obj);
4863
 
}; break; 
4864
 
case 5631: { // glGetUniformLocationARB 
 
4866
}; break;
 
4867
case 5641: { // glGetUniformLocationARB
4865
4868
 GLhandleARB programObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4866
4869
 GLchar *name = (GLchar *) bp;
4867
 
 int nameLen = strlen((char *)name); bp += nameLen+1+((8-((1+nameLen+0)%8))%8);
 
4870
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+0)%8))%8);
4868
4871
 GLint result = weglGetUniformLocationARB(programObj,name);
4869
4872
 int AP = 0; ErlDrvTermData rt[6];
4870
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4873
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4871
4874
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
4872
4875
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4873
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
4874
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4875
 
}; break; 
4876
 
case 5632: { // glGetActiveUniformARB 
 
4876
 driver_send_term(port,caller,rt,AP);
 
4877
}; break;
 
4878
case 5642: { // glGetActiveUniformARB
4877
4879
 GLhandleARB programObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4878
4880
 GLuint *index = (GLuint *) bp; bp += 4;
4879
4881
 GLsizei *maxLength = (GLsizei *) bp; bp += 4;
4884
4886
 name = (GLchar *) driver_alloc(sizeof(GLchar) * *maxLength);
4885
4887
 weglGetActiveUniformARB(programObj,*index,*maxLength,length,size,type,name);
4886
4888
 int AP = 0; ErlDrvTermData rt[13];
4887
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4889
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4888
4890
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *size;
4889
4891
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *type;
4890
4892
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) name; rt[AP++] = *length;
4891
4893
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 3;
4892
4894
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4893
 
 if (AP != 13 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,13);
4894
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
 
4895
 driver_send_term(port,caller,rt,AP);
4895
4896
 driver_free(name);
4896
 
}; break; 
4897
 
case 5633: { // glGetUniformfvARB 
 
4897
}; break;
 
4898
case 5643: { // glGetUniformfvARB
4898
4899
 GLhandleARB programObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4899
4900
 GLint *location = (GLint *) bp; bp += 4;
4900
4901
 GLfloat params[16] = {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
4901
4902
 weglGetUniformfvARB(programObj,*location,params);
4902
4903
 int AP = 0; ErlDrvTermData rt[38];
4903
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4904
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4904
4905
 GLdouble paramsConv[16], *paramsTmp = paramsConv; 
4905
4906
 for(int i=0; i < 16; i++) paramsConv[i] = (GLdouble) params[i];
4906
4907
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
4921
4922
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
4922
4923
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 16;
4923
4924
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4924
 
 if (AP != 38 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,38);
4925
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4926
 
}; break; 
4927
 
case 5634: { // glGetUniformivARB 
 
4925
 driver_send_term(port,caller,rt,AP);
 
4926
}; break;
 
4927
case 5644: { // glGetUniformivARB
4928
4928
 GLhandleARB programObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4929
4929
 GLint *location = (GLint *) bp; bp += 4;
4930
4930
 GLint params[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
4931
4931
 weglGetUniformivARB(programObj,*location,params);
4932
4932
 int AP = 0; ErlDrvTermData rt[38];
4933
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4933
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4934
4934
 GLint *paramsTmp = params;
4935
4935
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4936
4936
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4950
4950
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
4951
4951
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 16;
4952
4952
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4953
 
 if (AP != 38 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,38);
4954
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
4955
 
}; break; 
4956
 
case 5635: { // glGetShaderSourceARB 
 
4953
 driver_send_term(port,caller,rt,AP);
 
4954
}; break;
 
4955
case 5645: { // glGetShaderSourceARB
4957
4956
 GLhandleARB obj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4958
4957
 GLsizei *maxLength = (GLsizei *) bp; bp += 4;
4959
4958
 GLsizei length[1] = {0};
4961
4960
 source = (GLchar *) driver_alloc(sizeof(GLchar) * *maxLength);
4962
4961
 weglGetShaderSourceARB(obj,*maxLength,length,source);
4963
4962
 int AP = 0; ErlDrvTermData rt[7];
4964
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4963
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4965
4964
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) source; rt[AP++] = *length;
4966
4965
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4967
 
 if (AP != 7 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7);
4968
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
 
4966
 driver_send_term(port,caller,rt,AP);
4969
4967
 driver_free(source);
4970
 
}; break; 
4971
 
case 5636: { // glBindAttribLocationARB 
 
4968
}; break;
 
4969
case 5646: { // glBindAttribLocationARB
4972
4970
 GLhandleARB programObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4973
4971
 GLuint *index = (GLuint *) bp; bp += 4;
4974
4972
 GLchar *name = (GLchar *) bp;
4975
 
 int nameLen = strlen((char *)name); bp += nameLen+1+((8-((1+nameLen+4)%8))%8);
 
4973
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+4)%8))%8);
4976
4974
 weglBindAttribLocationARB(programObj,*index,name);
4977
 
}; break; 
4978
 
case 5637: { // glGetActiveAttribARB 
 
4975
}; break;
 
4976
case 5647: { // glGetActiveAttribARB
4979
4977
 GLhandleARB programObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
4980
4978
 GLuint *index = (GLuint *) bp; bp += 4;
4981
4979
 GLsizei *maxLength = (GLsizei *) bp; bp += 4;
4986
4984
 name = (GLchar *) driver_alloc(sizeof(GLchar) * *maxLength);
4987
4985
 weglGetActiveAttribARB(programObj,*index,*maxLength,length,size,type,name);
4988
4986
 int AP = 0; ErlDrvTermData rt[13];
4989
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
4987
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
4990
4988
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *size;
4991
4989
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *type;
4992
4990
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) name; rt[AP++] = *length;
4993
4991
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 3;
4994
4992
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
4995
 
 if (AP != 13 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,13);
4996
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
 
4993
 driver_send_term(port,caller,rt,AP);
4997
4994
 driver_free(name);
4998
 
}; break; 
4999
 
case 5638: { // glGetAttribLocationARB 
 
4995
}; break;
 
4996
case 5648: { // glGetAttribLocationARB
5000
4997
 GLhandleARB programObj = (GLhandleARB) * (GLuint64EXT *) bp; bp += 8;
5001
4998
 GLchar *name = (GLchar *) bp;
5002
 
 int nameLen = strlen((char *)name); bp += nameLen+1+((8-((1+nameLen+0)%8))%8);
 
4999
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+0)%8))%8);
5003
5000
 GLint result = weglGetAttribLocationARB(programObj,name);
5004
5001
 int AP = 0; ErlDrvTermData rt[6];
5005
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5002
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5006
5003
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
5007
5004
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5008
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
5009
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
5010
 
}; break; 
5011
 
case 5639: { // glIsRenderbuffer 
 
5005
 driver_send_term(port,caller,rt,AP);
 
5006
}; break;
 
5007
case 5649: { // glIsRenderbuffer
5012
5008
 GLuint *renderbuffer = (GLuint *) bp; bp += 4;
5013
5009
 GLboolean result = weglIsRenderbuffer(*renderbuffer);
5014
5010
 int AP = 0; ErlDrvTermData rt[6];
5015
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5011
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5016
5012
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
5017
5013
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5018
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
5019
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
5020
 
}; break; 
5021
 
case 5640: { // glBindRenderbuffer 
 
5014
 driver_send_term(port,caller,rt,AP);
 
5015
}; break;
 
5016
case 5650: { // glBindRenderbuffer
5022
5017
 GLenum *target = (GLenum *) bp; bp += 4;
5023
5018
 GLuint *renderbuffer = (GLuint *) bp; bp += 4;
5024
5019
 weglBindRenderbuffer(*target,*renderbuffer);
5025
 
}; break; 
5026
 
case 5641: { // glDeleteRenderbuffers 
 
5020
}; break;
 
5021
case 5651: { // glDeleteRenderbuffers
5027
5022
 int * renderbuffersLen = (int *) bp; bp += 4;
5028
5023
 GLuint * renderbuffers = (GLuint *) bp;  bp += (8-((*renderbuffersLen*4+4)%8))%8;
5029
5024
 weglDeleteRenderbuffers(*renderbuffersLen,renderbuffers);
5030
 
}; break; 
5031
 
case 5642: { // glGenRenderbuffers 
 
5025
}; break;
 
5026
case 5652: { // glGenRenderbuffers
5032
5027
 GLsizei *n = (GLsizei *) bp; bp += 4;
5033
5028
 GLuint *renderbuffers;
5034
5029
 renderbuffers = (GLuint *) driver_alloc(sizeof(GLuint) * *n);
5035
5030
 weglGenRenderbuffers(*n,renderbuffers);
5036
5031
 int AP = 0; ErlDrvTermData *rt;
5037
5032
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*n)*2));
5038
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5033
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5039
5034
 for(int i=0; i < *n; i++) {
5040
5035
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) renderbuffers[i];}
5041
5036
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*n)+1;
5042
5037
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5043
 
 if (AP != 7 + (*n)*2 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7 + (*n)*2);
5044
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
5045
 
 driver_free(rt); 
 
5038
 driver_send_term(port,caller,rt,AP);
 
5039
 driver_free(rt);
5046
5040
 driver_free(renderbuffers);
5047
 
}; break; 
5048
 
case 5643: { // glRenderbufferStorage 
 
5041
}; break;
 
5042
case 5653: { // glRenderbufferStorage
5049
5043
 GLenum *target = (GLenum *) bp; bp += 4;
5050
5044
 GLenum *internalformat = (GLenum *) bp; bp += 4;
5051
5045
 GLsizei *width = (GLsizei *) bp; bp += 4;
5052
5046
 GLsizei *height = (GLsizei *) bp; bp += 4;
5053
5047
 weglRenderbufferStorage(*target,*internalformat,*width,*height);
5054
 
}; break; 
5055
 
case 5644: { // glGetRenderbufferParameteriv 
 
5048
}; break;
 
5049
case 5654: { // glGetRenderbufferParameteriv
5056
5050
 GLenum *target = (GLenum *) bp; bp += 4;
5057
5051
 GLenum *pname = (GLenum *) bp; bp += 4;
5058
5052
 GLint params[1] = {0};
5059
5053
 weglGetRenderbufferParameteriv(*target,*pname,params);
5060
5054
 int AP = 0; ErlDrvTermData rt[6];
5061
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5055
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5062
5056
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *params;
5063
5057
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5064
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
5065
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
5066
 
}; break; 
5067
 
case 5645: { // glIsFramebuffer 
 
5058
 driver_send_term(port,caller,rt,AP);
 
5059
}; break;
 
5060
case 5655: { // glIsFramebuffer
5068
5061
 GLuint *framebuffer = (GLuint *) bp; bp += 4;
5069
5062
 GLboolean result = weglIsFramebuffer(*framebuffer);
5070
5063
 int AP = 0; ErlDrvTermData rt[6];
5071
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5064
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5072
5065
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
5073
5066
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5074
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
5075
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
5076
 
}; break; 
5077
 
case 5646: { // glBindFramebuffer 
 
5067
 driver_send_term(port,caller,rt,AP);
 
5068
}; break;
 
5069
case 5656: { // glBindFramebuffer
5078
5070
 GLenum *target = (GLenum *) bp; bp += 4;
5079
5071
 GLuint *framebuffer = (GLuint *) bp; bp += 4;
5080
5072
 weglBindFramebuffer(*target,*framebuffer);
5081
 
}; break; 
5082
 
case 5647: { // glDeleteFramebuffers 
 
5073
}; break;
 
5074
case 5657: { // glDeleteFramebuffers
5083
5075
 int * framebuffersLen = (int *) bp; bp += 4;
5084
5076
 GLuint * framebuffers = (GLuint *) bp;  bp += (8-((*framebuffersLen*4+4)%8))%8;
5085
5077
 weglDeleteFramebuffers(*framebuffersLen,framebuffers);
5086
 
}; break; 
5087
 
case 5648: { // glGenFramebuffers 
 
5078
}; break;
 
5079
case 5658: { // glGenFramebuffers
5088
5080
 GLsizei *n = (GLsizei *) bp; bp += 4;
5089
5081
 GLuint *framebuffers;
5090
5082
 framebuffers = (GLuint *) driver_alloc(sizeof(GLuint) * *n);
5091
5083
 weglGenFramebuffers(*n,framebuffers);
5092
5084
 int AP = 0; ErlDrvTermData *rt;
5093
5085
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*n)*2));
5094
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5086
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5095
5087
 for(int i=0; i < *n; i++) {
5096
5088
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) framebuffers[i];}
5097
5089
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*n)+1;
5098
5090
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5099
 
 if (AP != 7 + (*n)*2 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7 + (*n)*2);
5100
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
5101
 
 driver_free(rt); 
 
5091
 driver_send_term(port,caller,rt,AP);
 
5092
 driver_free(rt);
5102
5093
 driver_free(framebuffers);
5103
 
}; break; 
5104
 
case 5649: { // glCheckFramebufferStatus 
 
5094
}; break;
 
5095
case 5659: { // glCheckFramebufferStatus
5105
5096
 GLenum *target = (GLenum *) bp; bp += 4;
5106
5097
 GLenum result = weglCheckFramebufferStatus(*target);
5107
5098
 int AP = 0; ErlDrvTermData rt[6];
5108
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5099
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5109
5100
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
5110
5101
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5111
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
5112
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
5113
 
}; break; 
5114
 
case 5650: { // glFramebufferTexture1D 
 
5102
 driver_send_term(port,caller,rt,AP);
 
5103
}; break;
 
5104
case 5660: { // glFramebufferTexture1D
5115
5105
 GLenum *target = (GLenum *) bp; bp += 4;
5116
5106
 GLenum *attachment = (GLenum *) bp; bp += 4;
5117
5107
 GLenum *textarget = (GLenum *) bp; bp += 4;
5118
5108
 GLuint *texture = (GLuint *) bp; bp += 4;
5119
5109
 GLint *level = (GLint *) bp; bp += 4;
5120
5110
 weglFramebufferTexture1D(*target,*attachment,*textarget,*texture,*level);
5121
 
}; break; 
5122
 
case 5651: { // glFramebufferTexture2D 
 
5111
}; break;
 
5112
case 5661: { // glFramebufferTexture2D
5123
5113
 GLenum *target = (GLenum *) bp; bp += 4;
5124
5114
 GLenum *attachment = (GLenum *) bp; bp += 4;
5125
5115
 GLenum *textarget = (GLenum *) bp; bp += 4;
5126
5116
 GLuint *texture = (GLuint *) bp; bp += 4;
5127
5117
 GLint *level = (GLint *) bp; bp += 4;
5128
5118
 weglFramebufferTexture2D(*target,*attachment,*textarget,*texture,*level);
5129
 
}; break; 
5130
 
case 5652: { // glFramebufferTexture3D 
 
5119
}; break;
 
5120
case 5662: { // glFramebufferTexture3D
5131
5121
 GLenum *target = (GLenum *) bp; bp += 4;
5132
5122
 GLenum *attachment = (GLenum *) bp; bp += 4;
5133
5123
 GLenum *textarget = (GLenum *) bp; bp += 4;
5135
5125
 GLint *level = (GLint *) bp; bp += 4;
5136
5126
 GLint *zoffset = (GLint *) bp; bp += 4;
5137
5127
 weglFramebufferTexture3D(*target,*attachment,*textarget,*texture,*level,*zoffset);
5138
 
}; break; 
5139
 
case 5653: { // glFramebufferRenderbuffer 
 
5128
}; break;
 
5129
case 5663: { // glFramebufferRenderbuffer
5140
5130
 GLenum *target = (GLenum *) bp; bp += 4;
5141
5131
 GLenum *attachment = (GLenum *) bp; bp += 4;
5142
5132
 GLenum *renderbuffertarget = (GLenum *) bp; bp += 4;
5143
5133
 GLuint *renderbuffer = (GLuint *) bp; bp += 4;
5144
5134
 weglFramebufferRenderbuffer(*target,*attachment,*renderbuffertarget,*renderbuffer);
5145
 
}; break; 
5146
 
case 5654: { // glGetFramebufferAttachmentParameteriv 
 
5135
}; break;
 
5136
case 5664: { // glGetFramebufferAttachmentParameteriv
5147
5137
 GLenum *target = (GLenum *) bp; bp += 4;
5148
5138
 GLenum *attachment = (GLenum *) bp; bp += 4;
5149
5139
 GLenum *pname = (GLenum *) bp; bp += 4;
5150
5140
 GLint params[1] = {0};
5151
5141
 weglGetFramebufferAttachmentParameteriv(*target,*attachment,*pname,params);
5152
5142
 int AP = 0; ErlDrvTermData rt[6];
5153
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5143
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5154
5144
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *params;
5155
5145
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5156
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
5157
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
5158
 
}; break; 
5159
 
case 5655: { // glGenerateMipmap 
 
5146
 driver_send_term(port,caller,rt,AP);
 
5147
}; break;
 
5148
case 5665: { // glGenerateMipmap
5160
5149
 GLenum *target = (GLenum *) bp; bp += 4;
5161
5150
 weglGenerateMipmap(*target);
5162
 
}; break; 
5163
 
case 5656: { // glBlitFramebuffer 
 
5151
}; break;
 
5152
case 5666: { // glBlitFramebuffer
5164
5153
 GLint *srcX0 = (GLint *) bp; bp += 4;
5165
5154
 GLint *srcY0 = (GLint *) bp; bp += 4;
5166
5155
 GLint *srcX1 = (GLint *) bp; bp += 4;
5172
5161
 GLbitfield *mask = (GLbitfield *) bp; bp += 4;
5173
5162
 GLenum *filter = (GLenum *) bp; bp += 4;
5174
5163
 weglBlitFramebuffer(*srcX0,*srcY0,*srcX1,*srcY1,*dstX0,*dstY0,*dstX1,*dstY1,*mask,*filter);
5175
 
}; break; 
5176
 
case 5657: { // glRenderbufferStorageMultisample 
 
5164
}; break;
 
5165
case 5667: { // glRenderbufferStorageMultisample
5177
5166
 GLenum *target = (GLenum *) bp; bp += 4;
5178
5167
 GLsizei *samples = (GLsizei *) bp; bp += 4;
5179
5168
 GLenum *internalformat = (GLenum *) bp; bp += 4;
5180
5169
 GLsizei *width = (GLsizei *) bp; bp += 4;
5181
5170
 GLsizei *height = (GLsizei *) bp; bp += 4;
5182
5171
 weglRenderbufferStorageMultisample(*target,*samples,*internalformat,*width,*height);
5183
 
}; break; 
5184
 
case 5658: { // glFramebufferTextureLayer 
 
5172
}; break;
 
5173
case 5668: { // glFramebufferTextureLayer
5185
5174
 GLenum *target = (GLenum *) bp; bp += 4;
5186
5175
 GLenum *attachment = (GLenum *) bp; bp += 4;
5187
5176
 GLuint *texture = (GLuint *) bp; bp += 4;
5188
5177
 GLint *level = (GLint *) bp; bp += 4;
5189
5178
 GLint *layer = (GLint *) bp; bp += 4;
5190
5179
 weglFramebufferTextureLayer(*target,*attachment,*texture,*level,*layer);
5191
 
}; break; 
5192
 
case 5659: { // glProgramParameteriARB 
5193
 
 GLuint *program = (GLuint *) bp; bp += 4;
5194
 
 GLenum *pname = (GLenum *) bp; bp += 4;
5195
 
 GLint *value = (GLint *) bp; bp += 4;
5196
 
 weglProgramParameteriARB(*program,*pname,*value);
5197
 
}; break; 
5198
 
case 5660: { // glFramebufferTextureARB 
5199
 
 GLenum *target = (GLenum *) bp; bp += 4;
5200
 
 GLenum *attachment = (GLenum *) bp; bp += 4;
5201
 
 GLuint *texture = (GLuint *) bp; bp += 4;
5202
 
 GLint *level = (GLint *) bp; bp += 4;
5203
 
 weglFramebufferTextureARB(*target,*attachment,*texture,*level);
5204
 
}; break; 
5205
 
case 5661: { // glFramebufferTextureFaceARB 
 
5180
}; break;
 
5181
case 5669: { // glFramebufferTextureFaceARB
5206
5182
 GLenum *target = (GLenum *) bp; bp += 4;
5207
5183
 GLenum *attachment = (GLenum *) bp; bp += 4;
5208
5184
 GLuint *texture = (GLuint *) bp; bp += 4;
5209
5185
 GLint *level = (GLint *) bp; bp += 4;
5210
5186
 GLenum *face = (GLenum *) bp; bp += 4;
5211
5187
 weglFramebufferTextureFaceARB(*target,*attachment,*texture,*level,*face);
5212
 
}; break; 
5213
 
case 5662: { // glVertexAttribDivisorARB 
5214
 
 GLuint *index = (GLuint *) bp; bp += 4;
5215
 
 GLuint *divisor = (GLuint *) bp; bp += 4;
5216
 
 weglVertexAttribDivisorARB(*index,*divisor);
5217
 
}; break; 
5218
 
case 5663: { // glFlushMappedBufferRange 
 
5188
}; break;
 
5189
case 5670: { // glFlushMappedBufferRange
5219
5190
 GLenum *target = (GLenum *) bp; bp += 4;
5220
5191
 bp += 4;
5221
5192
 GLintptr offset = (GLintptr) * (GLuint64EXT *) bp; bp += 8;
5222
5193
 GLsizeiptr length = (GLsizeiptr) * (GLuint64EXT *) bp; bp += 8;
5223
5194
 weglFlushMappedBufferRange(*target,offset,length);
5224
 
}; break; 
5225
 
case 5664: { // glBindVertexArray 
 
5195
}; break;
 
5196
case 5671: { // glBindVertexArray
5226
5197
 GLuint *array = (GLuint *) bp; bp += 4;
5227
5198
 weglBindVertexArray(*array);
5228
 
}; break; 
5229
 
case 5665: { // glDeleteVertexArrays 
 
5199
}; break;
 
5200
case 5672: { // glDeleteVertexArrays
5230
5201
 int * arraysLen = (int *) bp; bp += 4;
5231
5202
 GLuint * arrays = (GLuint *) bp;  bp += (8-((*arraysLen*4+4)%8))%8;
5232
5203
 weglDeleteVertexArrays(*arraysLen,arrays);
5233
 
}; break; 
5234
 
case 5666: { // glGenVertexArrays 
 
5204
}; break;
 
5205
case 5673: { // glGenVertexArrays
5235
5206
 GLsizei *n = (GLsizei *) bp; bp += 4;
5236
5207
 GLuint *arrays;
5237
5208
 arrays = (GLuint *) driver_alloc(sizeof(GLuint) * *n);
5238
5209
 weglGenVertexArrays(*n,arrays);
5239
5210
 int AP = 0; ErlDrvTermData *rt;
5240
5211
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*n)*2));
5241
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5212
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5242
5213
 for(int i=0; i < *n; i++) {
5243
5214
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) arrays[i];}
5244
5215
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*n)+1;
5245
5216
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5246
 
 if (AP != 7 + (*n)*2 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7 + (*n)*2);
5247
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
5248
 
 driver_free(rt); 
 
5217
 driver_send_term(port,caller,rt,AP);
 
5218
 driver_free(rt);
5249
5219
 driver_free(arrays);
5250
 
}; break; 
5251
 
case 5667: { // glIsVertexArray 
 
5220
}; break;
 
5221
case 5674: { // glIsVertexArray
5252
5222
 GLuint *array = (GLuint *) bp; bp += 4;
5253
5223
 GLboolean result = weglIsVertexArray(*array);
5254
5224
 int AP = 0; ErlDrvTermData rt[6];
5255
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5225
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5256
5226
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
5257
5227
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5258
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
5259
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
5260
 
}; break; 
5261
 
case 5668: { // glGetUniformIndices 
 
5228
 driver_send_term(port,caller,rt,AP);
 
5229
}; break;
 
5230
case 5675: { // glGetUniformIndices
5262
5231
 GLuint *program = (GLuint *) bp; bp += 4;
5263
5232
 int * uniformNamesLen = (int *) bp; bp += 4;
5264
5233
 int * uniformNamesTotSize = (int *) bp; bp += 4;
5265
5234
 GLchar **uniformNames;
5266
 
 uniformNames = (GLchar **) driver_alloc(sizeof(GLchar *) * *uniformNamesLen); 
 
5235
 uniformNames = (GLchar **) driver_alloc(sizeof(GLchar *) * *uniformNamesLen);
5267
5236
 for(int i=0;i<*uniformNamesLen;i++) {
5268
5237
    uniformNames[i] = (GLchar *) bp; bp += 1+strlen(bp);};
5269
5238
 bp += (8 - ((0 + *uniformNamesTotSize) % 8)) % 8;
5272
5241
 weglGetUniformIndices(*program,*uniformNamesLen,(const GLchar **) uniformNames,uniformIndices);
5273
5242
 int AP = 0; ErlDrvTermData *rt;
5274
5243
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*uniformNamesLen)*2));
5275
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5244
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5276
5245
 for(int i=0; i < *uniformNamesLen; i++) {
5277
5246
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) uniformIndices[i];}
5278
5247
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*uniformNamesLen)+1;
5279
5248
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5280
 
 if (AP != 7 + (*uniformNamesLen)*2 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7 + (*uniformNamesLen)*2);
5281
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
5282
 
 driver_free(rt); 
 
5249
 driver_send_term(port,caller,rt,AP);
 
5250
 driver_free(rt);
5283
5251
 driver_free(uniformIndices);
5284
5252
 driver_free(uniformNames);
5285
 
}; break; 
5286
 
case 5669: { // glGetActiveUniformsiv 
 
5253
}; break;
 
5254
case 5676: { // glGetActiveUniformsiv
5287
5255
 GLuint *program = (GLuint *) bp; bp += 4;
5288
5256
 int * uniformIndicesLen = (int *) bp; bp += 4;
5289
5257
 GLuint * uniformIndices = (GLuint *) bp;  bp += (8-((*uniformIndicesLen*4+0)%8))%8;
5293
5261
 weglGetActiveUniformsiv(*program,*uniformIndicesLen,uniformIndices,*pname,params);
5294
5262
 int AP = 0; ErlDrvTermData *rt;
5295
5263
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*uniformIndicesLen)*2));
5296
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5264
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5297
5265
 for(int i=0; i < *uniformIndicesLen; i++) {
5298
5266
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) params[i];}
5299
5267
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*uniformIndicesLen)+1;
5300
5268
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5301
 
 if (AP != 7 + (*uniformIndicesLen)*2 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7 + (*uniformIndicesLen)*2);
5302
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
5303
 
 driver_free(rt); 
 
5269
 driver_send_term(port,caller,rt,AP);
 
5270
 driver_free(rt);
5304
5271
 driver_free(params);
5305
 
}; break; 
5306
 
case 5670: { // glGetActiveUniformName 
 
5272
}; break;
 
5273
case 5677: { // glGetActiveUniformName
5307
5274
 GLuint *program = (GLuint *) bp; bp += 4;
5308
5275
 GLuint *uniformIndex = (GLuint *) bp; bp += 4;
5309
5276
 GLsizei *bufSize = (GLsizei *) bp; bp += 4;
5312
5279
 uniformName = (GLchar *) driver_alloc(sizeof(GLchar) * *bufSize);
5313
5280
 weglGetActiveUniformName(*program,*uniformIndex,*bufSize,length,uniformName);
5314
5281
 int AP = 0; ErlDrvTermData rt[7];
5315
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5282
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5316
5283
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) uniformName; rt[AP++] = *length;
5317
5284
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5318
 
 if (AP != 7 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7);
5319
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
 
5285
 driver_send_term(port,caller,rt,AP);
5320
5286
 driver_free(uniformName);
5321
 
}; break; 
5322
 
case 5671: { // glGetUniformBlockIndex 
 
5287
}; break;
 
5288
case 5678: { // glGetUniformBlockIndex
5323
5289
 GLuint *program = (GLuint *) bp; bp += 4;
5324
5290
 GLchar *uniformBlockName = (GLchar *) bp;
5325
 
 int uniformBlockNameLen = strlen((char *)uniformBlockName); bp += uniformBlockNameLen+1+((8-((1+uniformBlockNameLen+4)%8))%8);
 
5291
 int uniformBlockNameLen[1] = {strlen((char *)uniformBlockName)}; bp += uniformBlockNameLen[0]+1+((8-((1+uniformBlockNameLen[0]+4)%8))%8);
5326
5292
 GLuint result = weglGetUniformBlockIndex(*program,uniformBlockName);
5327
5293
 int AP = 0; ErlDrvTermData rt[6];
5328
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5294
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5329
5295
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
5330
5296
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5331
 
 if (AP != 6 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,6);
5332
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
5333
 
}; break; 
5334
 
case 5672: { // glGetActiveUniformBlockiv 
 
5297
 driver_send_term(port,caller,rt,AP);
 
5298
}; break;
 
5299
case 5679: { // glGetActiveUniformBlockiv
5335
5300
 GLuint *program = (GLuint *) bp; bp += 4;
5336
5301
 GLuint *uniformBlockIndex = (GLuint *) bp; bp += 4;
5337
5302
 GLenum *pname = (GLenum *) bp; bp += 4;
5338
 
 GLint *params = (GLint *) bins[0]->base;
 
5303
 GLint *params = (GLint *) bins[0];
5339
5304
 weglGetActiveUniformBlockiv(*program,*uniformBlockIndex,*pname,params);
5340
5305
 int AP = 0; ErlDrvTermData rt[6];
5341
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5306
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5342
5307
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "ok");
5343
5308
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5344
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
5345
 
}; break; 
5346
 
case 5673: { // glGetActiveUniformBlockName 
 
5309
 driver_send_term(port,caller,rt,AP);
 
5310
}; break;
 
5311
case 5680: { // glGetActiveUniformBlockName
5347
5312
 GLuint *program = (GLuint *) bp; bp += 4;
5348
5313
 GLuint *uniformBlockIndex = (GLuint *) bp; bp += 4;
5349
5314
 GLsizei *bufSize = (GLsizei *) bp; bp += 4;
5352
5317
 uniformBlockName = (GLchar *) driver_alloc(sizeof(GLchar) * *bufSize);
5353
5318
 weglGetActiveUniformBlockName(*program,*uniformBlockIndex,*bufSize,length,uniformBlockName);
5354
5319
 int AP = 0; ErlDrvTermData rt[7];
5355
 
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_wxe_result_");
 
5320
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
5356
5321
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) uniformBlockName; rt[AP++] = *length;
5357
5322
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
5358
 
 if (AP != 7 )  fprintf(stderr, "%d: ERROR AP mismatch %d %d\r\n",__LINE__,AP,7);
5359
 
 driver_send_term(WXE_DRV_PORT,caller,rt,AP);
 
5323
 driver_send_term(port,caller,rt,AP);
5360
5324
 driver_free(uniformBlockName);
5361
 
}; break; 
5362
 
case 5674: { // glUniformBlockBinding 
 
5325
}; break;
 
5326
case 5681: { // glUniformBlockBinding
5363
5327
 GLuint *program = (GLuint *) bp; bp += 4;
5364
5328
 GLuint *uniformBlockIndex = (GLuint *) bp; bp += 4;
5365
5329
 GLuint *uniformBlockBinding = (GLuint *) bp; bp += 4;
5366
5330
 weglUniformBlockBinding(*program,*uniformBlockIndex,*uniformBlockBinding);
5367
 
}; break; 
5368
 
case 5675: { // glCopyBufferSubData 
 
5331
}; break;
 
5332
case 5682: { // glCopyBufferSubData
5369
5333
 GLenum *readTarget = (GLenum *) bp; bp += 4;
5370
5334
 GLenum *writeTarget = (GLenum *) bp; bp += 4;
5371
5335
 GLintptr readOffset = (GLintptr) * (GLuint64EXT *) bp; bp += 8;
5372
5336
 GLintptr writeOffset = (GLintptr) * (GLuint64EXT *) bp; bp += 8;
5373
5337
 GLsizeiptr size = (GLsizeiptr) * (GLuint64EXT *) bp; bp += 8;
5374
5338
 weglCopyBufferSubData(*readTarget,*writeTarget,readOffset,writeOffset,size);
5375
 
}; break; 
5376
 
case 5676: { // glResizeBuffersMESA 
 
5339
}; break;
 
5340
case 5683: { // glDrawElementsBaseVertex
 
5341
 GLenum *mode = (GLenum *) bp; bp += 4;
 
5342
 GLsizei *count = (GLsizei *) bp; bp += 4;
 
5343
 GLenum *type = (GLenum *) bp; bp += 4;
 
5344
 GLvoid *indices = (GLvoid *) * (int *) bp; bp += 4;
 
5345
 GLint *basevertex = (GLint *) bp; bp += 4;
 
5346
 weglDrawElementsBaseVertex(*mode,*count,*type,indices,*basevertex);
 
5347
}; break;
 
5348
case 5684: { // glDrawElementsBaseVertex
 
5349
 GLenum *mode = (GLenum *) bp; bp += 4;
 
5350
 GLsizei *count = (GLsizei *) bp; bp += 4;
 
5351
 GLenum *type = (GLenum *) bp; bp += 4;
 
5352
 GLvoid *indices = (GLvoid *) bins[0];
 
5353
 GLint *basevertex = (GLint *) bp; bp += 4;
 
5354
 weglDrawElementsBaseVertex(*mode,*count,*type,indices,*basevertex);
 
5355
}; break;
 
5356
case 5685: { // glDrawRangeElementsBaseVertex
 
5357
 GLenum *mode = (GLenum *) bp; bp += 4;
 
5358
 GLuint *start = (GLuint *) bp; bp += 4;
 
5359
 GLuint *end = (GLuint *) bp; bp += 4;
 
5360
 GLsizei *count = (GLsizei *) bp; bp += 4;
 
5361
 GLenum *type = (GLenum *) bp; bp += 4;
 
5362
 GLvoid *indices = (GLvoid *) * (int *) bp; bp += 4;
 
5363
 GLint *basevertex = (GLint *) bp; bp += 4;
 
5364
 weglDrawRangeElementsBaseVertex(*mode,*start,*end,*count,*type,indices,*basevertex);
 
5365
}; break;
 
5366
case 5686: { // glDrawRangeElementsBaseVertex
 
5367
 GLenum *mode = (GLenum *) bp; bp += 4;
 
5368
 GLuint *start = (GLuint *) bp; bp += 4;
 
5369
 GLuint *end = (GLuint *) bp; bp += 4;
 
5370
 GLsizei *count = (GLsizei *) bp; bp += 4;
 
5371
 GLenum *type = (GLenum *) bp; bp += 4;
 
5372
 GLvoid *indices = (GLvoid *) bins[0];
 
5373
 GLint *basevertex = (GLint *) bp; bp += 4;
 
5374
 weglDrawRangeElementsBaseVertex(*mode,*start,*end,*count,*type,indices,*basevertex);
 
5375
}; break;
 
5376
case 5687: { // glDrawElementsInstancedBaseVertex
 
5377
 GLenum *mode = (GLenum *) bp; bp += 4;
 
5378
 GLsizei *count = (GLsizei *) bp; bp += 4;
 
5379
 GLenum *type = (GLenum *) bp; bp += 4;
 
5380
 GLvoid *indices = (GLvoid *) * (int *) bp; bp += 4;
 
5381
 GLsizei *primcount = (GLsizei *) bp; bp += 4;
 
5382
 GLint *basevertex = (GLint *) bp; bp += 4;
 
5383
 weglDrawElementsInstancedBaseVertex(*mode,*count,*type,indices,*primcount,*basevertex);
 
5384
}; break;
 
5385
case 5688: { // glDrawElementsInstancedBaseVertex
 
5386
 GLenum *mode = (GLenum *) bp; bp += 4;
 
5387
 GLsizei *count = (GLsizei *) bp; bp += 4;
 
5388
 GLenum *type = (GLenum *) bp; bp += 4;
 
5389
 GLvoid *indices = (GLvoid *) bins[0];
 
5390
 GLsizei *primcount = (GLsizei *) bp; bp += 4;
 
5391
 GLint *basevertex = (GLint *) bp; bp += 4;
 
5392
 weglDrawElementsInstancedBaseVertex(*mode,*count,*type,indices,*primcount,*basevertex);
 
5393
}; break;
 
5394
case 5689: { // glProvokingVertex
 
5395
 GLenum *mode = (GLenum *) bp; bp += 4;
 
5396
 weglProvokingVertex(*mode);
 
5397
}; break;
 
5398
case 5690: { // glFenceSync
 
5399
 GLenum *condition = (GLenum *) bp; bp += 4;
 
5400
 GLbitfield *flags = (GLbitfield *) bp; bp += 4;
 
5401
 GLsync result = weglFenceSync(*condition,*flags);
 
5402
 int AP = 0; ErlDrvTermData rt[6];
 
5403
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5404
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
 
5405
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5406
 driver_send_term(port,caller,rt,AP);
 
5407
}; break;
 
5408
case 5691: { // glIsSync
 
5409
 GLsync sync = (GLsync) * (GLuint64EXT *) bp; bp += 8;
 
5410
 GLboolean result = weglIsSync(sync);
 
5411
 int AP = 0; ErlDrvTermData rt[6];
 
5412
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5413
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
 
5414
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5415
 driver_send_term(port,caller,rt,AP);
 
5416
}; break;
 
5417
case 5692: { // glDeleteSync
 
5418
 GLsync sync = (GLsync) * (GLuint64EXT *) bp; bp += 8;
 
5419
 weglDeleteSync(sync);
 
5420
}; break;
 
5421
case 5693: { // glClientWaitSync
 
5422
 GLsync sync = (GLsync) * (GLuint64EXT *) bp; bp += 8;
 
5423
 GLbitfield *flags = (GLbitfield *) bp; bp += 4;
 
5424
 bp += 4;
 
5425
 GLuint64 timeout = (GLuint64) * (GLuint64EXT *) bp; bp += 8;
 
5426
 GLenum result = weglClientWaitSync(sync,*flags,timeout);
 
5427
 int AP = 0; ErlDrvTermData rt[6];
 
5428
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5429
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
 
5430
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5431
 driver_send_term(port,caller,rt,AP);
 
5432
}; break;
 
5433
case 5694: { // glWaitSync
 
5434
 GLsync sync = (GLsync) * (GLuint64EXT *) bp; bp += 8;
 
5435
 GLbitfield *flags = (GLbitfield *) bp; bp += 4;
 
5436
 bp += 4;
 
5437
 GLuint64 timeout = (GLuint64) * (GLuint64EXT *) bp; bp += 8;
 
5438
 weglWaitSync(sync,*flags,timeout);
 
5439
}; break;
 
5440
case 5695: { // glGetInteger64v
 
5441
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5442
 GLint64 params[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 
5443
 weglGetInteger64v(*pname,params);
 
5444
 int AP = 0; ErlDrvTermData rt[39];
 
5445
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5446
 GLint64 *paramsTmp = params;
 
5447
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5448
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5449
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5450
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5451
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5452
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5453
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5454
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5455
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5456
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5457
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5458
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5459
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5460
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5461
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5462
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5463
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 16+1;
 
5464
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5465
 driver_send_term(port,caller,rt,AP);
 
5466
}; break;
 
5467
case 5696: { // glGetSynciv
 
5468
 GLsync sync = (GLsync) * (GLuint64EXT *) bp; bp += 8;
 
5469
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5470
 GLsizei *bufSize = (GLsizei *) bp; bp += 4;
 
5471
 GLsizei length[1] = {0};
 
5472
 GLint *values;
 
5473
 values = (GLint *) driver_alloc(sizeof(GLint) * *bufSize);
 
5474
 weglGetSynciv(sync,*pname,*bufSize,length,values);
 
5475
 int AP = 0; ErlDrvTermData *rt;
 
5476
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*length)*2));
 
5477
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5478
 for(int i=0; i < *length; i++) {
 
5479
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) values[i];}
 
5480
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*length)+1;
 
5481
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5482
 driver_send_term(port,caller,rt,AP);
 
5483
 driver_free(rt);
 
5484
 driver_free(values);
 
5485
}; break;
 
5486
case 5697: { // glTexImage2DMultisample
 
5487
 GLenum *target = (GLenum *) bp; bp += 4;
 
5488
 GLsizei *samples = (GLsizei *) bp; bp += 4;
 
5489
 GLint *internalformat = (GLint *) bp; bp += 4;
 
5490
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
5491
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
5492
 GLboolean *fixedsamplelocations = (GLboolean *) bp; bp += 1;
 
5493
 weglTexImage2DMultisample(*target,*samples,*internalformat,*width,*height,*fixedsamplelocations);
 
5494
}; break;
 
5495
case 5698: { // glTexImage3DMultisample
 
5496
 GLenum *target = (GLenum *) bp; bp += 4;
 
5497
 GLsizei *samples = (GLsizei *) bp; bp += 4;
 
5498
 GLint *internalformat = (GLint *) bp; bp += 4;
 
5499
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
5500
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
5501
 GLsizei *depth = (GLsizei *) bp; bp += 4;
 
5502
 GLboolean *fixedsamplelocations = (GLboolean *) bp; bp += 1;
 
5503
 weglTexImage3DMultisample(*target,*samples,*internalformat,*width,*height,*depth,*fixedsamplelocations);
 
5504
}; break;
 
5505
case 5699: { // glGetMultisamplefv
 
5506
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5507
 GLuint *index = (GLuint *) bp; bp += 4;
 
5508
 GLfloat val[2] = {0.0,0.0};
 
5509
 weglGetMultisamplefv(*pname,*index,val);
 
5510
 int AP = 0; ErlDrvTermData rt[10];
 
5511
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5512
 GLdouble valConv[2], *valTmp = valConv; 
 
5513
 for(int i=0; i < 2; i++) valConv[i] = (GLdouble) val[i];
 
5514
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) valTmp++;
 
5515
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) valTmp++;
 
5516
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5517
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5518
 driver_send_term(port,caller,rt,AP);
 
5519
}; break;
 
5520
case 5700: { // glSampleMaski
 
5521
 GLuint *index = (GLuint *) bp; bp += 4;
 
5522
 GLbitfield *mask = (GLbitfield *) bp; bp += 4;
 
5523
 weglSampleMaski(*index,*mask);
 
5524
}; break;
 
5525
case 5701: { // glNamedStringARB
 
5526
 GLenum *type = (GLenum *) bp; bp += 4;
 
5527
 GLchar *name = (GLchar *) bp;
 
5528
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+4)%8))%8);
 
5529
 GLchar *string = (GLchar *) bp;
 
5530
 int stringLen[1] = {strlen((char *)string)}; bp += stringLen[0]+1+((8-((1+stringLen[0]+0)%8))%8);
 
5531
 weglNamedStringARB(*type,*nameLen,name,*stringLen,string);
 
5532
}; break;
 
5533
case 5702: { // glDeleteNamedStringARB
 
5534
 GLchar *name = (GLchar *) bp;
 
5535
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+0)%8))%8);
 
5536
 weglDeleteNamedStringARB(*nameLen,name);
 
5537
}; break;
 
5538
case 5703: { // glCompileShaderIncludeARB
 
5539
 GLuint *shader = (GLuint *) bp; bp += 4;
 
5540
 int * pathLen = (int *) bp; bp += 4;
 
5541
 int * pathTotSize = (int *) bp; bp += 4;
 
5542
 GLchar **path;
 
5543
 path = (GLchar **) driver_alloc(sizeof(GLchar *) * *pathLen);
 
5544
 for(int i=0;i<*pathLen;i++) {
 
5545
    path[i] = (GLchar *) bp; bp += 1+strlen(bp);};
 
5546
 bp += (8 - ((0 + *pathTotSize) % 8)) % 8;
 
5547
 weglCompileShaderIncludeARB(*shader,*pathLen,(const GLchar **) path,NULL);
 
5548
 driver_free(path);
 
5549
}; break;
 
5550
case 5704: { // glIsNamedStringARB
 
5551
 GLchar *name = (GLchar *) bp;
 
5552
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+0)%8))%8);
 
5553
 GLboolean result = weglIsNamedStringARB(*nameLen,name);
 
5554
 int AP = 0; ErlDrvTermData rt[6];
 
5555
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5556
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
 
5557
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5558
 driver_send_term(port,caller,rt,AP);
 
5559
}; break;
 
5560
case 5705: { // glGetNamedStringARB
 
5561
 GLchar *name = (GLchar *) bp;
 
5562
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+0)%8))%8);
 
5563
 GLsizei *bufSize = (GLsizei *) bp; bp += 4;
 
5564
 GLint stringlen[1] = {0};
 
5565
 GLchar *string;
 
5566
 string = (GLchar *) driver_alloc(sizeof(GLchar) * *bufSize);
 
5567
 weglGetNamedStringARB(*nameLen,name,*bufSize,stringlen,string);
 
5568
 int AP = 0; ErlDrvTermData rt[7];
 
5569
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5570
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) string; rt[AP++] = *stringlen;
 
5571
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5572
 driver_send_term(port,caller,rt,AP);
 
5573
 driver_free(string);
 
5574
}; break;
 
5575
case 5706: { // glGetNamedStringivARB
 
5576
 GLchar *name = (GLchar *) bp;
 
5577
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+0)%8))%8);
 
5578
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5579
 GLint params[1] = {0};
 
5580
 weglGetNamedStringivARB(*nameLen,name,*pname,params);
 
5581
 int AP = 0; ErlDrvTermData rt[6];
 
5582
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5583
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *params;
 
5584
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5585
 driver_send_term(port,caller,rt,AP);
 
5586
}; break;
 
5587
case 5707: { // glBindFragDataLocationIndexed
 
5588
 GLuint *program = (GLuint *) bp; bp += 4;
 
5589
 GLuint *colorNumber = (GLuint *) bp; bp += 4;
 
5590
 GLuint *index = (GLuint *) bp; bp += 4;
 
5591
 GLchar *name = (GLchar *) bp;
 
5592
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+4)%8))%8);
 
5593
 weglBindFragDataLocationIndexed(*program,*colorNumber,*index,name);
 
5594
}; break;
 
5595
case 5708: { // glGetFragDataIndex
 
5596
 GLuint *program = (GLuint *) bp; bp += 4;
 
5597
 GLchar *name = (GLchar *) bp;
 
5598
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+4)%8))%8);
 
5599
 GLint result = weglGetFragDataIndex(*program,name);
 
5600
 int AP = 0; ErlDrvTermData rt[6];
 
5601
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5602
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
 
5603
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5604
 driver_send_term(port,caller,rt,AP);
 
5605
}; break;
 
5606
case 5709: { // glGenSamplers
 
5607
 GLsizei *count = (GLsizei *) bp; bp += 4;
 
5608
 GLuint *samplers;
 
5609
 samplers = (GLuint *) driver_alloc(sizeof(GLuint) * *count);
 
5610
 weglGenSamplers(*count,samplers);
 
5611
 int AP = 0; ErlDrvTermData *rt;
 
5612
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*count)*2));
 
5613
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5614
 for(int i=0; i < *count; i++) {
 
5615
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) samplers[i];}
 
5616
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*count)+1;
 
5617
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5618
 driver_send_term(port,caller,rt,AP);
 
5619
 driver_free(rt);
 
5620
 driver_free(samplers);
 
5621
}; break;
 
5622
case 5710: { // glDeleteSamplers
 
5623
 int * samplersLen = (int *) bp; bp += 4;
 
5624
 GLuint * samplers = (GLuint *) bp;  bp += (8-((*samplersLen*4+4)%8))%8;
 
5625
 weglDeleteSamplers(*samplersLen,samplers);
 
5626
}; break;
 
5627
case 5711: { // glIsSampler
 
5628
 GLuint *sampler = (GLuint *) bp; bp += 4;
 
5629
 GLboolean result = weglIsSampler(*sampler);
 
5630
 int AP = 0; ErlDrvTermData rt[6];
 
5631
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5632
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
 
5633
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5634
 driver_send_term(port,caller,rt,AP);
 
5635
}; break;
 
5636
case 5712: { // glBindSampler
 
5637
 GLuint *unit = (GLuint *) bp; bp += 4;
 
5638
 GLuint *sampler = (GLuint *) bp; bp += 4;
 
5639
 weglBindSampler(*unit,*sampler);
 
5640
}; break;
 
5641
case 5713: { // glSamplerParameteri
 
5642
 GLuint *sampler = (GLuint *) bp; bp += 4;
 
5643
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5644
 GLint *param = (GLint *) bp; bp += 4;
 
5645
 weglSamplerParameteri(*sampler,*pname,*param);
 
5646
}; break;
 
5647
case 5714: { // glSamplerParameteriv
 
5648
 GLuint *sampler = (GLuint *) bp; bp += 4;
 
5649
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5650
 int * paramLen = (int *) bp; bp += 4;
 
5651
 GLint * param = (GLint *) bp;  bp += (8-((*paramLen*4+4)%8))%8;
 
5652
 weglSamplerParameteriv(*sampler,*pname,param);
 
5653
}; break;
 
5654
case 5715: { // glSamplerParameterf
 
5655
 GLuint *sampler = (GLuint *) bp; bp += 4;
 
5656
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5657
 GLfloat *param = (GLfloat *) bp; bp += 4;
 
5658
 weglSamplerParameterf(*sampler,*pname,*param);
 
5659
}; break;
 
5660
case 5716: { // glSamplerParameterfv
 
5661
 GLuint *sampler = (GLuint *) bp; bp += 4;
 
5662
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5663
 int * paramLen = (int *) bp; bp += 4;
 
5664
 GLfloat * param = (GLfloat *) bp;  bp += (8-((*paramLen*4+4)%8))%8;
 
5665
 weglSamplerParameterfv(*sampler,*pname,param);
 
5666
}; break;
 
5667
case 5717: { // glSamplerParameterIiv
 
5668
 GLuint *sampler = (GLuint *) bp; bp += 4;
 
5669
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5670
 int * paramLen = (int *) bp; bp += 4;
 
5671
 GLint * param = (GLint *) bp;  bp += (8-((*paramLen*4+4)%8))%8;
 
5672
 weglSamplerParameterIiv(*sampler,*pname,param);
 
5673
}; break;
 
5674
case 5718: { // glSamplerParameterIuiv
 
5675
 GLuint *sampler = (GLuint *) bp; bp += 4;
 
5676
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5677
 int * paramLen = (int *) bp; bp += 4;
 
5678
 GLuint * param = (GLuint *) bp;  bp += (8-((*paramLen*4+4)%8))%8;
 
5679
 weglSamplerParameterIuiv(*sampler,*pname,param);
 
5680
}; break;
 
5681
case 5719: { // glGetSamplerParameteriv
 
5682
 GLuint *sampler = (GLuint *) bp; bp += 4;
 
5683
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5684
 GLint params[4] = {0,0,0,0};
 
5685
 weglGetSamplerParameteriv(*sampler,*pname,params);
 
5686
 int AP = 0; ErlDrvTermData rt[15];
 
5687
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5688
 GLint *paramsTmp = params;
 
5689
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5690
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5691
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5692
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5693
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 4+1;
 
5694
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5695
 driver_send_term(port,caller,rt,AP);
 
5696
}; break;
 
5697
case 5720: { // glGetSamplerParameterIiv
 
5698
 GLuint *sampler = (GLuint *) bp; bp += 4;
 
5699
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5700
 GLint params[4] = {0,0,0,0};
 
5701
 weglGetSamplerParameterIiv(*sampler,*pname,params);
 
5702
 int AP = 0; ErlDrvTermData rt[15];
 
5703
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5704
 GLint *paramsTmp = params;
 
5705
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5706
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5707
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5708
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5709
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 4+1;
 
5710
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5711
 driver_send_term(port,caller,rt,AP);
 
5712
}; break;
 
5713
case 5721: { // glGetSamplerParameterfv
 
5714
 GLuint *sampler = (GLuint *) bp; bp += 4;
 
5715
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5716
 GLfloat params[4] = {0.0,0.0,0.0,0.0};
 
5717
 weglGetSamplerParameterfv(*sampler,*pname,params);
 
5718
 int AP = 0; ErlDrvTermData rt[15];
 
5719
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5720
 GLdouble paramsConv[4], *paramsTmp = paramsConv; 
 
5721
 for(int i=0; i < 4; i++) paramsConv[i] = (GLdouble) params[i];
 
5722
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5723
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5724
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5725
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5726
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 4+1;
 
5727
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5728
 driver_send_term(port,caller,rt,AP);
 
5729
}; break;
 
5730
case 5722: { // glGetSamplerParameterIuiv
 
5731
 GLuint *sampler = (GLuint *) bp; bp += 4;
 
5732
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5733
 GLuint params[4] = {0,0,0,0};
 
5734
 weglGetSamplerParameterIuiv(*sampler,*pname,params);
 
5735
 int AP = 0; ErlDrvTermData rt[15];
 
5736
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5737
 GLuint *paramsTmp = params;
 
5738
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5739
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5740
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5741
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
5742
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 4+1;
 
5743
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5744
 driver_send_term(port,caller,rt,AP);
 
5745
}; break;
 
5746
case 5723: { // glQueryCounter
 
5747
 GLuint *id = (GLuint *) bp; bp += 4;
 
5748
 GLenum *target = (GLenum *) bp; bp += 4;
 
5749
 weglQueryCounter(*id,*target);
 
5750
}; break;
 
5751
case 5724: { // glGetQueryObjecti64v
 
5752
 GLuint *id = (GLuint *) bp; bp += 4;
 
5753
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5754
 GLint64 params[1] = {0};
 
5755
 weglGetQueryObjecti64v(*id,*pname,params);
 
5756
 int AP = 0; ErlDrvTermData rt[6];
 
5757
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5758
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *params;
 
5759
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5760
 driver_send_term(port,caller,rt,AP);
 
5761
}; break;
 
5762
case 5725: { // glGetQueryObjectui64v
 
5763
 GLuint *id = (GLuint *) bp; bp += 4;
 
5764
 GLenum *pname = (GLenum *) bp; bp += 4;
 
5765
 GLuint64 params[1] = {0};
 
5766
 weglGetQueryObjectui64v(*id,*pname,params);
 
5767
 int AP = 0; ErlDrvTermData rt[6];
 
5768
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5769
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *params;
 
5770
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5771
 driver_send_term(port,caller,rt,AP);
 
5772
}; break;
 
5773
case 5726: { // glDrawArraysIndirect
 
5774
 GLenum *mode = (GLenum *) bp; bp += 4;
 
5775
 GLvoid *indirect = (GLvoid *) * (int *) bp; bp += 4;
 
5776
 weglDrawArraysIndirect(*mode,indirect);
 
5777
}; break;
 
5778
case 5727: { // glDrawArraysIndirect
 
5779
 GLenum *mode = (GLenum *) bp; bp += 4;
 
5780
 GLvoid *indirect = (GLvoid *) bins[0];
 
5781
 weglDrawArraysIndirect(*mode,indirect);
 
5782
}; break;
 
5783
case 5728: { // glDrawElementsIndirect
 
5784
 GLenum *mode = (GLenum *) bp; bp += 4;
 
5785
 GLenum *type = (GLenum *) bp; bp += 4;
 
5786
 GLvoid *indirect = (GLvoid *) * (int *) bp; bp += 4;
 
5787
 weglDrawElementsIndirect(*mode,*type,indirect);
 
5788
}; break;
 
5789
case 5729: { // glDrawElementsIndirect
 
5790
 GLenum *mode = (GLenum *) bp; bp += 4;
 
5791
 GLenum *type = (GLenum *) bp; bp += 4;
 
5792
 GLvoid *indirect = (GLvoid *) bins[0];
 
5793
 weglDrawElementsIndirect(*mode,*type,indirect);
 
5794
}; break;
 
5795
case 5730: { // glUniform1d
 
5796
 GLint *location = (GLint *) bp; bp += 4;
 
5797
 bp += 4;
 
5798
 GLdouble *x = (GLdouble *) bp; bp += 8;
 
5799
 weglUniform1d(*location,*x);
 
5800
}; break;
 
5801
case 5731: { // glUniform2d
 
5802
 GLint *location = (GLint *) bp; bp += 4;
 
5803
 bp += 4;
 
5804
 GLdouble *x = (GLdouble *) bp; bp += 8;
 
5805
 GLdouble *y = (GLdouble *) bp; bp += 8;
 
5806
 weglUniform2d(*location,*x,*y);
 
5807
}; break;
 
5808
case 5732: { // glUniform3d
 
5809
 GLint *location = (GLint *) bp; bp += 4;
 
5810
 bp += 4;
 
5811
 GLdouble *x = (GLdouble *) bp; bp += 8;
 
5812
 GLdouble *y = (GLdouble *) bp; bp += 8;
 
5813
 GLdouble *z = (GLdouble *) bp; bp += 8;
 
5814
 weglUniform3d(*location,*x,*y,*z);
 
5815
}; break;
 
5816
case 5733: { // glUniform4d
 
5817
 GLint *location = (GLint *) bp; bp += 4;
 
5818
 bp += 4;
 
5819
 GLdouble *x = (GLdouble *) bp; bp += 8;
 
5820
 GLdouble *y = (GLdouble *) bp; bp += 8;
 
5821
 GLdouble *z = (GLdouble *) bp; bp += 8;
 
5822
 GLdouble *w = (GLdouble *) bp; bp += 8;
 
5823
 weglUniform4d(*location,*x,*y,*z,*w);
 
5824
}; break;
 
5825
case 5734: { // glUniform1dv
 
5826
 GLint *location = (GLint *) bp; bp += 4;
 
5827
 bp += 4;
 
5828
 int * valueLen = (int *) bp; bp += 8;
 
5829
 GLdouble * value = (GLdouble *) bp;  bp += (8-((*valueLen*8+0)%8))%8;
 
5830
 weglUniform1dv(*location,*valueLen,value);
 
5831
}; break;
 
5832
case 5735: { // glUniform2dv
 
5833
 GLint *location = (GLint *) bp; bp += 4;
 
5834
 bp += 4;
 
5835
 int *valueLen = (int *) bp; bp += 8;
 
5836
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*16;
 
5837
 weglUniform2dv(*location,*valueLen,value);
 
5838
}; break;
 
5839
case 5736: { // glUniform3dv
 
5840
 GLint *location = (GLint *) bp; bp += 4;
 
5841
 bp += 4;
 
5842
 int *valueLen = (int *) bp; bp += 8;
 
5843
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*24;
 
5844
 weglUniform3dv(*location,*valueLen,value);
 
5845
}; break;
 
5846
case 5737: { // glUniform4dv
 
5847
 GLint *location = (GLint *) bp; bp += 4;
 
5848
 bp += 4;
 
5849
 int *valueLen = (int *) bp; bp += 8;
 
5850
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*32;
 
5851
 weglUniform4dv(*location,*valueLen,value);
 
5852
}; break;
 
5853
case 5738: { // glUniformMatrix2dv
 
5854
 GLint *location = (GLint *) bp; bp += 4;
 
5855
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
5856
 bp += 3;
 
5857
 int *valueLen = (int *) bp; bp += 8;
 
5858
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*32;
 
5859
 weglUniformMatrix2dv(*location,*valueLen,*transpose,value);
 
5860
}; break;
 
5861
case 5739: { // glUniformMatrix3dv
 
5862
 GLint *location = (GLint *) bp; bp += 4;
 
5863
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
5864
 bp += 3;
 
5865
 int *valueLen = (int *) bp; bp += 8;
 
5866
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*72;
 
5867
 weglUniformMatrix3dv(*location,*valueLen,*transpose,value);
 
5868
}; break;
 
5869
case 5740: { // glUniformMatrix4dv
 
5870
 GLint *location = (GLint *) bp; bp += 4;
 
5871
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
5872
 bp += 3;
 
5873
 int *valueLen = (int *) bp; bp += 8;
 
5874
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*128;
 
5875
 weglUniformMatrix4dv(*location,*valueLen,*transpose,value);
 
5876
}; break;
 
5877
case 5741: { // glUniformMatrix2x3dv
 
5878
 GLint *location = (GLint *) bp; bp += 4;
 
5879
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
5880
 bp += 3;
 
5881
 int *valueLen = (int *) bp; bp += 8;
 
5882
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*48;
 
5883
 weglUniformMatrix2x3dv(*location,*valueLen,*transpose,value);
 
5884
}; break;
 
5885
case 5742: { // glUniformMatrix2x4dv
 
5886
 GLint *location = (GLint *) bp; bp += 4;
 
5887
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
5888
 bp += 3;
 
5889
 int *valueLen = (int *) bp; bp += 8;
 
5890
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*64;
 
5891
 weglUniformMatrix2x4dv(*location,*valueLen,*transpose,value);
 
5892
}; break;
 
5893
case 5743: { // glUniformMatrix3x2dv
 
5894
 GLint *location = (GLint *) bp; bp += 4;
 
5895
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
5896
 bp += 3;
 
5897
 int *valueLen = (int *) bp; bp += 8;
 
5898
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*48;
 
5899
 weglUniformMatrix3x2dv(*location,*valueLen,*transpose,value);
 
5900
}; break;
 
5901
case 5744: { // glUniformMatrix3x4dv
 
5902
 GLint *location = (GLint *) bp; bp += 4;
 
5903
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
5904
 bp += 3;
 
5905
 int *valueLen = (int *) bp; bp += 8;
 
5906
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*96;
 
5907
 weglUniformMatrix3x4dv(*location,*valueLen,*transpose,value);
 
5908
}; break;
 
5909
case 5745: { // glUniformMatrix4x2dv
 
5910
 GLint *location = (GLint *) bp; bp += 4;
 
5911
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
5912
 bp += 3;
 
5913
 int *valueLen = (int *) bp; bp += 8;
 
5914
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*64;
 
5915
 weglUniformMatrix4x2dv(*location,*valueLen,*transpose,value);
 
5916
}; break;
 
5917
case 5746: { // glUniformMatrix4x3dv
 
5918
 GLint *location = (GLint *) bp; bp += 4;
 
5919
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
5920
 bp += 3;
 
5921
 int *valueLen = (int *) bp; bp += 8;
 
5922
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*96;
 
5923
 weglUniformMatrix4x3dv(*location,*valueLen,*transpose,value);
 
5924
}; break;
 
5925
case 5747: { // glGetUniformdv
 
5926
 GLuint *program = (GLuint *) bp; bp += 4;
 
5927
 GLint *location = (GLint *) bp; bp += 4;
 
5928
 GLdouble params[16] = {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
 
5929
 weglGetUniformdv(*program,*location,params);
 
5930
 int AP = 0; ErlDrvTermData rt[38];
 
5931
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5932
 GLdouble *paramsTmp = params;
 
5933
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5934
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5935
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5936
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5937
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5938
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5939
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5940
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5941
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5942
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5943
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5944
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5945
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5946
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5947
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5948
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
5949
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 16;
 
5950
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5951
 driver_send_term(port,caller,rt,AP);
 
5952
}; break;
 
5953
case 5748: { // glGetSubroutineUniformLocation
 
5954
 GLuint *program = (GLuint *) bp; bp += 4;
 
5955
 GLenum *shadertype = (GLenum *) bp; bp += 4;
 
5956
 GLchar *name = (GLchar *) bp;
 
5957
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+0)%8))%8);
 
5958
 GLint result = weglGetSubroutineUniformLocation(*program,*shadertype,name);
 
5959
 int AP = 0; ErlDrvTermData rt[6];
 
5960
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5961
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
 
5962
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5963
 driver_send_term(port,caller,rt,AP);
 
5964
}; break;
 
5965
case 5749: { // glGetSubroutineIndex
 
5966
 GLuint *program = (GLuint *) bp; bp += 4;
 
5967
 GLenum *shadertype = (GLenum *) bp; bp += 4;
 
5968
 GLchar *name = (GLchar *) bp;
 
5969
 int nameLen[1] = {strlen((char *)name)}; bp += nameLen[0]+1+((8-((1+nameLen[0]+0)%8))%8);
 
5970
 GLuint result = weglGetSubroutineIndex(*program,*shadertype,name);
 
5971
 int AP = 0; ErlDrvTermData rt[6];
 
5972
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5973
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
 
5974
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5975
 driver_send_term(port,caller,rt,AP);
 
5976
}; break;
 
5977
case 5750: { // glGetActiveSubroutineUniformName
 
5978
 GLuint *program = (GLuint *) bp; bp += 4;
 
5979
 GLenum *shadertype = (GLenum *) bp; bp += 4;
 
5980
 GLuint *index = (GLuint *) bp; bp += 4;
 
5981
 GLsizei *bufsize = (GLsizei *) bp; bp += 4;
 
5982
 GLsizei length[1] = {0};
 
5983
 GLchar *name;
 
5984
 name = (GLchar *) driver_alloc(sizeof(GLchar) * *bufsize);
 
5985
 weglGetActiveSubroutineUniformName(*program,*shadertype,*index,*bufsize,length,name);
 
5986
 int AP = 0; ErlDrvTermData rt[7];
 
5987
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
5988
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) name; rt[AP++] = *length;
 
5989
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
5990
 driver_send_term(port,caller,rt,AP);
 
5991
 driver_free(name);
 
5992
}; break;
 
5993
case 5751: { // glGetActiveSubroutineName
 
5994
 GLuint *program = (GLuint *) bp; bp += 4;
 
5995
 GLenum *shadertype = (GLenum *) bp; bp += 4;
 
5996
 GLuint *index = (GLuint *) bp; bp += 4;
 
5997
 GLsizei *bufsize = (GLsizei *) bp; bp += 4;
 
5998
 GLsizei length[1] = {0};
 
5999
 GLchar *name;
 
6000
 name = (GLchar *) driver_alloc(sizeof(GLchar) * *bufsize);
 
6001
 weglGetActiveSubroutineName(*program,*shadertype,*index,*bufsize,length,name);
 
6002
 int AP = 0; ErlDrvTermData rt[7];
 
6003
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6004
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) name; rt[AP++] = *length;
 
6005
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6006
 driver_send_term(port,caller,rt,AP);
 
6007
 driver_free(name);
 
6008
}; break;
 
6009
case 5752: { // glUniformSubroutinesuiv
 
6010
 GLenum *shadertype = (GLenum *) bp; bp += 4;
 
6011
 int * indicesLen = (int *) bp; bp += 4;
 
6012
 GLuint * indices = (GLuint *) bp;  bp += (8-((*indicesLen*4+0)%8))%8;
 
6013
 weglUniformSubroutinesuiv(*shadertype,*indicesLen,indices);
 
6014
}; break;
 
6015
case 5753: { // glGetUniformSubroutineuiv
 
6016
 GLenum *shadertype = (GLenum *) bp; bp += 4;
 
6017
 GLint *location = (GLint *) bp; bp += 4;
 
6018
 GLuint params[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 
6019
 weglGetUniformSubroutineuiv(*shadertype,*location,params);
 
6020
 int AP = 0; ErlDrvTermData rt[38];
 
6021
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6022
 GLuint *paramsTmp = params;
 
6023
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6024
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6025
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6026
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6027
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6028
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6029
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6030
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6031
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6032
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6033
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6034
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6035
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6036
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6037
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6038
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *paramsTmp++;
 
6039
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 16;
 
6040
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6041
 driver_send_term(port,caller,rt,AP);
 
6042
}; break;
 
6043
case 5754: { // glGetProgramStageiv
 
6044
 GLuint *program = (GLuint *) bp; bp += 4;
 
6045
 GLenum *shadertype = (GLenum *) bp; bp += 4;
 
6046
 GLenum *pname = (GLenum *) bp; bp += 4;
 
6047
 GLint values[1] = {0};
 
6048
 weglGetProgramStageiv(*program,*shadertype,*pname,values);
 
6049
 int AP = 0; ErlDrvTermData rt[6];
 
6050
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6051
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *values;
 
6052
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6053
 driver_send_term(port,caller,rt,AP);
 
6054
}; break;
 
6055
case 5755: { // glPatchParameteri
 
6056
 GLenum *pname = (GLenum *) bp; bp += 4;
 
6057
 GLint *value = (GLint *) bp; bp += 4;
 
6058
 weglPatchParameteri(*pname,*value);
 
6059
}; break;
 
6060
case 5756: { // glPatchParameterfv
 
6061
 GLenum *pname = (GLenum *) bp; bp += 4;
 
6062
 int * valuesLen = (int *) bp; bp += 4;
 
6063
 GLfloat * values = (GLfloat *) bp;  bp += (8-((*valuesLen*4+0)%8))%8;
 
6064
 weglPatchParameterfv(*pname,values);
 
6065
}; break;
 
6066
case 5757: { // glBindTransformFeedback
 
6067
 GLenum *target = (GLenum *) bp; bp += 4;
 
6068
 GLuint *id = (GLuint *) bp; bp += 4;
 
6069
 weglBindTransformFeedback(*target,*id);
 
6070
}; break;
 
6071
case 5758: { // glDeleteTransformFeedbacks
 
6072
 int * idsLen = (int *) bp; bp += 4;
 
6073
 GLuint * ids = (GLuint *) bp;  bp += (8-((*idsLen*4+4)%8))%8;
 
6074
 weglDeleteTransformFeedbacks(*idsLen,ids);
 
6075
}; break;
 
6076
case 5759: { // glGenTransformFeedbacks
 
6077
 GLsizei *n = (GLsizei *) bp; bp += 4;
 
6078
 GLuint *ids;
 
6079
 ids = (GLuint *) driver_alloc(sizeof(GLuint) * *n);
 
6080
 weglGenTransformFeedbacks(*n,ids);
 
6081
 int AP = 0; ErlDrvTermData *rt;
 
6082
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*n)*2));
 
6083
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6084
 for(int i=0; i < *n; i++) {
 
6085
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) ids[i];}
 
6086
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*n)+1;
 
6087
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6088
 driver_send_term(port,caller,rt,AP);
 
6089
 driver_free(rt);
 
6090
 driver_free(ids);
 
6091
}; break;
 
6092
case 5760: { // glIsTransformFeedback
 
6093
 GLuint *id = (GLuint *) bp; bp += 4;
 
6094
 GLboolean result = weglIsTransformFeedback(*id);
 
6095
 int AP = 0; ErlDrvTermData rt[6];
 
6096
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6097
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
 
6098
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6099
 driver_send_term(port,caller,rt,AP);
 
6100
}; break;
 
6101
case 5761: { // glPauseTransformFeedback
 
6102
 weglPauseTransformFeedback();
 
6103
}; break;
 
6104
case 5762: { // glResumeTransformFeedback
 
6105
 weglResumeTransformFeedback();
 
6106
}; break;
 
6107
case 5763: { // glDrawTransformFeedback
 
6108
 GLenum *mode = (GLenum *) bp; bp += 4;
 
6109
 GLuint *id = (GLuint *) bp; bp += 4;
 
6110
 weglDrawTransformFeedback(*mode,*id);
 
6111
}; break;
 
6112
case 5764: { // glDrawTransformFeedbackStream
 
6113
 GLenum *mode = (GLenum *) bp; bp += 4;
 
6114
 GLuint *id = (GLuint *) bp; bp += 4;
 
6115
 GLuint *stream = (GLuint *) bp; bp += 4;
 
6116
 weglDrawTransformFeedbackStream(*mode,*id,*stream);
 
6117
}; break;
 
6118
case 5765: { // glBeginQueryIndexed
 
6119
 GLenum *target = (GLenum *) bp; bp += 4;
 
6120
 GLuint *index = (GLuint *) bp; bp += 4;
 
6121
 GLuint *id = (GLuint *) bp; bp += 4;
 
6122
 weglBeginQueryIndexed(*target,*index,*id);
 
6123
}; break;
 
6124
case 5766: { // glEndQueryIndexed
 
6125
 GLenum *target = (GLenum *) bp; bp += 4;
 
6126
 GLuint *index = (GLuint *) bp; bp += 4;
 
6127
 weglEndQueryIndexed(*target,*index);
 
6128
}; break;
 
6129
case 5767: { // glGetQueryIndexediv
 
6130
 GLenum *target = (GLenum *) bp; bp += 4;
 
6131
 GLuint *index = (GLuint *) bp; bp += 4;
 
6132
 GLenum *pname = (GLenum *) bp; bp += 4;
 
6133
 GLint params[1] = {0};
 
6134
 weglGetQueryIndexediv(*target,*index,*pname,params);
 
6135
 int AP = 0; ErlDrvTermData rt[6];
 
6136
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6137
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *params;
 
6138
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6139
 driver_send_term(port,caller,rt,AP);
 
6140
}; break;
 
6141
case 5768: { // glReleaseShaderCompiler
 
6142
 weglReleaseShaderCompiler();
 
6143
}; break;
 
6144
case 5769: { // glShaderBinary
 
6145
 int * shadersLen = (int *) bp; bp += 4;
 
6146
 GLuint * shaders = (GLuint *) bp;  bp += (8-((*shadersLen*4+4)%8))%8;
 
6147
 GLenum *binaryformat = (GLenum *) bp; bp += 4;
 
6148
 GLvoid *binary = (GLvoid *) bins[0];
 
6149
 GLsizei binary_size = bins_sz[0];
 
6150
 weglShaderBinary(*shadersLen,shaders,*binaryformat,binary,binary_size);
 
6151
}; break;
 
6152
case 5770: { // glGetShaderPrecisionFormat
 
6153
 GLenum *shadertype = (GLenum *) bp; bp += 4;
 
6154
 GLenum *precisiontype = (GLenum *) bp; bp += 4;
 
6155
 GLint range[2] = {0,0};
 
6156
 GLint precision[1] = {0};
 
6157
 weglGetShaderPrecisionFormat(*shadertype,*precisiontype,range,precision);
 
6158
 int AP = 0; ErlDrvTermData rt[14];
 
6159
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6160
 GLint *rangeTmp = range;
 
6161
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *rangeTmp++;
 
6162
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *rangeTmp++;
 
6163
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6164
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *precision;
 
6165
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6166
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6167
 driver_send_term(port,caller,rt,AP);
 
6168
}; break;
 
6169
case 5771: { // glDepthRangef
 
6170
 GLclampf *n = (GLclampf *) bp; bp += 4;
 
6171
 GLclampf *f = (GLclampf *) bp; bp += 4;
 
6172
 weglDepthRangef(*n,*f);
 
6173
}; break;
 
6174
case 5772: { // glClearDepthf
 
6175
 GLclampf *d = (GLclampf *) bp; bp += 4;
 
6176
 weglClearDepthf(*d);
 
6177
}; break;
 
6178
case 5773: { // glGetProgramBinary
 
6179
 GLuint *program = (GLuint *) bp; bp += 4;
 
6180
 GLsizei *bufSize = (GLsizei *) bp; bp += 4;
 
6181
 GLsizei length[1] = {0};
 
6182
 GLenum binaryFormat[1] = {0};
 
6183
 ErlDrvBinary *binary = driver_alloc_binary(*bufSize);
 
6184
 weglGetProgramBinary(*program,*bufSize,length,binaryFormat,(GLvoid*) binary->orig_bytes);
 
6185
 int AP = 0; ErlDrvTermData rt[12];
 
6186
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6187
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *binaryFormat;
 
6188
 rt[AP++] = ERL_DRV_BINARY; rt[AP++] = (ErlDrvTermData) binary; rt[AP++] = *length; rt[AP++] = 0;
 
6189
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6190
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6191
 driver_send_term(port,caller,rt,AP);
 
6192
 driver_free_binary(binary);
 
6193
}; break;
 
6194
case 5774: { // glProgramBinary
 
6195
 GLuint *program = (GLuint *) bp; bp += 4;
 
6196
 GLenum *binaryFormat = (GLenum *) bp; bp += 4;
 
6197
 GLvoid *binary = (GLvoid *) bins[0];
 
6198
 GLsizei binary_size = bins_sz[0];
 
6199
 weglProgramBinary(*program,*binaryFormat,binary,binary_size);
 
6200
}; break;
 
6201
case 5775: { // glProgramParameteri
 
6202
 GLuint *program = (GLuint *) bp; bp += 4;
 
6203
 GLenum *pname = (GLenum *) bp; bp += 4;
 
6204
 GLint *value = (GLint *) bp; bp += 4;
 
6205
 weglProgramParameteri(*program,*pname,*value);
 
6206
}; break;
 
6207
case 5776: { // glUseProgramStages
 
6208
 GLuint *pipeline = (GLuint *) bp; bp += 4;
 
6209
 GLbitfield *stages = (GLbitfield *) bp; bp += 4;
 
6210
 GLuint *program = (GLuint *) bp; bp += 4;
 
6211
 weglUseProgramStages(*pipeline,*stages,*program);
 
6212
}; break;
 
6213
case 5777: { // glActiveShaderProgram
 
6214
 GLuint *pipeline = (GLuint *) bp; bp += 4;
 
6215
 GLuint *program = (GLuint *) bp; bp += 4;
 
6216
 weglActiveShaderProgram(*pipeline,*program);
 
6217
}; break;
 
6218
case 5778: { // glCreateShaderProgramv
 
6219
 GLenum *type = (GLenum *) bp; bp += 4;
 
6220
 int * stringsLen = (int *) bp; bp += 4;
 
6221
 int * stringsTotSize = (int *) bp; bp += 4;
 
6222
 GLchar **strings;
 
6223
 strings = (GLchar **) driver_alloc(sizeof(GLchar *) * *stringsLen);
 
6224
 for(int i=0;i<*stringsLen;i++) {
 
6225
    strings[i] = (GLchar *) bp; bp += 1+strlen(bp);};
 
6226
 bp += (8 - ((0 + *stringsTotSize) % 8)) % 8;
 
6227
 GLuint result = weglCreateShaderProgramv(*type,*stringsLen,(const GLchar **) strings);
 
6228
 int AP = 0; ErlDrvTermData rt[6];
 
6229
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6230
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
 
6231
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6232
 driver_send_term(port,caller,rt,AP);
 
6233
 driver_free(strings);
 
6234
}; break;
 
6235
case 5779: { // glBindProgramPipeline
 
6236
 GLuint *pipeline = (GLuint *) bp; bp += 4;
 
6237
 weglBindProgramPipeline(*pipeline);
 
6238
}; break;
 
6239
case 5780: { // glDeleteProgramPipelines
 
6240
 int * pipelinesLen = (int *) bp; bp += 4;
 
6241
 GLuint * pipelines = (GLuint *) bp;  bp += (8-((*pipelinesLen*4+4)%8))%8;
 
6242
 weglDeleteProgramPipelines(*pipelinesLen,pipelines);
 
6243
}; break;
 
6244
case 5781: { // glGenProgramPipelines
 
6245
 GLsizei *n = (GLsizei *) bp; bp += 4;
 
6246
 GLuint *pipelines;
 
6247
 pipelines = (GLuint *) driver_alloc(sizeof(GLuint) * *n);
 
6248
 weglGenProgramPipelines(*n,pipelines);
 
6249
 int AP = 0; ErlDrvTermData *rt;
 
6250
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(7 + (*n)*2));
 
6251
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6252
 for(int i=0; i < *n; i++) {
 
6253
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) pipelines[i];}
 
6254
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*n)+1;
 
6255
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6256
 driver_send_term(port,caller,rt,AP);
 
6257
 driver_free(rt);
 
6258
 driver_free(pipelines);
 
6259
}; break;
 
6260
case 5782: { // glIsProgramPipeline
 
6261
 GLuint *pipeline = (GLuint *) bp; bp += 4;
 
6262
 GLboolean result = weglIsProgramPipeline(*pipeline);
 
6263
 int AP = 0; ErlDrvTermData rt[6];
 
6264
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6265
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
 
6266
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6267
 driver_send_term(port,caller,rt,AP);
 
6268
}; break;
 
6269
case 5783: { // glGetProgramPipelineiv
 
6270
 GLuint *pipeline = (GLuint *) bp; bp += 4;
 
6271
 GLenum *pname = (GLenum *) bp; bp += 4;
 
6272
 GLint params[1] = {0};
 
6273
 weglGetProgramPipelineiv(*pipeline,*pname,params);
 
6274
 int AP = 0; ErlDrvTermData rt[6];
 
6275
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6276
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *params;
 
6277
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6278
 driver_send_term(port,caller,rt,AP);
 
6279
}; break;
 
6280
case 5784: { // glProgramUniform1i
 
6281
 GLuint *program = (GLuint *) bp; bp += 4;
 
6282
 GLint *location = (GLint *) bp; bp += 4;
 
6283
 GLint *v0 = (GLint *) bp; bp += 4;
 
6284
 weglProgramUniform1i(*program,*location,*v0);
 
6285
}; break;
 
6286
case 5785: { // glProgramUniform1iv
 
6287
 GLuint *program = (GLuint *) bp; bp += 4;
 
6288
 GLint *location = (GLint *) bp; bp += 4;
 
6289
 int * valueLen = (int *) bp; bp += 4;
 
6290
 GLint * value = (GLint *) bp;  bp += (8-((*valueLen*4+4)%8))%8;
 
6291
 weglProgramUniform1iv(*program,*location,*valueLen,value);
 
6292
}; break;
 
6293
case 5786: { // glProgramUniform1f
 
6294
 GLuint *program = (GLuint *) bp; bp += 4;
 
6295
 GLint *location = (GLint *) bp; bp += 4;
 
6296
 GLfloat *v0 = (GLfloat *) bp; bp += 4;
 
6297
 weglProgramUniform1f(*program,*location,*v0);
 
6298
}; break;
 
6299
case 5787: { // glProgramUniform1fv
 
6300
 GLuint *program = (GLuint *) bp; bp += 4;
 
6301
 GLint *location = (GLint *) bp; bp += 4;
 
6302
 int * valueLen = (int *) bp; bp += 4;
 
6303
 GLfloat * value = (GLfloat *) bp;  bp += (8-((*valueLen*4+4)%8))%8;
 
6304
 weglProgramUniform1fv(*program,*location,*valueLen,value);
 
6305
}; break;
 
6306
case 5788: { // glProgramUniform1d
 
6307
 GLuint *program = (GLuint *) bp; bp += 4;
 
6308
 GLint *location = (GLint *) bp; bp += 4;
 
6309
 GLdouble *v0 = (GLdouble *) bp; bp += 8;
 
6310
 weglProgramUniform1d(*program,*location,*v0);
 
6311
}; break;
 
6312
case 5789: { // glProgramUniform1dv
 
6313
 GLuint *program = (GLuint *) bp; bp += 4;
 
6314
 GLint *location = (GLint *) bp; bp += 4;
 
6315
 int * valueLen = (int *) bp; bp += 8;
 
6316
 GLdouble * value = (GLdouble *) bp;  bp += (8-((*valueLen*8+0)%8))%8;
 
6317
 weglProgramUniform1dv(*program,*location,*valueLen,value);
 
6318
}; break;
 
6319
case 5790: { // glProgramUniform1ui
 
6320
 GLuint *program = (GLuint *) bp; bp += 4;
 
6321
 GLint *location = (GLint *) bp; bp += 4;
 
6322
 GLuint *v0 = (GLuint *) bp; bp += 4;
 
6323
 weglProgramUniform1ui(*program,*location,*v0);
 
6324
}; break;
 
6325
case 5791: { // glProgramUniform1uiv
 
6326
 GLuint *program = (GLuint *) bp; bp += 4;
 
6327
 GLint *location = (GLint *) bp; bp += 4;
 
6328
 int * valueLen = (int *) bp; bp += 4;
 
6329
 GLuint * value = (GLuint *) bp;  bp += (8-((*valueLen*4+4)%8))%8;
 
6330
 weglProgramUniform1uiv(*program,*location,*valueLen,value);
 
6331
}; break;
 
6332
case 5792: { // glProgramUniform2i
 
6333
 GLuint *program = (GLuint *) bp; bp += 4;
 
6334
 GLint *location = (GLint *) bp; bp += 4;
 
6335
 GLint *v0 = (GLint *) bp; bp += 4;
 
6336
 GLint *v1 = (GLint *) bp; bp += 4;
 
6337
 weglProgramUniform2i(*program,*location,*v0,*v1);
 
6338
}; break;
 
6339
case 5793: { // glProgramUniform2iv
 
6340
 GLuint *program = (GLuint *) bp; bp += 4;
 
6341
 GLint *location = (GLint *) bp; bp += 4;
 
6342
 int *valueLen = (int *) bp; bp += 4;
 
6343
 GLint * value = (GLint *) bp; bp += *valueLen*8;
 
6344
 weglProgramUniform2iv(*program,*location,*valueLen,value);
 
6345
}; break;
 
6346
case 5794: { // glProgramUniform2f
 
6347
 GLuint *program = (GLuint *) bp; bp += 4;
 
6348
 GLint *location = (GLint *) bp; bp += 4;
 
6349
 GLfloat *v0 = (GLfloat *) bp; bp += 4;
 
6350
 GLfloat *v1 = (GLfloat *) bp; bp += 4;
 
6351
 weglProgramUniform2f(*program,*location,*v0,*v1);
 
6352
}; break;
 
6353
case 5795: { // glProgramUniform2fv
 
6354
 GLuint *program = (GLuint *) bp; bp += 4;
 
6355
 GLint *location = (GLint *) bp; bp += 4;
 
6356
 int *valueLen = (int *) bp; bp += 4;
 
6357
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*8;
 
6358
 weglProgramUniform2fv(*program,*location,*valueLen,value);
 
6359
}; break;
 
6360
case 5796: { // glProgramUniform2d
 
6361
 GLuint *program = (GLuint *) bp; bp += 4;
 
6362
 GLint *location = (GLint *) bp; bp += 4;
 
6363
 GLdouble *v0 = (GLdouble *) bp; bp += 8;
 
6364
 GLdouble *v1 = (GLdouble *) bp; bp += 8;
 
6365
 weglProgramUniform2d(*program,*location,*v0,*v1);
 
6366
}; break;
 
6367
case 5797: { // glProgramUniform2dv
 
6368
 GLuint *program = (GLuint *) bp; bp += 4;
 
6369
 GLint *location = (GLint *) bp; bp += 4;
 
6370
 int *valueLen = (int *) bp; bp += 8;
 
6371
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*16;
 
6372
 weglProgramUniform2dv(*program,*location,*valueLen,value);
 
6373
}; break;
 
6374
case 5798: { // glProgramUniform2ui
 
6375
 GLuint *program = (GLuint *) bp; bp += 4;
 
6376
 GLint *location = (GLint *) bp; bp += 4;
 
6377
 GLuint *v0 = (GLuint *) bp; bp += 4;
 
6378
 GLuint *v1 = (GLuint *) bp; bp += 4;
 
6379
 weglProgramUniform2ui(*program,*location,*v0,*v1);
 
6380
}; break;
 
6381
case 5799: { // glProgramUniform2uiv
 
6382
 GLuint *program = (GLuint *) bp; bp += 4;
 
6383
 GLint *location = (GLint *) bp; bp += 4;
 
6384
 int *valueLen = (int *) bp; bp += 4;
 
6385
 GLuint * value = (GLuint *) bp; bp += *valueLen*8;
 
6386
 weglProgramUniform2uiv(*program,*location,*valueLen,value);
 
6387
}; break;
 
6388
case 5800: { // glProgramUniform3i
 
6389
 GLuint *program = (GLuint *) bp; bp += 4;
 
6390
 GLint *location = (GLint *) bp; bp += 4;
 
6391
 GLint *v0 = (GLint *) bp; bp += 4;
 
6392
 GLint *v1 = (GLint *) bp; bp += 4;
 
6393
 GLint *v2 = (GLint *) bp; bp += 4;
 
6394
 weglProgramUniform3i(*program,*location,*v0,*v1,*v2);
 
6395
}; break;
 
6396
case 5801: { // glProgramUniform3iv
 
6397
 GLuint *program = (GLuint *) bp; bp += 4;
 
6398
 GLint *location = (GLint *) bp; bp += 4;
 
6399
 int *valueLen = (int *) bp; bp += 4;
 
6400
 GLint * value = (GLint *) bp; bp += *valueLen*12;
 
6401
 weglProgramUniform3iv(*program,*location,*valueLen,value);
 
6402
}; break;
 
6403
case 5802: { // glProgramUniform3f
 
6404
 GLuint *program = (GLuint *) bp; bp += 4;
 
6405
 GLint *location = (GLint *) bp; bp += 4;
 
6406
 GLfloat *v0 = (GLfloat *) bp; bp += 4;
 
6407
 GLfloat *v1 = (GLfloat *) bp; bp += 4;
 
6408
 GLfloat *v2 = (GLfloat *) bp; bp += 4;
 
6409
 weglProgramUniform3f(*program,*location,*v0,*v1,*v2);
 
6410
}; break;
 
6411
case 5803: { // glProgramUniform3fv
 
6412
 GLuint *program = (GLuint *) bp; bp += 4;
 
6413
 GLint *location = (GLint *) bp; bp += 4;
 
6414
 int *valueLen = (int *) bp; bp += 4;
 
6415
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*12;
 
6416
 weglProgramUniform3fv(*program,*location,*valueLen,value);
 
6417
}; break;
 
6418
case 5804: { // glProgramUniform3d
 
6419
 GLuint *program = (GLuint *) bp; bp += 4;
 
6420
 GLint *location = (GLint *) bp; bp += 4;
 
6421
 GLdouble *v0 = (GLdouble *) bp; bp += 8;
 
6422
 GLdouble *v1 = (GLdouble *) bp; bp += 8;
 
6423
 GLdouble *v2 = (GLdouble *) bp; bp += 8;
 
6424
 weglProgramUniform3d(*program,*location,*v0,*v1,*v2);
 
6425
}; break;
 
6426
case 5805: { // glProgramUniform3dv
 
6427
 GLuint *program = (GLuint *) bp; bp += 4;
 
6428
 GLint *location = (GLint *) bp; bp += 4;
 
6429
 int *valueLen = (int *) bp; bp += 8;
 
6430
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*24;
 
6431
 weglProgramUniform3dv(*program,*location,*valueLen,value);
 
6432
}; break;
 
6433
case 5806: { // glProgramUniform3ui
 
6434
 GLuint *program = (GLuint *) bp; bp += 4;
 
6435
 GLint *location = (GLint *) bp; bp += 4;
 
6436
 GLuint *v0 = (GLuint *) bp; bp += 4;
 
6437
 GLuint *v1 = (GLuint *) bp; bp += 4;
 
6438
 GLuint *v2 = (GLuint *) bp; bp += 4;
 
6439
 weglProgramUniform3ui(*program,*location,*v0,*v1,*v2);
 
6440
}; break;
 
6441
case 5807: { // glProgramUniform3uiv
 
6442
 GLuint *program = (GLuint *) bp; bp += 4;
 
6443
 GLint *location = (GLint *) bp; bp += 4;
 
6444
 int *valueLen = (int *) bp; bp += 4;
 
6445
 GLuint * value = (GLuint *) bp; bp += *valueLen*12;
 
6446
 weglProgramUniform3uiv(*program,*location,*valueLen,value);
 
6447
}; break;
 
6448
case 5808: { // glProgramUniform4i
 
6449
 GLuint *program = (GLuint *) bp; bp += 4;
 
6450
 GLint *location = (GLint *) bp; bp += 4;
 
6451
 GLint *v0 = (GLint *) bp; bp += 4;
 
6452
 GLint *v1 = (GLint *) bp; bp += 4;
 
6453
 GLint *v2 = (GLint *) bp; bp += 4;
 
6454
 GLint *v3 = (GLint *) bp; bp += 4;
 
6455
 weglProgramUniform4i(*program,*location,*v0,*v1,*v2,*v3);
 
6456
}; break;
 
6457
case 5809: { // glProgramUniform4iv
 
6458
 GLuint *program = (GLuint *) bp; bp += 4;
 
6459
 GLint *location = (GLint *) bp; bp += 4;
 
6460
 int *valueLen = (int *) bp; bp += 4;
 
6461
 GLint * value = (GLint *) bp; bp += *valueLen*16;
 
6462
 weglProgramUniform4iv(*program,*location,*valueLen,value);
 
6463
}; break;
 
6464
case 5810: { // glProgramUniform4f
 
6465
 GLuint *program = (GLuint *) bp; bp += 4;
 
6466
 GLint *location = (GLint *) bp; bp += 4;
 
6467
 GLfloat *v0 = (GLfloat *) bp; bp += 4;
 
6468
 GLfloat *v1 = (GLfloat *) bp; bp += 4;
 
6469
 GLfloat *v2 = (GLfloat *) bp; bp += 4;
 
6470
 GLfloat *v3 = (GLfloat *) bp; bp += 4;
 
6471
 weglProgramUniform4f(*program,*location,*v0,*v1,*v2,*v3);
 
6472
}; break;
 
6473
case 5811: { // glProgramUniform4fv
 
6474
 GLuint *program = (GLuint *) bp; bp += 4;
 
6475
 GLint *location = (GLint *) bp; bp += 4;
 
6476
 int *valueLen = (int *) bp; bp += 4;
 
6477
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*16;
 
6478
 weglProgramUniform4fv(*program,*location,*valueLen,value);
 
6479
}; break;
 
6480
case 5812: { // glProgramUniform4d
 
6481
 GLuint *program = (GLuint *) bp; bp += 4;
 
6482
 GLint *location = (GLint *) bp; bp += 4;
 
6483
 GLdouble *v0 = (GLdouble *) bp; bp += 8;
 
6484
 GLdouble *v1 = (GLdouble *) bp; bp += 8;
 
6485
 GLdouble *v2 = (GLdouble *) bp; bp += 8;
 
6486
 GLdouble *v3 = (GLdouble *) bp; bp += 8;
 
6487
 weglProgramUniform4d(*program,*location,*v0,*v1,*v2,*v3);
 
6488
}; break;
 
6489
case 5813: { // glProgramUniform4dv
 
6490
 GLuint *program = (GLuint *) bp; bp += 4;
 
6491
 GLint *location = (GLint *) bp; bp += 4;
 
6492
 int *valueLen = (int *) bp; bp += 8;
 
6493
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*32;
 
6494
 weglProgramUniform4dv(*program,*location,*valueLen,value);
 
6495
}; break;
 
6496
case 5814: { // glProgramUniform4ui
 
6497
 GLuint *program = (GLuint *) bp; bp += 4;
 
6498
 GLint *location = (GLint *) bp; bp += 4;
 
6499
 GLuint *v0 = (GLuint *) bp; bp += 4;
 
6500
 GLuint *v1 = (GLuint *) bp; bp += 4;
 
6501
 GLuint *v2 = (GLuint *) bp; bp += 4;
 
6502
 GLuint *v3 = (GLuint *) bp; bp += 4;
 
6503
 weglProgramUniform4ui(*program,*location,*v0,*v1,*v2,*v3);
 
6504
}; break;
 
6505
case 5815: { // glProgramUniform4uiv
 
6506
 GLuint *program = (GLuint *) bp; bp += 4;
 
6507
 GLint *location = (GLint *) bp; bp += 4;
 
6508
 int *valueLen = (int *) bp; bp += 4;
 
6509
 GLuint * value = (GLuint *) bp; bp += *valueLen*16;
 
6510
 weglProgramUniform4uiv(*program,*location,*valueLen,value);
 
6511
}; break;
 
6512
case 5816: { // glProgramUniformMatrix2fv
 
6513
 GLuint *program = (GLuint *) bp; bp += 4;
 
6514
 GLint *location = (GLint *) bp; bp += 4;
 
6515
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6516
 bp += 3;
 
6517
 int *valueLen = (int *) bp; bp += 4;
 
6518
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*16;
 
6519
 weglProgramUniformMatrix2fv(*program,*location,*valueLen,*transpose,value);
 
6520
}; break;
 
6521
case 5817: { // glProgramUniformMatrix3fv
 
6522
 GLuint *program = (GLuint *) bp; bp += 4;
 
6523
 GLint *location = (GLint *) bp; bp += 4;
 
6524
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6525
 bp += 3;
 
6526
 int *valueLen = (int *) bp; bp += 4;
 
6527
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*36;
 
6528
 weglProgramUniformMatrix3fv(*program,*location,*valueLen,*transpose,value);
 
6529
}; break;
 
6530
case 5818: { // glProgramUniformMatrix4fv
 
6531
 GLuint *program = (GLuint *) bp; bp += 4;
 
6532
 GLint *location = (GLint *) bp; bp += 4;
 
6533
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6534
 bp += 3;
 
6535
 int *valueLen = (int *) bp; bp += 4;
 
6536
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*64;
 
6537
 weglProgramUniformMatrix4fv(*program,*location,*valueLen,*transpose,value);
 
6538
}; break;
 
6539
case 5819: { // glProgramUniformMatrix2dv
 
6540
 GLuint *program = (GLuint *) bp; bp += 4;
 
6541
 GLint *location = (GLint *) bp; bp += 4;
 
6542
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6543
 bp += 7;
 
6544
 int *valueLen = (int *) bp; bp += 8;
 
6545
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*32;
 
6546
 weglProgramUniformMatrix2dv(*program,*location,*valueLen,*transpose,value);
 
6547
}; break;
 
6548
case 5820: { // glProgramUniformMatrix3dv
 
6549
 GLuint *program = (GLuint *) bp; bp += 4;
 
6550
 GLint *location = (GLint *) bp; bp += 4;
 
6551
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6552
 bp += 7;
 
6553
 int *valueLen = (int *) bp; bp += 8;
 
6554
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*72;
 
6555
 weglProgramUniformMatrix3dv(*program,*location,*valueLen,*transpose,value);
 
6556
}; break;
 
6557
case 5821: { // glProgramUniformMatrix4dv
 
6558
 GLuint *program = (GLuint *) bp; bp += 4;
 
6559
 GLint *location = (GLint *) bp; bp += 4;
 
6560
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6561
 bp += 7;
 
6562
 int *valueLen = (int *) bp; bp += 8;
 
6563
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*128;
 
6564
 weglProgramUniformMatrix4dv(*program,*location,*valueLen,*transpose,value);
 
6565
}; break;
 
6566
case 5822: { // glProgramUniformMatrix2x3fv
 
6567
 GLuint *program = (GLuint *) bp; bp += 4;
 
6568
 GLint *location = (GLint *) bp; bp += 4;
 
6569
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6570
 bp += 3;
 
6571
 int *valueLen = (int *) bp; bp += 4;
 
6572
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*24;
 
6573
 weglProgramUniformMatrix2x3fv(*program,*location,*valueLen,*transpose,value);
 
6574
}; break;
 
6575
case 5823: { // glProgramUniformMatrix3x2fv
 
6576
 GLuint *program = (GLuint *) bp; bp += 4;
 
6577
 GLint *location = (GLint *) bp; bp += 4;
 
6578
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6579
 bp += 3;
 
6580
 int *valueLen = (int *) bp; bp += 4;
 
6581
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*24;
 
6582
 weglProgramUniformMatrix3x2fv(*program,*location,*valueLen,*transpose,value);
 
6583
}; break;
 
6584
case 5824: { // glProgramUniformMatrix2x4fv
 
6585
 GLuint *program = (GLuint *) bp; bp += 4;
 
6586
 GLint *location = (GLint *) bp; bp += 4;
 
6587
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6588
 bp += 3;
 
6589
 int *valueLen = (int *) bp; bp += 4;
 
6590
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*32;
 
6591
 weglProgramUniformMatrix2x4fv(*program,*location,*valueLen,*transpose,value);
 
6592
}; break;
 
6593
case 5825: { // glProgramUniformMatrix4x2fv
 
6594
 GLuint *program = (GLuint *) bp; bp += 4;
 
6595
 GLint *location = (GLint *) bp; bp += 4;
 
6596
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6597
 bp += 3;
 
6598
 int *valueLen = (int *) bp; bp += 4;
 
6599
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*32;
 
6600
 weglProgramUniformMatrix4x2fv(*program,*location,*valueLen,*transpose,value);
 
6601
}; break;
 
6602
case 5826: { // glProgramUniformMatrix3x4fv
 
6603
 GLuint *program = (GLuint *) bp; bp += 4;
 
6604
 GLint *location = (GLint *) bp; bp += 4;
 
6605
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6606
 bp += 3;
 
6607
 int *valueLen = (int *) bp; bp += 4;
 
6608
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*48;
 
6609
 weglProgramUniformMatrix3x4fv(*program,*location,*valueLen,*transpose,value);
 
6610
}; break;
 
6611
case 5827: { // glProgramUniformMatrix4x3fv
 
6612
 GLuint *program = (GLuint *) bp; bp += 4;
 
6613
 GLint *location = (GLint *) bp; bp += 4;
 
6614
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6615
 bp += 3;
 
6616
 int *valueLen = (int *) bp; bp += 4;
 
6617
 GLfloat * value = (GLfloat *) bp; bp += *valueLen*48;
 
6618
 weglProgramUniformMatrix4x3fv(*program,*location,*valueLen,*transpose,value);
 
6619
}; break;
 
6620
case 5828: { // glProgramUniformMatrix2x3dv
 
6621
 GLuint *program = (GLuint *) bp; bp += 4;
 
6622
 GLint *location = (GLint *) bp; bp += 4;
 
6623
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6624
 bp += 7;
 
6625
 int *valueLen = (int *) bp; bp += 8;
 
6626
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*48;
 
6627
 weglProgramUniformMatrix2x3dv(*program,*location,*valueLen,*transpose,value);
 
6628
}; break;
 
6629
case 5829: { // glProgramUniformMatrix3x2dv
 
6630
 GLuint *program = (GLuint *) bp; bp += 4;
 
6631
 GLint *location = (GLint *) bp; bp += 4;
 
6632
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6633
 bp += 7;
 
6634
 int *valueLen = (int *) bp; bp += 8;
 
6635
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*48;
 
6636
 weglProgramUniformMatrix3x2dv(*program,*location,*valueLen,*transpose,value);
 
6637
}; break;
 
6638
case 5830: { // glProgramUniformMatrix2x4dv
 
6639
 GLuint *program = (GLuint *) bp; bp += 4;
 
6640
 GLint *location = (GLint *) bp; bp += 4;
 
6641
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6642
 bp += 7;
 
6643
 int *valueLen = (int *) bp; bp += 8;
 
6644
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*64;
 
6645
 weglProgramUniformMatrix2x4dv(*program,*location,*valueLen,*transpose,value);
 
6646
}; break;
 
6647
case 5831: { // glProgramUniformMatrix4x2dv
 
6648
 GLuint *program = (GLuint *) bp; bp += 4;
 
6649
 GLint *location = (GLint *) bp; bp += 4;
 
6650
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6651
 bp += 7;
 
6652
 int *valueLen = (int *) bp; bp += 8;
 
6653
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*64;
 
6654
 weglProgramUniformMatrix4x2dv(*program,*location,*valueLen,*transpose,value);
 
6655
}; break;
 
6656
case 5832: { // glProgramUniformMatrix3x4dv
 
6657
 GLuint *program = (GLuint *) bp; bp += 4;
 
6658
 GLint *location = (GLint *) bp; bp += 4;
 
6659
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6660
 bp += 7;
 
6661
 int *valueLen = (int *) bp; bp += 8;
 
6662
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*96;
 
6663
 weglProgramUniformMatrix3x4dv(*program,*location,*valueLen,*transpose,value);
 
6664
}; break;
 
6665
case 5833: { // glProgramUniformMatrix4x3dv
 
6666
 GLuint *program = (GLuint *) bp; bp += 4;
 
6667
 GLint *location = (GLint *) bp; bp += 4;
 
6668
 GLboolean *transpose = (GLboolean *) bp; bp += 1;
 
6669
 bp += 7;
 
6670
 int *valueLen = (int *) bp; bp += 8;
 
6671
 GLdouble * value = (GLdouble *) bp; bp += *valueLen*96;
 
6672
 weglProgramUniformMatrix4x3dv(*program,*location,*valueLen,*transpose,value);
 
6673
}; break;
 
6674
case 5834: { // glValidateProgramPipeline
 
6675
 GLuint *pipeline = (GLuint *) bp; bp += 4;
 
6676
 weglValidateProgramPipeline(*pipeline);
 
6677
}; break;
 
6678
case 5835: { // glGetProgramPipelineInfoLog
 
6679
 GLuint *pipeline = (GLuint *) bp; bp += 4;
 
6680
 GLsizei *bufSize = (GLsizei *) bp; bp += 4;
 
6681
 GLsizei length[1] = {0};
 
6682
 GLchar *infoLog;
 
6683
 infoLog = (GLchar *) driver_alloc(sizeof(GLchar) * *bufSize);
 
6684
 weglGetProgramPipelineInfoLog(*pipeline,*bufSize,length,infoLog);
 
6685
 int AP = 0; ErlDrvTermData rt[7];
 
6686
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6687
 rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) infoLog; rt[AP++] = *length;
 
6688
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6689
 driver_send_term(port,caller,rt,AP);
 
6690
 driver_free(infoLog);
 
6691
}; break;
 
6692
case 5836: { // glVertexAttribL1dv
 
6693
 GLuint *index = (GLuint *) bp; bp += 4;
 
6694
 bp += 4;
 
6695
 GLdouble *v = (GLdouble *) bp; bp += 8;
 
6696
 weglVertexAttribL1dv(*index,v);
 
6697
}; break;
 
6698
case 5837: { // glVertexAttribL2dv
 
6699
 GLuint *index = (GLuint *) bp; bp += 4;
 
6700
 bp += 4;
 
6701
 GLdouble *v = (GLdouble *) bp; bp += 8;
 
6702
 weglVertexAttribL2dv(*index,v);
 
6703
}; break;
 
6704
case 5838: { // glVertexAttribL3dv
 
6705
 GLuint *index = (GLuint *) bp; bp += 4;
 
6706
 bp += 4;
 
6707
 GLdouble *v = (GLdouble *) bp; bp += 8;
 
6708
 weglVertexAttribL3dv(*index,v);
 
6709
}; break;
 
6710
case 5839: { // glVertexAttribL4dv
 
6711
 GLuint *index = (GLuint *) bp; bp += 4;
 
6712
 bp += 4;
 
6713
 GLdouble *v = (GLdouble *) bp; bp += 8;
 
6714
 weglVertexAttribL4dv(*index,v);
 
6715
}; break;
 
6716
case 5840: { // glVertexAttribLPointer
 
6717
 GLuint *index = (GLuint *) bp; bp += 4;
 
6718
 GLint *size = (GLint *) bp; bp += 4;
 
6719
 GLenum *type = (GLenum *) bp; bp += 4;
 
6720
 GLsizei *stride = (GLsizei *) bp; bp += 4;
 
6721
 GLvoid *pointer = (GLvoid *) * (int *) bp; bp += 4;
 
6722
 weglVertexAttribLPointer(*index,*size,*type,*stride,pointer);
 
6723
}; break;
 
6724
case 5841: { // glVertexAttribLPointer
 
6725
 GLuint *index = (GLuint *) bp; bp += 4;
 
6726
 GLint *size = (GLint *) bp; bp += 4;
 
6727
 GLenum *type = (GLenum *) bp; bp += 4;
 
6728
 GLsizei *stride = (GLsizei *) bp; bp += 4;
 
6729
 GLvoid *pointer = (GLvoid *) bins[0];
 
6730
 weglVertexAttribLPointer(*index,*size,*type,*stride,pointer);
 
6731
}; break;
 
6732
case 5842: { // glGetVertexAttribLdv
 
6733
 GLuint *index = (GLuint *) bp; bp += 4;
 
6734
 GLenum *pname = (GLenum *) bp; bp += 4;
 
6735
 GLdouble params[4] = {0.0,0.0,0.0,0.0};
 
6736
 weglGetVertexAttribLdv(*index,*pname,params);
 
6737
 int AP = 0; ErlDrvTermData rt[14];
 
6738
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6739
 GLdouble *paramsTmp = params;
 
6740
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
6741
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
6742
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
6743
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) paramsTmp++;
 
6744
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 4;
 
6745
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6746
 driver_send_term(port,caller,rt,AP);
 
6747
}; break;
 
6748
case 5843: { // glViewportArrayv
 
6749
 GLuint *first = (GLuint *) bp; bp += 4;
 
6750
 int *vLen = (int *) bp; bp += 4;
 
6751
 GLfloat * v = (GLfloat *) bp; bp += *vLen*16;
 
6752
 weglViewportArrayv(*first,*vLen,v);
 
6753
}; break;
 
6754
case 5844: { // glViewportIndexedf
 
6755
 GLuint *index = (GLuint *) bp; bp += 4;
 
6756
 GLfloat *x = (GLfloat *) bp; bp += 4;
 
6757
 GLfloat *y = (GLfloat *) bp; bp += 4;
 
6758
 GLfloat *w = (GLfloat *) bp; bp += 4;
 
6759
 GLfloat *h = (GLfloat *) bp; bp += 4;
 
6760
 weglViewportIndexedf(*index,*x,*y,*w,*h);
 
6761
}; break;
 
6762
case 5845: { // glViewportIndexedfv
 
6763
 GLuint *index = (GLuint *) bp; bp += 4;
 
6764
 GLfloat * v = (GLfloat *) bp; bp += 16;
 
6765
 weglViewportIndexedfv(*index,v);
 
6766
}; break;
 
6767
case 5846: { // glScissorArrayv
 
6768
 GLuint *first = (GLuint *) bp; bp += 4;
 
6769
 int *vLen = (int *) bp; bp += 4;
 
6770
 GLint * v = (GLint *) bp; bp += *vLen*16;
 
6771
 weglScissorArrayv(*first,*vLen,v);
 
6772
}; break;
 
6773
case 5847: { // glScissorIndexed
 
6774
 GLuint *index = (GLuint *) bp; bp += 4;
 
6775
 GLint *left = (GLint *) bp; bp += 4;
 
6776
 GLint *bottom = (GLint *) bp; bp += 4;
 
6777
 GLsizei *width = (GLsizei *) bp; bp += 4;
 
6778
 GLsizei *height = (GLsizei *) bp; bp += 4;
 
6779
 weglScissorIndexed(*index,*left,*bottom,*width,*height);
 
6780
}; break;
 
6781
case 5848: { // glScissorIndexedv
 
6782
 GLuint *index = (GLuint *) bp; bp += 4;
 
6783
 GLint * v = (GLint *) bp; bp += 16;
 
6784
 weglScissorIndexedv(*index,v);
 
6785
}; break;
 
6786
case 5849: { // glDepthRangeArrayv
 
6787
 GLuint *first = (GLuint *) bp; bp += 4;
 
6788
 bp += 4;
 
6789
 int *vLen = (int *) bp; bp += 8;
 
6790
 GLclampd * v = (GLclampd *) bp; bp += *vLen*16;
 
6791
 weglDepthRangeArrayv(*first,*vLen,v);
 
6792
}; break;
 
6793
case 5850: { // glDepthRangeIndexed
 
6794
 GLuint *index = (GLuint *) bp; bp += 4;
 
6795
 bp += 4;
 
6796
 GLclampd *n = (GLclampd *) bp; bp += 8;
 
6797
 GLclampd *f = (GLclampd *) bp; bp += 8;
 
6798
 weglDepthRangeIndexed(*index,*n,*f);
 
6799
}; break;
 
6800
case 5851: { // glGetFloati_v
 
6801
 GLenum *target = (GLenum *) bp; bp += 4;
 
6802
 GLuint *index = (GLuint *) bp; bp += 4;
 
6803
 GLfloat data[16] = {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
 
6804
 weglGetFloati_v(*target,*index,data);
 
6805
 int AP = 0; ErlDrvTermData rt[39];
 
6806
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6807
 GLdouble dataConv[16], *dataTmp = dataConv; 
 
6808
 for(int i=0; i < 16; i++) dataConv[i] = (GLdouble) data[i];
 
6809
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6810
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6811
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6812
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6813
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6814
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6815
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6816
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6817
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6818
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6819
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6820
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6821
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6822
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6823
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6824
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6825
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 16+1;
 
6826
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6827
 driver_send_term(port,caller,rt,AP);
 
6828
}; break;
 
6829
case 5852: { // glGetDoublei_v
 
6830
 GLenum *target = (GLenum *) bp; bp += 4;
 
6831
 GLuint *index = (GLuint *) bp; bp += 4;
 
6832
 GLdouble data[16] = {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
 
6833
 weglGetDoublei_v(*target,*index,data);
 
6834
 int AP = 0; ErlDrvTermData rt[39];
 
6835
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6836
 GLdouble *dataTmp = data;
 
6837
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6838
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6839
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6840
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6841
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6842
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6843
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6844
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6845
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6846
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6847
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6848
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6849
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6850
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6851
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6852
 rt[AP++] = ERL_DRV_FLOAT; rt[AP++] = (ErlDrvTermData) dataTmp++;
 
6853
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = 16+1;
 
6854
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6855
 driver_send_term(port,caller,rt,AP);
 
6856
}; break;
 
6857
case 5853: { // glDebugMessageControlARB
 
6858
 GLenum *source = (GLenum *) bp; bp += 4;
 
6859
 GLenum *type = (GLenum *) bp; bp += 4;
 
6860
 GLenum *severity = (GLenum *) bp; bp += 4;
 
6861
 int * idsLen = (int *) bp; bp += 4;
 
6862
 GLuint * ids = (GLuint *) bp;  bp += (8-((*idsLen*4+0)%8))%8;
 
6863
 GLboolean *enabled = (GLboolean *) bp; bp += 1;
 
6864
 weglDebugMessageControlARB(*source,*type,*severity,*idsLen,ids,*enabled);
 
6865
}; break;
 
6866
case 5854: { // glDebugMessageInsertARB
 
6867
 GLenum *source = (GLenum *) bp; bp += 4;
 
6868
 GLenum *type = (GLenum *) bp; bp += 4;
 
6869
 GLuint *id = (GLuint *) bp; bp += 4;
 
6870
 GLenum *severity = (GLenum *) bp; bp += 4;
 
6871
 GLchar *buf = (GLchar *) bp;
 
6872
 int bufLen[1] = {strlen((char *)buf)}; bp += bufLen[0]+1+((8-((1+bufLen[0]+0)%8))%8);
 
6873
 weglDebugMessageInsertARB(*source,*type,*id,*severity,*bufLen,buf);
 
6874
}; break;
 
6875
case 5855: { // glGetDebugMessageLogARB
 
6876
 GLuint *count = (GLuint *) bp; bp += 4;
 
6877
 GLsizei *bufsize = (GLsizei *) bp; bp += 4;
 
6878
 GLenum *sources;
 
6879
 sources = (GLenum *) driver_alloc(sizeof(GLenum) * *count);
 
6880
 GLenum *types;
 
6881
 types = (GLenum *) driver_alloc(sizeof(GLenum) * *count);
 
6882
 GLuint *ids;
 
6883
 ids = (GLuint *) driver_alloc(sizeof(GLuint) * *count);
 
6884
 GLenum *severities;
 
6885
 severities = (GLenum *) driver_alloc(sizeof(GLenum) * *count);
 
6886
 GLsizei *lengths;
 
6887
 lengths = (GLsizei *) driver_alloc(sizeof(GLsizei) * *count);
 
6888
 GLchar *messageLog;
 
6889
 messageLog = (GLchar *) driver_alloc(sizeof(GLchar) * *bufsize);
 
6890
 GLuint result = weglGetDebugMessageLogARB(*count,*bufsize,sources,types,ids,severities,lengths,messageLog);
 
6891
 int AP = 0; ErlDrvTermData *rt;
 
6892
 rt = (ErlDrvTermData *) driver_alloc(sizeof(ErlDrvTermData)*(23 + result*3 + result*2 + result*2 + result*2 + result*2));
 
6893
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6894
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
 
6895
 for(int i=0; i < (int) result; i++) {
 
6896
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) sources[i];}
 
6897
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = ((int) result)+1;
 
6898
 for(int i=0; i < (int) result; i++) {
 
6899
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) types[i];}
 
6900
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = ((int) result)+1;
 
6901
 for(int i=0; i < (int) result; i++) {
 
6902
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) ids[i];}
 
6903
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = ((int) result)+1;
 
6904
 for(int i=0; i < (int) result; i++) {
 
6905
    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) severities[i];}
 
6906
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = ((int) result)+1;
 
6907
 for(int i=0; i < (int) result; i++) {
 
6908
    rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) messageLog; rt[AP++] = lengths[i]-1;
 
6909
    messageLog += lengths[i]; }
 
6910
 rt[AP++] = ERL_DRV_NIL; rt[AP++] = ERL_DRV_LIST; rt[AP++] = ((int) result)+1;
 
6911
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 6;
 
6912
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6913
 driver_send_term(port,caller,rt,AP);
 
6914
 driver_free(rt);
 
6915
 driver_free(messageLog);
 
6916
 driver_free(lengths);
 
6917
 driver_free(severities);
 
6918
 driver_free(ids);
 
6919
 driver_free(types);
 
6920
 driver_free(sources);
 
6921
}; break;
 
6922
case 5856: { // glGetGraphicsResetStatusARB
 
6923
 GLenum result = weglGetGraphicsResetStatusARB();
 
6924
 int AP = 0; ErlDrvTermData rt[6];
 
6925
 rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_result_");
 
6926
 rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) result;
 
6927
 rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6928
 driver_send_term(port,caller,rt,AP);
 
6929
}; break;
 
6930
case 5857: { // glResizeBuffersMESA
5377
6931
 weglResizeBuffersMESA();
5378
 
}; break; 
5379
 
case 5677: { // glWindowPos4dvMESA 
 
6932
}; break;
 
6933
case 5858: { // glWindowPos4dvMESA
5380
6934
 GLdouble *v = (GLdouble *) bp; bp += 8;
5381
6935
 weglWindowPos4dvMESA(v);
5382
 
}; break; 
5383
 
case 5678: { // glWindowPos4fvMESA 
 
6936
}; break;
 
6937
case 5859: { // glWindowPos4fvMESA
5384
6938
 GLfloat *v = (GLfloat *) bp; bp += 4;
5385
6939
 weglWindowPos4fvMESA(v);
5386
 
}; break; 
5387
 
case 5679: { // glWindowPos4ivMESA 
 
6940
}; break;
 
6941
case 5860: { // glWindowPos4ivMESA
5388
6942
 GLint *v = (GLint *) bp; bp += 4;
5389
6943
 weglWindowPos4ivMESA(v);
5390
 
}; break; 
5391
 
case 5680: { // glWindowPos4svMESA 
 
6944
}; break;
 
6945
case 5861: { // glWindowPos4svMESA
5392
6946
 GLshort *v = (GLshort *) bp; bp += 2;
5393
6947
 weglWindowPos4svMESA(v);
5394
 
}; break; 
5395
 
case 5681: { // glDepthBoundsEXT 
 
6948
}; break;
 
6949
case 5862: { // glDepthBoundsEXT
5396
6950
 GLclampd *zmin = (GLclampd *) bp; bp += 8;
5397
6951
 GLclampd *zmax = (GLclampd *) bp; bp += 8;
5398
6952
 weglDepthBoundsEXT(*zmin,*zmax);
5399
 
}; break; 
5400
 
case 5682: { // glStencilClearTagEXT 
 
6953
}; break;
 
6954
case 5863: { // glStencilClearTagEXT
5401
6955
 GLsizei *stencilTagBits = (GLsizei *) bp; bp += 4;
5402
6956
 GLuint *stencilClearTag = (GLuint *) bp; bp += 4;
5403
6957
 weglStencilClearTagEXT(*stencilTagBits,*stencilClearTag);
5404
 
}; break; 
 
6958
}; break;
 
6959
}} catch (char *err_msg) {
 
6960
int AP = 0; ErlDrvTermData rt[12];
 
6961
rt[AP++] = ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) "_egl_error_");
 
6962
rt[AP++] = ERL_DRV_INT; rt[AP++] = (int) op;
 
6963
rt[AP++] = ERL_DRV_ATOM; rt[AP++] = driver_mk_atom((char *) err_msg);
 
6964
// rt[AP++] = ERL_DRV_ATOM; rt[AP++] = driver_mk_atom((char *) gl_fns[op-GLE_GL_FUNC_START].name);
 
6965
// rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;
 
6966
rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 3;
 
6967
driver_send_term(port,caller,rt,AP);
5405
6968
}} /* The End */
5406
6969