1 /*
2  * %CopyrightBegin%
3  *
4  * Copyright Ericsson AB 2008-2020. All Rights Reserved.
5  *
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  *     http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *
18  * %CopyrightEnd%
19 */
20 /***** This file is generated do not edit ****/
21 
22 #include <stdio.h>
23 #include <string.h>
24 extern "C" {
25  #include "../egl_impl.h"
26  #include "gl_fdefs.h"
27 }
28 
ecb_gluBuild1DMipmapLevels(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])29 void ecb_gluBuild1DMipmapLevels(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
30 {
31   GLint result;
32   ERL_NIF_TERM reply;
33   GLenum target;
34   GLint internalFormat;
35   GLsizei width;
36   GLenum format;
37   GLenum type;
38   GLint level;
39   GLint base;
40   GLint max;
41   ErlNifBinary data;
42   if(!enif_get_uint(env, argv[0],  &target)) Badarg(5010,"target");
43   if(!enif_get_int(env, argv[1],  &internalFormat)) Badarg(5010,"internalFormat");
44   if(!enif_get_int(env, argv[2],  &width)) Badarg(5010,"width");
45   if(!enif_get_uint(env, argv[3],  &format)) Badarg(5010,"format");
46   if(!enif_get_uint(env, argv[4],  &type)) Badarg(5010,"type");
47   if(!enif_get_int(env, argv[5],  &level)) Badarg(5010,"level");
48   if(!enif_get_int(env, argv[6],  &base)) Badarg(5010,"base");
49   if(!enif_get_int(env, argv[7],  &max)) Badarg(5010,"max");
50   if(!enif_inspect_binary(env, argv[8], &data)) Badarg(5010,"data");
51   result = wegluBuild1DMipmapLevels(target,internalFormat,width,format,type,level,base,max,(void *) data.data);
52   reply =      enif_make_int(env, result);
53   enif_send(NULL, self, env,
54    enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
55 }
56 
ecb_gluBuild1DMipmaps(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])57 void ecb_gluBuild1DMipmaps(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
58 {
59   GLint result;
60   ERL_NIF_TERM reply;
61   GLenum target;
62   GLint internalFormat;
63   GLsizei width;
64   GLenum format;
65   GLenum type;
66   ErlNifBinary data;
67   if(!enif_get_uint(env, argv[0],  &target)) Badarg(5011,"target");
68   if(!enif_get_int(env, argv[1],  &internalFormat)) Badarg(5011,"internalFormat");
69   if(!enif_get_int(env, argv[2],  &width)) Badarg(5011,"width");
70   if(!enif_get_uint(env, argv[3],  &format)) Badarg(5011,"format");
71   if(!enif_get_uint(env, argv[4],  &type)) Badarg(5011,"type");
72   if(!enif_inspect_binary(env, argv[5], &data)) Badarg(5011,"data");
73   result = wegluBuild1DMipmaps(target,internalFormat,width,format,type,(void *) data.data);
74   reply =      enif_make_int(env, result);
75   enif_send(NULL, self, env,
76    enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
77 }
78 
ecb_gluBuild2DMipmapLevels(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])79 void ecb_gluBuild2DMipmapLevels(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
80 {
81   GLint result;
82   ERL_NIF_TERM reply;
83   GLenum target;
84   GLint internalFormat;
85   GLsizei width;
86   GLsizei height;
87   GLenum format;
88   GLenum type;
89   GLint level;
90   GLint base;
91   GLint max;
92   ErlNifBinary data;
93   if(!enif_get_uint(env, argv[0],  &target)) Badarg(5012,"target");
94   if(!enif_get_int(env, argv[1],  &internalFormat)) Badarg(5012,"internalFormat");
95   if(!enif_get_int(env, argv[2],  &width)) Badarg(5012,"width");
96   if(!enif_get_int(env, argv[3],  &height)) Badarg(5012,"height");
97   if(!enif_get_uint(env, argv[4],  &format)) Badarg(5012,"format");
98   if(!enif_get_uint(env, argv[5],  &type)) Badarg(5012,"type");
99   if(!enif_get_int(env, argv[6],  &level)) Badarg(5012,"level");
100   if(!enif_get_int(env, argv[7],  &base)) Badarg(5012,"base");
101   if(!enif_get_int(env, argv[8],  &max)) Badarg(5012,"max");
102   if(!enif_inspect_binary(env, argv[9], &data)) Badarg(5012,"data");
103   result = wegluBuild2DMipmapLevels(target,internalFormat,width,height,format,type,level,base,max,(void *) data.data);
104   reply =      enif_make_int(env, result);
105   enif_send(NULL, self, env,
106    enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
107 }
108 
ecb_gluBuild2DMipmaps(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])109 void ecb_gluBuild2DMipmaps(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
110 {
111   GLint result;
112   ERL_NIF_TERM reply;
113   GLenum target;
114   GLint internalFormat;
115   GLsizei width;
116   GLsizei height;
117   GLenum format;
118   GLenum type;
119   ErlNifBinary data;
120   if(!enif_get_uint(env, argv[0],  &target)) Badarg(5013,"target");
121   if(!enif_get_int(env, argv[1],  &internalFormat)) Badarg(5013,"internalFormat");
122   if(!enif_get_int(env, argv[2],  &width)) Badarg(5013,"width");
123   if(!enif_get_int(env, argv[3],  &height)) Badarg(5013,"height");
124   if(!enif_get_uint(env, argv[4],  &format)) Badarg(5013,"format");
125   if(!enif_get_uint(env, argv[5],  &type)) Badarg(5013,"type");
126   if(!enif_inspect_binary(env, argv[6], &data)) Badarg(5013,"data");
127   result = wegluBuild2DMipmaps(target,internalFormat,width,height,format,type,(void *) data.data);
128   reply =      enif_make_int(env, result);
129   enif_send(NULL, self, env,
130    enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
131 }
132 
ecb_gluBuild3DMipmapLevels(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])133 void ecb_gluBuild3DMipmapLevels(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
134 {
135   GLint result;
136   ERL_NIF_TERM reply;
137   GLenum target;
138   GLint internalFormat;
139   GLsizei width;
140   GLsizei height;
141   GLsizei depth;
142   GLenum format;
143   GLenum type;
144   GLint level;
145   GLint base;
146   GLint max;
147   ErlNifBinary data;
148   if(!enif_get_uint(env, argv[0],  &target)) Badarg(5014,"target");
149   if(!enif_get_int(env, argv[1],  &internalFormat)) Badarg(5014,"internalFormat");
150   if(!enif_get_int(env, argv[2],  &width)) Badarg(5014,"width");
151   if(!enif_get_int(env, argv[3],  &height)) Badarg(5014,"height");
152   if(!enif_get_int(env, argv[4],  &depth)) Badarg(5014,"depth");
153   if(!enif_get_uint(env, argv[5],  &format)) Badarg(5014,"format");
154   if(!enif_get_uint(env, argv[6],  &type)) Badarg(5014,"type");
155   if(!enif_get_int(env, argv[7],  &level)) Badarg(5014,"level");
156   if(!enif_get_int(env, argv[8],  &base)) Badarg(5014,"base");
157   if(!enif_get_int(env, argv[9],  &max)) Badarg(5014,"max");
158   if(!enif_inspect_binary(env, argv[10], &data)) Badarg(5014,"data");
159   result = wegluBuild3DMipmapLevels(target,internalFormat,width,height,depth,format,type,level,base,max,(void *) data.data);
160   reply =      enif_make_int(env, result);
161   enif_send(NULL, self, env,
162    enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
163 }
164 
ecb_gluBuild3DMipmaps(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])165 void ecb_gluBuild3DMipmaps(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
166 {
167   GLint result;
168   ERL_NIF_TERM reply;
169   GLenum target;
170   GLint internalFormat;
171   GLsizei width;
172   GLsizei height;
173   GLsizei depth;
174   GLenum format;
175   GLenum type;
176   ErlNifBinary data;
177   if(!enif_get_uint(env, argv[0],  &target)) Badarg(5015,"target");
178   if(!enif_get_int(env, argv[1],  &internalFormat)) Badarg(5015,"internalFormat");
179   if(!enif_get_int(env, argv[2],  &width)) Badarg(5015,"width");
180   if(!enif_get_int(env, argv[3],  &height)) Badarg(5015,"height");
181   if(!enif_get_int(env, argv[4],  &depth)) Badarg(5015,"depth");
182   if(!enif_get_uint(env, argv[5],  &format)) Badarg(5015,"format");
183   if(!enif_get_uint(env, argv[6],  &type)) Badarg(5015,"type");
184   if(!enif_inspect_binary(env, argv[7], &data)) Badarg(5015,"data");
185   result = wegluBuild3DMipmaps(target,internalFormat,width,height,depth,format,type,(void *) data.data);
186   reply =      enif_make_int(env, result);
187   enif_send(NULL, self, env,
188    enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
189 }
190 
ecb_gluCheckExtension(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])191 void ecb_gluCheckExtension(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
192 {
193   GLboolean result;
194   ERL_NIF_TERM reply;
195   ErlNifBinary extName;
196   ErlNifBinary extString;
197   if(!enif_inspect_binary(env, argv[0], &extName)) Badarg(5016,"extName");
198   if(!enif_inspect_binary(env, argv[1], &extString)) Badarg(5016,"extString");
199   result = wegluCheckExtension((GLubyte *) extName.data,(GLubyte *) extString.data);
200   reply =      enif_make_int(env, result);
201   enif_send(NULL, self, env,
202    enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
203 }
204 
ecb_gluCylinder(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])205 void ecb_gluCylinder(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
206 {
207   GLUquadric *quad;
208   GLdouble base;
209   GLdouble top;
210   GLdouble height;
211   GLint slices;
212   GLint stacks;
213   if(!egl_get_ptr(env, argv[0], (void **) &quad)) Badarg(5017,"quad");
214   if(!enif_get_double(env, argv[1],  &base)) Badarg(5017,"base");
215   if(!enif_get_double(env, argv[2],  &top)) Badarg(5017,"top");
216   if(!enif_get_double(env, argv[3],  &height)) Badarg(5017,"height");
217   if(!enif_get_int(env, argv[4],  &slices)) Badarg(5017,"slices");
218   if(!enif_get_int(env, argv[5],  &stacks)) Badarg(5017,"stacks");
219   wegluCylinder(quad,base,top,height,slices,stacks);
220 }
221 
ecb_gluDeleteQuadric(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])222 void ecb_gluDeleteQuadric(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
223 {
224   GLUquadric *quad;
225   if(!egl_get_ptr(env, argv[0], (void **) &quad)) Badarg(5018,"quad");
226   wegluDeleteQuadric(quad);
227 }
228 
ecb_gluDisk(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])229 void ecb_gluDisk(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
230 {
231   GLUquadric *quad;
232   GLdouble inner;
233   GLdouble outer;
234   GLint slices;
235   GLint loops;
236   if(!egl_get_ptr(env, argv[0], (void **) &quad)) Badarg(5019,"quad");
237   if(!enif_get_double(env, argv[1],  &inner)) Badarg(5019,"inner");
238   if(!enif_get_double(env, argv[2],  &outer)) Badarg(5019,"outer");
239   if(!enif_get_int(env, argv[3],  &slices)) Badarg(5019,"slices");
240   if(!enif_get_int(env, argv[4],  &loops)) Badarg(5019,"loops");
241   wegluDisk(quad,inner,outer,slices,loops);
242 }
243 
ecb_gluErrorString(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])244 void ecb_gluErrorString(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
245 {
246   const GLubyte *  result;
247   ERL_NIF_TERM reply;
248   GLenum error;
249   if(!enif_get_uint(env, argv[0],  &error)) Badarg(5020,"error");
250   result = wegluErrorString(error);
251   reply =      enif_make_string(env, (const char *) result, ERL_NIF_LATIN1);
252   enif_send(NULL, self, env,
253    enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
254 }
255 
ecb_gluGetString(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])256 void ecb_gluGetString(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
257 {
258   const GLubyte *  result;
259   ERL_NIF_TERM reply;
260   GLenum name;
261   if(!enif_get_uint(env, argv[0],  &name)) Badarg(5021,"name");
262   result = wegluGetString(name);
263   reply =      enif_make_string(env, (const char *) result, ERL_NIF_LATIN1);
264   enif_send(NULL, self, env,
265    enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
266 }
267 
ecb_gluLookAt(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])268 void ecb_gluLookAt(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
269 {
270   GLdouble eyeX;
271   GLdouble eyeY;
272   GLdouble eyeZ;
273   GLdouble centerX;
274   GLdouble centerY;
275   GLdouble centerZ;
276   GLdouble upX;
277   GLdouble upY;
278   GLdouble upZ;
279   if(!enif_get_double(env, argv[0],  &eyeX)) Badarg(5022,"eyeX");
280   if(!enif_get_double(env, argv[1],  &eyeY)) Badarg(5022,"eyeY");
281   if(!enif_get_double(env, argv[2],  &eyeZ)) Badarg(5022,"eyeZ");
282   if(!enif_get_double(env, argv[3],  &centerX)) Badarg(5022,"centerX");
283   if(!enif_get_double(env, argv[4],  &centerY)) Badarg(5022,"centerY");
284   if(!enif_get_double(env, argv[5],  &centerZ)) Badarg(5022,"centerZ");
285   if(!enif_get_double(env, argv[6],  &upX)) Badarg(5022,"upX");
286   if(!enif_get_double(env, argv[7],  &upY)) Badarg(5022,"upY");
287   if(!enif_get_double(env, argv[8],  &upZ)) Badarg(5022,"upZ");
288   wegluLookAt(eyeX,eyeY,eyeZ,centerX,centerY,centerZ,upX,upY,upZ);
289 }
290 
ecb_gluNewQuadric(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])291 void ecb_gluNewQuadric(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
292 {
293   GLUquadric *  result;
294   ERL_NIF_TERM reply;
295   result = wegluNewQuadric();
296   reply =      enif_make_uint64(env, (egl_uint64_t) result);
297   enif_send(NULL, self, env,
298    enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
299 }
300 
ecb_gluOrtho2D(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])301 void ecb_gluOrtho2D(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
302 {
303   GLdouble left;
304   GLdouble right;
305   GLdouble bottom;
306   GLdouble top;
307   if(!enif_get_double(env, argv[0],  &left)) Badarg(5024,"left");
308   if(!enif_get_double(env, argv[1],  &right)) Badarg(5024,"right");
309   if(!enif_get_double(env, argv[2],  &bottom)) Badarg(5024,"bottom");
310   if(!enif_get_double(env, argv[3],  &top)) Badarg(5024,"top");
311   wegluOrtho2D(left,right,bottom,top);
312 }
313 
ecb_gluPartialDisk(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])314 void ecb_gluPartialDisk(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
315 {
316   GLUquadric *quad;
317   GLdouble inner;
318   GLdouble outer;
319   GLint slices;
320   GLint loops;
321   GLdouble start;
322   GLdouble sweep;
323   if(!egl_get_ptr(env, argv[0], (void **) &quad)) Badarg(5025,"quad");
324   if(!enif_get_double(env, argv[1],  &inner)) Badarg(5025,"inner");
325   if(!enif_get_double(env, argv[2],  &outer)) Badarg(5025,"outer");
326   if(!enif_get_int(env, argv[3],  &slices)) Badarg(5025,"slices");
327   if(!enif_get_int(env, argv[4],  &loops)) Badarg(5025,"loops");
328   if(!enif_get_double(env, argv[5],  &start)) Badarg(5025,"start");
329   if(!enif_get_double(env, argv[6],  &sweep)) Badarg(5025,"sweep");
330   wegluPartialDisk(quad,inner,outer,slices,loops,start,sweep);
331 }
332 
ecb_gluPerspective(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])333 void ecb_gluPerspective(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
334 {
335   GLdouble fovy;
336   GLdouble aspect;
337   GLdouble zNear;
338   GLdouble zFar;
339   if(!enif_get_double(env, argv[0],  &fovy)) Badarg(5026,"fovy");
340   if(!enif_get_double(env, argv[1],  &aspect)) Badarg(5026,"aspect");
341   if(!enif_get_double(env, argv[2],  &zNear)) Badarg(5026,"zNear");
342   if(!enif_get_double(env, argv[3],  &zFar)) Badarg(5026,"zFar");
343   wegluPerspective(fovy,aspect,zNear,zFar);
344 }
345 
ecb_gluPickMatrix(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])346 void ecb_gluPickMatrix(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
347 {
348   GLdouble x;
349   GLdouble y;
350   GLdouble delX;
351   GLdouble delY;
352   GLint viewport[4];
353   if(!enif_get_double(env, argv[0],  &x)) Badarg(5027,"x");
354   if(!enif_get_double(env, argv[1],  &y)) Badarg(5027,"y");
355   if(!enif_get_double(env, argv[2],  &delX)) Badarg(5027,"delX");
356   if(!enif_get_double(env, argv[3],  &delY)) Badarg(5027,"delY");
357   {
358    int viewport_a;
359    const ERL_NIF_TERM *viewport_t;
360    if(!enif_get_tuple(env, argv[4], &viewport_a, &viewport_t) || viewport_a != 4) {
361      Badarg(5027,"viewport");
362    } else {
363     int i1 = 0;
364      if(!enif_get_int(env, viewport_t[i1++], &viewport[0])) Badarg(5027,"viewport");
365      if(!enif_get_int(env, viewport_t[i1++], &viewport[1])) Badarg(5027,"viewport");
366      if(!enif_get_int(env, viewport_t[i1++], &viewport[2])) Badarg(5027,"viewport");
367      if(!enif_get_int(env, viewport_t[i1++], &viewport[3])) Badarg(5027,"viewport");
368    }};
369   wegluPickMatrix(x,y,delX,delY,viewport);
370 }
371 
ecb_gluProject(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])372 void ecb_gluProject(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
373 {
374   GLint result;
375   ERL_NIF_TERM reply;
376   GLdouble objX;
377   GLdouble objY;
378   GLdouble objZ;
379   GLdouble model[16];
380   GLdouble proj[16];
381   GLint view[4];
382   GLdouble winX;
383   GLdouble winY;
384   GLdouble winZ;
385   if(!enif_get_double(env, argv[0],  &objX)) Badarg(5028,"objX");
386   if(!enif_get_double(env, argv[1],  &objY)) Badarg(5028,"objY");
387   if(!enif_get_double(env, argv[2],  &objZ)) Badarg(5028,"objZ");
388   {
389    int model_a;
390    const ERL_NIF_TERM *model_t;
391    if(!enif_get_tuple(env, argv[3], &model_a, &model_t)
392        || (model_a != 12 && model_a != 16)) {
393      Badarg(5028,"model");
394    } else {
395     int i1 = 0;
396      if(!enif_get_double(env, model_t[i1++], &model[0])) Badarg(5028,"model");
397      if(!enif_get_double(env, model_t[i1++], &model[1])) Badarg(5028,"model");
398      if(!enif_get_double(env, model_t[i1++], &model[2])) Badarg(5028,"model");
399      if(model_a == 16)
400         if(!enif_get_double(env, model_t[i1++], &model[3])) Badarg(5028,"model");
401      if(!enif_get_double(env, model_t[i1++], &model[4])) Badarg(5028,"model");
402      if(!enif_get_double(env, model_t[i1++], &model[5])) Badarg(5028,"model");
403      if(!enif_get_double(env, model_t[i1++], &model[6])) Badarg(5028,"model");
404      if(model_a == 16)
405         if(!enif_get_double(env, model_t[i1++], &model[7])) Badarg(5028,"model");
406      if(!enif_get_double(env, model_t[i1++], &model[8])) Badarg(5028,"model");
407      if(!enif_get_double(env, model_t[i1++], &model[9])) Badarg(5028,"model");
408      if(!enif_get_double(env, model_t[i1++], &model[10])) Badarg(5028,"model");
409      if(model_a == 16)
410         if(!enif_get_double(env, model_t[i1++], &model[11])) Badarg(5028,"model");
411      if(!enif_get_double(env, model_t[i1++], &model[12])) Badarg(5028,"model");
412      if(!enif_get_double(env, model_t[i1++], &model[13])) Badarg(5028,"model");
413      if(!enif_get_double(env, model_t[i1++], &model[14])) Badarg(5028,"model");
414      if(model_a == 16) {
415         if(!enif_get_double(env, model_t[i1++], &model[15])) Badarg(5028,"model");
416      } else {
417        model[3] = 0.0; model[7] = 0.0; model[11] = 0.0; model[15] = 1.0;
418      }
419    }};
420   {
421    int proj_a;
422    const ERL_NIF_TERM *proj_t;
423    if(!enif_get_tuple(env, argv[4], &proj_a, &proj_t)
424        || (proj_a != 12 && proj_a != 16)) {
425      Badarg(5028,"proj");
426    } else {
427     int i1 = 0;
428      if(!enif_get_double(env, proj_t[i1++], &proj[0])) Badarg(5028,"proj");
429      if(!enif_get_double(env, proj_t[i1++], &proj[1])) Badarg(5028,"proj");
430      if(!enif_get_double(env, proj_t[i1++], &proj[2])) Badarg(5028,"proj");
431      if(proj_a == 16)
432         if(!enif_get_double(env, proj_t[i1++], &proj[3])) Badarg(5028,"proj");
433      if(!enif_get_double(env, proj_t[i1++], &proj[4])) Badarg(5028,"proj");
434      if(!enif_get_double(env, proj_t[i1++], &proj[5])) Badarg(5028,"proj");
435      if(!enif_get_double(env, proj_t[i1++], &proj[6])) Badarg(5028,"proj");
436      if(proj_a == 16)
437         if(!enif_get_double(env, proj_t[i1++], &proj[7])) Badarg(5028,"proj");
438      if(!enif_get_double(env, proj_t[i1++], &proj[8])) Badarg(5028,"proj");
439      if(!enif_get_double(env, proj_t[i1++], &proj[9])) Badarg(5028,"proj");
440      if(!enif_get_double(env, proj_t[i1++], &proj[10])) Badarg(5028,"proj");
441      if(proj_a == 16)
442         if(!enif_get_double(env, proj_t[i1++], &proj[11])) Badarg(5028,"proj");
443      if(!enif_get_double(env, proj_t[i1++], &proj[12])) Badarg(5028,"proj");
444      if(!enif_get_double(env, proj_t[i1++], &proj[13])) Badarg(5028,"proj");
445      if(!enif_get_double(env, proj_t[i1++], &proj[14])) Badarg(5028,"proj");
446      if(proj_a == 16) {
447         if(!enif_get_double(env, proj_t[i1++], &proj[15])) Badarg(5028,"proj");
448      } else {
449        proj[3] = 0.0; proj[7] = 0.0; proj[11] = 0.0; proj[15] = 1.0;
450      }
451    }};
452   {
453    int view_a;
454    const ERL_NIF_TERM *view_t;
455    if(!enif_get_tuple(env, argv[5], &view_a, &view_t) || view_a != 4) {
456      Badarg(5028,"view");
457    } else {
458     int i1 = 0;
459      if(!enif_get_int(env, view_t[i1++], &view[0])) Badarg(5028,"view");
460      if(!enif_get_int(env, view_t[i1++], &view[1])) Badarg(5028,"view");
461      if(!enif_get_int(env, view_t[i1++], &view[2])) Badarg(5028,"view");
462      if(!enif_get_int(env, view_t[i1++], &view[3])) Badarg(5028,"view");
463    }};
464   result = wegluProject(objX,objY,objZ,model,proj,view,&winX,&winY,&winZ);
465   reply = enif_make_tuple4(env,
466           enif_make_int(env, result),
467      enif_make_double(env, winX),
468      enif_make_double(env, winY),
469      enif_make_double(env, winZ) );
470   enif_send(NULL, self, env,
471    enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
472 }
473 
ecb_gluQuadricDrawStyle(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])474 void ecb_gluQuadricDrawStyle(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
475 {
476   GLUquadric *quad;
477   GLenum draw;
478   if(!egl_get_ptr(env, argv[0], (void **) &quad)) Badarg(5029,"quad");
479   if(!enif_get_uint(env, argv[1],  &draw)) Badarg(5029,"draw");
480   wegluQuadricDrawStyle(quad,draw);
481 }
482 
ecb_gluQuadricNormals(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])483 void ecb_gluQuadricNormals(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
484 {
485   GLUquadric *quad;
486   GLenum normal;
487   if(!egl_get_ptr(env, argv[0], (void **) &quad)) Badarg(5030,"quad");
488   if(!enif_get_uint(env, argv[1],  &normal)) Badarg(5030,"normal");
489   wegluQuadricNormals(quad,normal);
490 }
491 
ecb_gluQuadricOrientation(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])492 void ecb_gluQuadricOrientation(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
493 {
494   GLUquadric *quad;
495   GLenum orientation;
496   if(!egl_get_ptr(env, argv[0], (void **) &quad)) Badarg(5031,"quad");
497   if(!enif_get_uint(env, argv[1],  &orientation)) Badarg(5031,"orientation");
498   wegluQuadricOrientation(quad,orientation);
499 }
500 
ecb_gluQuadricTexture(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])501 void ecb_gluQuadricTexture(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
502 {
503   GLUquadric *quad;
504   GLboolean texture;
505   if(!egl_get_ptr(env, argv[0], (void **) &quad)) Badarg(5032,"quad");
506   if(!egl_get_ubyte(env, argv[1],  &texture)) Badarg(5032,"texture");
507   wegluQuadricTexture(quad,texture);
508 }
509 
ecb_gluScaleImage(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])510 void ecb_gluScaleImage(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
511 {
512   GLint result;
513   ERL_NIF_TERM reply;
514   GLenum format;
515   GLsizei wIn;
516   GLsizei hIn;
517   GLenum typeIn;
518   ErlNifBinary dataIn;
519   GLsizei wOut;
520   GLsizei hOut;
521   GLenum typeOut;
522   ErlNifBinary dataOut;
523   if(!enif_get_uint(env, argv[0],  &format)) Badarg(5033,"format");
524   if(!enif_get_int(env, argv[1],  &wIn)) Badarg(5033,"wIn");
525   if(!enif_get_int(env, argv[2],  &hIn)) Badarg(5033,"hIn");
526   if(!enif_get_uint(env, argv[3],  &typeIn)) Badarg(5033,"typeIn");
527   if(!enif_inspect_binary(env, argv[4], &dataIn)) Badarg(5033,"dataIn");
528   if(!enif_get_int(env, argv[5],  &wOut)) Badarg(5033,"wOut");
529   if(!enif_get_int(env, argv[6],  &hOut)) Badarg(5033,"hOut");
530   if(!enif_get_uint(env, argv[7],  &typeOut)) Badarg(5033,"typeOut");
531   if(enif_is_binary(env, argv[8]))
532     enif_inspect_binary(env, argv[8], &dataOut);
533   else if(enif_is_tuple(env, argv[8])) {
534     int dataOut_a;
535     const ERL_NIF_TERM *dataOut_t;
536     if(enif_get_tuple(env, argv[8], &dataOut_a, &dataOut_t) &&
537          enif_is_binary(env, dataOut_t[1]))
538        enif_inspect_binary(env, dataOut_t[1], &dataOut);
539     else Badarg(5033, "dataOut");
540   } else Badarg(5033, "dataOut");
541   result = wegluScaleImage(format,wIn,hIn,typeIn,(void *) dataIn.data,wOut,hOut,typeOut,(GLvoid *) dataOut.data);
542   reply =      enif_make_int(env, result);
543   enif_send(NULL, self, env,
544    enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
545 }
546 
ecb_gluSphere(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])547 void ecb_gluSphere(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
548 {
549   GLUquadric *quad;
550   GLdouble radius;
551   GLint slices;
552   GLint stacks;
553   if(!egl_get_ptr(env, argv[0], (void **) &quad)) Badarg(5034,"quad");
554   if(!enif_get_double(env, argv[1],  &radius)) Badarg(5034,"radius");
555   if(!enif_get_int(env, argv[2],  &slices)) Badarg(5034,"slices");
556   if(!enif_get_int(env, argv[3],  &stacks)) Badarg(5034,"stacks");
557   wegluSphere(quad,radius,slices,stacks);
558 }
559 
ecb_gluUnProject(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])560 void ecb_gluUnProject(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
561 {
562   GLint result;
563   ERL_NIF_TERM reply;
564   GLdouble winX;
565   GLdouble winY;
566   GLdouble winZ;
567   GLdouble model[16];
568   GLdouble proj[16];
569   GLint view[4];
570   GLdouble objX;
571   GLdouble objY;
572   GLdouble objZ;
573   if(!enif_get_double(env, argv[0],  &winX)) Badarg(5035,"winX");
574   if(!enif_get_double(env, argv[1],  &winY)) Badarg(5035,"winY");
575   if(!enif_get_double(env, argv[2],  &winZ)) Badarg(5035,"winZ");
576   {
577    int model_a;
578    const ERL_NIF_TERM *model_t;
579    if(!enif_get_tuple(env, argv[3], &model_a, &model_t)
580        || (model_a != 12 && model_a != 16)) {
581      Badarg(5035,"model");
582    } else {
583     int i1 = 0;
584      if(!enif_get_double(env, model_t[i1++], &model[0])) Badarg(5035,"model");
585      if(!enif_get_double(env, model_t[i1++], &model[1])) Badarg(5035,"model");
586      if(!enif_get_double(env, model_t[i1++], &model[2])) Badarg(5035,"model");
587      if(model_a == 16)
588         if(!enif_get_double(env, model_t[i1++], &model[3])) Badarg(5035,"model");
589      if(!enif_get_double(env, model_t[i1++], &model[4])) Badarg(5035,"model");
590      if(!enif_get_double(env, model_t[i1++], &model[5])) Badarg(5035,"model");
591      if(!enif_get_double(env, model_t[i1++], &model[6])) Badarg(5035,"model");
592      if(model_a == 16)
593         if(!enif_get_double(env, model_t[i1++], &model[7])) Badarg(5035,"model");
594      if(!enif_get_double(env, model_t[i1++], &model[8])) Badarg(5035,"model");
595      if(!enif_get_double(env, model_t[i1++], &model[9])) Badarg(5035,"model");
596      if(!enif_get_double(env, model_t[i1++], &model[10])) Badarg(5035,"model");
597      if(model_a == 16)
598         if(!enif_get_double(env, model_t[i1++], &model[11])) Badarg(5035,"model");
599      if(!enif_get_double(env, model_t[i1++], &model[12])) Badarg(5035,"model");
600      if(!enif_get_double(env, model_t[i1++], &model[13])) Badarg(5035,"model");
601      if(!enif_get_double(env, model_t[i1++], &model[14])) Badarg(5035,"model");
602      if(model_a == 16) {
603         if(!enif_get_double(env, model_t[i1++], &model[15])) Badarg(5035,"model");
604      } else {
605        model[3] = 0.0; model[7] = 0.0; model[11] = 0.0; model[15] = 1.0;
606      }
607    }};
608   {
609    int proj_a;
610    const ERL_NIF_TERM *proj_t;
611    if(!enif_get_tuple(env, argv[4], &proj_a, &proj_t)
612        || (proj_a != 12 && proj_a != 16)) {
613      Badarg(5035,"proj");
614    } else {
615     int i1 = 0;
616      if(!enif_get_double(env, proj_t[i1++], &proj[0])) Badarg(5035,"proj");
617      if(!enif_get_double(env, proj_t[i1++], &proj[1])) Badarg(5035,"proj");
618      if(!enif_get_double(env, proj_t[i1++], &proj[2])) Badarg(5035,"proj");
619      if(proj_a == 16)
620         if(!enif_get_double(env, proj_t[i1++], &proj[3])) Badarg(5035,"proj");
621      if(!enif_get_double(env, proj_t[i1++], &proj[4])) Badarg(5035,"proj");
622      if(!enif_get_double(env, proj_t[i1++], &proj[5])) Badarg(5035,"proj");
623      if(!enif_get_double(env, proj_t[i1++], &proj[6])) Badarg(5035,"proj");
624      if(proj_a == 16)
625         if(!enif_get_double(env, proj_t[i1++], &proj[7])) Badarg(5035,"proj");
626      if(!enif_get_double(env, proj_t[i1++], &proj[8])) Badarg(5035,"proj");
627      if(!enif_get_double(env, proj_t[i1++], &proj[9])) Badarg(5035,"proj");
628      if(!enif_get_double(env, proj_t[i1++], &proj[10])) Badarg(5035,"proj");
629      if(proj_a == 16)
630         if(!enif_get_double(env, proj_t[i1++], &proj[11])) Badarg(5035,"proj");
631      if(!enif_get_double(env, proj_t[i1++], &proj[12])) Badarg(5035,"proj");
632      if(!enif_get_double(env, proj_t[i1++], &proj[13])) Badarg(5035,"proj");
633      if(!enif_get_double(env, proj_t[i1++], &proj[14])) Badarg(5035,"proj");
634      if(proj_a == 16) {
635         if(!enif_get_double(env, proj_t[i1++], &proj[15])) Badarg(5035,"proj");
636      } else {
637        proj[3] = 0.0; proj[7] = 0.0; proj[11] = 0.0; proj[15] = 1.0;
638      }
639    }};
640   {
641    int view_a;
642    const ERL_NIF_TERM *view_t;
643    if(!enif_get_tuple(env, argv[5], &view_a, &view_t) || view_a != 4) {
644      Badarg(5035,"view");
645    } else {
646     int i1 = 0;
647      if(!enif_get_int(env, view_t[i1++], &view[0])) Badarg(5035,"view");
648      if(!enif_get_int(env, view_t[i1++], &view[1])) Badarg(5035,"view");
649      if(!enif_get_int(env, view_t[i1++], &view[2])) Badarg(5035,"view");
650      if(!enif_get_int(env, view_t[i1++], &view[3])) Badarg(5035,"view");
651    }};
652   result = wegluUnProject(winX,winY,winZ,model,proj,view,&objX,&objY,&objZ);
653   reply = enif_make_tuple4(env,
654           enif_make_int(env, result),
655      enif_make_double(env, objX),
656      enif_make_double(env, objY),
657      enif_make_double(env, objZ) );
658   enif_send(NULL, self, env,
659    enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
660 }
661 
ecb_gluUnProject4(ErlNifEnv * env,ErlNifPid * self,ERL_NIF_TERM argv[])662 void ecb_gluUnProject4(ErlNifEnv* env, ErlNifPid *self, ERL_NIF_TERM argv[])
663 {
664   GLint result;
665   ERL_NIF_TERM reply;
666   GLdouble winX;
667   GLdouble winY;
668   GLdouble winZ;
669   GLdouble clipW;
670   GLdouble model[16];
671   GLdouble proj[16];
672   GLint view[4];
673   GLdouble nearVal;
674   GLdouble farVal;
675   GLdouble objX;
676   GLdouble objY;
677   GLdouble objZ;
678   GLdouble objW;
679   if(!enif_get_double(env, argv[0],  &winX)) Badarg(5036,"winX");
680   if(!enif_get_double(env, argv[1],  &winY)) Badarg(5036,"winY");
681   if(!enif_get_double(env, argv[2],  &winZ)) Badarg(5036,"winZ");
682   if(!enif_get_double(env, argv[3],  &clipW)) Badarg(5036,"clipW");
683   {
684    int model_a;
685    const ERL_NIF_TERM *model_t;
686    if(!enif_get_tuple(env, argv[4], &model_a, &model_t)
687        || (model_a != 12 && model_a != 16)) {
688      Badarg(5036,"model");
689    } else {
690     int i1 = 0;
691      if(!enif_get_double(env, model_t[i1++], &model[0])) Badarg(5036,"model");
692      if(!enif_get_double(env, model_t[i1++], &model[1])) Badarg(5036,"model");
693      if(!enif_get_double(env, model_t[i1++], &model[2])) Badarg(5036,"model");
694      if(model_a == 16)
695         if(!enif_get_double(env, model_t[i1++], &model[3])) Badarg(5036,"model");
696      if(!enif_get_double(env, model_t[i1++], &model[4])) Badarg(5036,"model");
697      if(!enif_get_double(env, model_t[i1++], &model[5])) Badarg(5036,"model");
698      if(!enif_get_double(env, model_t[i1++], &model[6])) Badarg(5036,"model");
699      if(model_a == 16)
700         if(!enif_get_double(env, model_t[i1++], &model[7])) Badarg(5036,"model");
701      if(!enif_get_double(env, model_t[i1++], &model[8])) Badarg(5036,"model");
702      if(!enif_get_double(env, model_t[i1++], &model[9])) Badarg(5036,"model");
703      if(!enif_get_double(env, model_t[i1++], &model[10])) Badarg(5036,"model");
704      if(model_a == 16)
705         if(!enif_get_double(env, model_t[i1++], &model[11])) Badarg(5036,"model");
706      if(!enif_get_double(env, model_t[i1++], &model[12])) Badarg(5036,"model");
707      if(!enif_get_double(env, model_t[i1++], &model[13])) Badarg(5036,"model");
708      if(!enif_get_double(env, model_t[i1++], &model[14])) Badarg(5036,"model");
709      if(model_a == 16) {
710         if(!enif_get_double(env, model_t[i1++], &model[15])) Badarg(5036,"model");
711      } else {
712        model[3] = 0.0; model[7] = 0.0; model[11] = 0.0; model[15] = 1.0;
713      }
714    }};
715   {
716    int proj_a;
717    const ERL_NIF_TERM *proj_t;
718    if(!enif_get_tuple(env, argv[5], &proj_a, &proj_t)
719        || (proj_a != 12 && proj_a != 16)) {
720      Badarg(5036,"proj");
721    } else {
722     int i1 = 0;
723      if(!enif_get_double(env, proj_t[i1++], &proj[0])) Badarg(5036,"proj");
724      if(!enif_get_double(env, proj_t[i1++], &proj[1])) Badarg(5036,"proj");
725      if(!enif_get_double(env, proj_t[i1++], &proj[2])) Badarg(5036,"proj");
726      if(proj_a == 16)
727         if(!enif_get_double(env, proj_t[i1++], &proj[3])) Badarg(5036,"proj");
728      if(!enif_get_double(env, proj_t[i1++], &proj[4])) Badarg(5036,"proj");
729      if(!enif_get_double(env, proj_t[i1++], &proj[5])) Badarg(5036,"proj");
730      if(!enif_get_double(env, proj_t[i1++], &proj[6])) Badarg(5036,"proj");
731      if(proj_a == 16)
732         if(!enif_get_double(env, proj_t[i1++], &proj[7])) Badarg(5036,"proj");
733      if(!enif_get_double(env, proj_t[i1++], &proj[8])) Badarg(5036,"proj");
734      if(!enif_get_double(env, proj_t[i1++], &proj[9])) Badarg(5036,"proj");
735      if(!enif_get_double(env, proj_t[i1++], &proj[10])) Badarg(5036,"proj");
736      if(proj_a == 16)
737         if(!enif_get_double(env, proj_t[i1++], &proj[11])) Badarg(5036,"proj");
738      if(!enif_get_double(env, proj_t[i1++], &proj[12])) Badarg(5036,"proj");
739      if(!enif_get_double(env, proj_t[i1++], &proj[13])) Badarg(5036,"proj");
740      if(!enif_get_double(env, proj_t[i1++], &proj[14])) Badarg(5036,"proj");
741      if(proj_a == 16) {
742         if(!enif_get_double(env, proj_t[i1++], &proj[15])) Badarg(5036,"proj");
743      } else {
744        proj[3] = 0.0; proj[7] = 0.0; proj[11] = 0.0; proj[15] = 1.0;
745      }
746    }};
747   {
748    int view_a;
749    const ERL_NIF_TERM *view_t;
750    if(!enif_get_tuple(env, argv[6], &view_a, &view_t) || view_a != 4) {
751      Badarg(5036,"view");
752    } else {
753     int i1 = 0;
754      if(!enif_get_int(env, view_t[i1++], &view[0])) Badarg(5036,"view");
755      if(!enif_get_int(env, view_t[i1++], &view[1])) Badarg(5036,"view");
756      if(!enif_get_int(env, view_t[i1++], &view[2])) Badarg(5036,"view");
757      if(!enif_get_int(env, view_t[i1++], &view[3])) Badarg(5036,"view");
758    }};
759   if(!enif_get_double(env, argv[7],  &nearVal)) Badarg(5036,"nearVal");
760   if(!enif_get_double(env, argv[8],  &farVal)) Badarg(5036,"farVal");
761   result = wegluUnProject4(winX,winY,winZ,clipW,model,proj,view,nearVal,farVal,&objX,&objY,&objZ,&objW);
762   reply = enif_make_tuple5(env,
763           enif_make_int(env, result),
764      enif_make_double(env, objX),
765      enif_make_double(env, objY),
766      enif_make_double(env, objZ),
767      enif_make_double(env, objW) );
768   enif_send(NULL, self, env,
769    enif_make_tuple2(env, EGL_ATOM_REPLY, reply));
770 }
771 
772