Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(260)

Side by Side Diff: runtime/embedders/openglui/common/extension.cc

Issue 11883013: Refactored OpenGL embedder that works on Android, Mac or Linux. (Closed) Base URL: http://dart.googlecode.com/svn/branches/bleeding_edge/dart/
Patch Set: Created 7 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
2 // for details. All rights reserved. Use of this source code is governed by a
3 // BSD-style license that can be found in the LICENSE file.
4
5 #include "embedders/openglui/common/extension.h"
6
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10
11 #include "embedders/openglui/common/log.h"
12 #include "embedders/openglui/common/opengl.h"
13 #include "include/dart_api.h"
14
15 Dart_Handle HandleError(Dart_Handle handle) {
16 if (Dart_IsError(handle)) Dart_PropagateError(handle);
17 return handle;
18 }
19
20 void CheckGLError(const char *function) {
21 int error = glGetError();
22 if (error != GL_NO_ERROR) {
23 if (error == GL_INVALID_ENUM) {
24 LOGE("%s: An unacceptable value is given for an enumerated argument.",
25 function);
26 } else if (error == GL_INVALID_VALUE) {
27 LOGE("%s: A numeric argument is out of range.", function);
28 } else if (error == GL_INVALID_OPERATION) {
29 LOGE("%s: The specified operation is not allowed in the current state.",
30 function);
31 } else if (error == GL_INVALID_FRAMEBUFFER_OPERATION) {
32 LOGE("%s: The framebuffer object is not complete.", function);
33 } else if (error == GL_OUT_OF_MEMORY) {
34 LOGE("%s: There is not enough memory left to execute the command.",
35 function);
36 } else {
37 LOGE("ERROR!: %s returns %d", function, error);
38 }
39 }
40 }
41
42 const char* GetArgAsString(Dart_NativeArguments arguments, int idx) {
43 Dart_Handle whatHandle = HandleError(Dart_GetNativeArgument(arguments, idx));
44 uint8_t* str;
45 intptr_t length;
46 HandleError(Dart_StringLength(whatHandle, &length));
47 HandleError(Dart_StringToUTF8(whatHandle, &str, &length));
48 str[length] = 0;
49 return const_cast<const char*>(reinterpret_cast<char*>(str));
50 }
51
52 double GetArgAsDouble(Dart_NativeArguments arguments, int index) {
53 Dart_Handle handle = HandleError(Dart_GetNativeArgument(arguments, index));
54 if (Dart_IsDouble(handle)) {
55 double v;
56 HandleError(Dart_DoubleValue(handle, &v));
57 return v;
58 }
59 if (Dart_IsInteger(handle)) {
60 int64_t v;
61 HandleError(Dart_IntegerToInt64(handle, &v));
62 return static_cast<double>(v);
63 }
64 LOGE("Argument at index %d has non-numeric type", index);
65 Dart_ThrowException(Dart_NewStringFromCString("Numeric argument expected."));
66 return 0;
67 }
68
69 int64_t GetArgAsInt(Dart_NativeArguments arguments, int index) {
70 Dart_Handle handle = HandleError(Dart_GetNativeArgument(arguments, index));
71 if (Dart_IsDouble(handle)) {
72 double v;
73 HandleError(Dart_DoubleValue(handle, &v));
74 return static_cast<int64_t>(v);
75 }
76 if (Dart_IsInteger(handle)) {
77 int64_t v;
78 HandleError(Dart_IntegerToInt64(handle, &v));
79 return v;
80 }
81 LOGE("Argument at index %d has non-numeric type", index);
82 Dart_ThrowException(Dart_NewStringFromCString("Numeric argument expected."));
83 return 0;
84 }
85
86 bool GetArgAsBool(Dart_NativeArguments arguments, int index) {
87 Dart_Handle handle = HandleError(Dart_GetNativeArgument(arguments, index));
88 if (Dart_IsBoolean(handle)) {
89 bool v;
90 HandleError(Dart_BooleanValue(handle, &v));
91 return v;
92 }
93 LOGI("Argument at index %d has non-Boolean type", index);
94 Dart_ThrowException(Dart_NewStringFromCString("Boolean argument expected."));
95 return false;
96 }
97
98 GLint* GetArgsAsGLintList(Dart_NativeArguments arguments, int index,
99 int* len_out) {
100 Dart_Handle argHandle = HandleError(Dart_GetNativeArgument(arguments, index));
101 if (Dart_IsList(argHandle)) {
102 intptr_t len;
103 HandleError(Dart_ListLength(argHandle, &len));
104 GLint* list = new GLint[len];
105 for (int i = 0; i < len; i++) {
106 Dart_Handle vHandle = Dart_ListGetAt(argHandle, i);
107 int64_t v;
108 HandleError(Dart_IntegerToInt64(vHandle, &v));
109 list[i] = v;
110 }
111 *len_out = len;
112 return list;
113 }
114 LOGI("Argument at index %d has non-List type", index);
115 Dart_ThrowException(Dart_NewStringFromCString("List argument expected."));
116 return NULL;
117 }
118
119 GLfloat* GetArgsAsFloatList(Dart_NativeArguments arguments, int index,
120 int* len_out) {
121 Dart_Handle locationHandle =
122 HandleError(Dart_GetNativeArgument(arguments, 0));
123 int64_t location;
124 HandleError(Dart_IntegerToInt64(locationHandle, &location));
125
126 Dart_Handle argHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
127
128 if (Dart_IsList(argHandle)) {
129 intptr_t len;
130 HandleError(Dart_ListLength(argHandle, &len));
131 GLfloat* list = new GLfloat[len];
132 for (int i = 0; i < len; i++) {
133 Dart_Handle vHandle = Dart_ListGetAt(argHandle, i);
134 double v;
135 HandleError(Dart_DoubleValue(vHandle, &v));
136 list[i] = v;
137 }
138 *len_out = len;
139 return list;
140 }
141 LOGI("Argument at index %d has non-List type", index);
142 Dart_ThrowException(Dart_NewStringFromCString("List argument expected."));
143 return NULL;
144 }
145
146 void SetBoolReturnValue(Dart_NativeArguments arguments, bool b) {
147 Dart_Handle result = HandleError(Dart_NewBoolean(b));
148 Dart_SetReturnValue(arguments, result);
149 }
150
151 void SetIntReturnValue(Dart_NativeArguments arguments, int v) {
152 Dart_Handle result = HandleError(Dart_NewInteger(v));
153 Dart_SetReturnValue(arguments, result);
154 }
155
156 void SetStringReturnValue(Dart_NativeArguments arguments, const char* s) {
157 Dart_Handle result = HandleError(Dart_NewStringFromCString(s));
158 Dart_SetReturnValue(arguments, result);
159 }
160
161 void Log(Dart_NativeArguments arguments) {
162 Dart_EnterScope();
163 LOGI("%s", GetArgAsString(arguments, 0));
164 Dart_ExitScope();
165 }
166
167 void LogError(Dart_NativeArguments arguments) {
168 Dart_EnterScope();
169 LOGE("%s", GetArgAsString(arguments, 0));
170 Dart_ExitScope();
171 }
172
173 void SystemRand(Dart_NativeArguments arguments) {
174 Dart_EnterScope();
175 SetIntReturnValue(arguments, rand());
176 Dart_ExitScope();
177 }
178
179 void SystemSrand(Dart_NativeArguments arguments) {
180 Dart_EnterScope();
181 bool success = false;
182 Dart_Handle seed_object = HandleError(Dart_GetNativeArgument(arguments, 0));
183 if (Dart_IsInteger(seed_object)) {
184 bool fits;
185 HandleError(Dart_IntegerFitsIntoInt64(seed_object, &fits));
186 if (fits) {
187 int64_t seed;
188 HandleError(Dart_IntegerToInt64(seed_object, &seed));
189 srand(static_cast<unsigned>(seed));
190 success = true;
191 }
192 }
193 SetBoolReturnValue(arguments, success);
194 Dart_ExitScope();
195 }
196
197 void SwapBuffers(Dart_NativeArguments arguments) {
198 LOGI("SwapBuffers");
199 Dart_EnterScope();
200 GLSwapBuffers();
201 CheckGLError("GLSwapBuffers");
202 Dart_ExitScope();
203 }
204
205 void GLAttachShader(Dart_NativeArguments arguments) {
206 LOGI("GLAttachShader");
207 Dart_EnterScope();
208
209 int64_t program = GetArgAsInt(arguments, 0);
210 int64_t shader = GetArgAsInt(arguments, 1);
211
212 glAttachShader(program, shader);
213 CheckGLError("glAttachShader");
214 Dart_ExitScope();
215 }
216
217 void GLBindBuffer(Dart_NativeArguments arguments) {
218 LOGI("GLBindBuffer");
219 Dart_EnterScope();
220
221 int64_t target = GetArgAsInt(arguments, 0);
222 int64_t buffer = GetArgAsInt(arguments, 1);
223
224 glBindBuffer(target, buffer);
225 CheckGLError("glBindBuffer");
226 Dart_ExitScope();
227 }
228
229 void GLBufferData(Dart_NativeArguments arguments) {
230 LOGI("GLBufferData");
231 Dart_EnterScope();
232
233 int64_t target = GetArgAsInt(arguments, 0);
234
235 Dart_Handle dataHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
236 intptr_t size;
237 HandleError(Dart_ListLength(dataHandle, &size));
238
239 LOGI("Size: %d", static_cast<int>(size));
240
241 // TODO(vsm): No guarantee that this is a float!
242 float* data = new float[size];
243 for (int i = 0; i < size; i++) {
244 Dart_Handle elemHandle = HandleError(Dart_ListGetAt(dataHandle, i));
245 double value;
246 Dart_DoubleValue(elemHandle, &value);
247 data[i] = static_cast<float>(value);
248 LOGI("Value[%d]: %f", i, data[i]);
249 }
250
251 Dart_Handle usageHandle = HandleError(Dart_GetNativeArgument(arguments, 2));
252 int64_t usage;
253 HandleError(Dart_IntegerToInt64(usageHandle, &usage));
254
255 glBufferData(target, size * sizeof(data[0]), data, usage);
256 CheckGLError("glBufferData");
257 delete[] data;
258 Dart_ExitScope();
259 }
260
261 void GLCompileShader(Dart_NativeArguments arguments) {
262 LOGI("GLCompileShader");
263 Dart_EnterScope();
264 int64_t shader = GetArgAsInt(arguments, 0);
265 glCompileShader(shader);
266 CheckGLError("glCompileShader");
267 Dart_ExitScope();
268 }
269
270 void GLCreateBuffer(Dart_NativeArguments arguments) {
271 LOGI("GLCreateBuffer");
272 Dart_EnterScope();
273 GLuint buffer;
274 glGenBuffers(1, &buffer);
275 CheckGLError("glGenBuffers");
276 SetIntReturnValue(arguments, buffer);
277 Dart_ExitScope();
278 }
279
280 void GLCreateProgram(Dart_NativeArguments arguments) {
281 LOGI("GLCreateProgram");
282 Dart_EnterScope();
283 int64_t program = glCreateProgram();
284 CheckGLError("glCreateProgram");
285 SetIntReturnValue(arguments, program);
286 Dart_ExitScope();
287 }
288
289 void GLCreateShader(Dart_NativeArguments arguments) {
290 LOGI("GLCreateShader");
291 Dart_EnterScope();
292 int64_t type = GetArgAsInt(arguments, 0);
293 int64_t shader = glCreateShader((GLenum)type);
294 CheckGLError("glCreateShader");
295 SetIntReturnValue(arguments, shader);
296 Dart_ExitScope();
297 }
298
299 void GLDrawArrays(Dart_NativeArguments arguments) {
300 LOGI("GLDrawArrays");
301 Dart_EnterScope();
302
303 int64_t mode = GetArgAsInt(arguments, 0);
304 int64_t first = GetArgAsInt(arguments, 1);
305 int64_t count = GetArgAsInt(arguments, 2);
306
307 glDrawArrays(mode, first, count);
308 CheckGLError("glDrawArrays");
309 Dart_ExitScope();
310 LOGI("Done GLDrawArrays");
311 }
312
313 void GLEnableVertexAttribArray(Dart_NativeArguments arguments) {
314 LOGI("GLEnableVertexAttribArray");
315 Dart_EnterScope();
316
317 int64_t location = GetArgAsInt(arguments, 0);
318
319 glEnableVertexAttribArray(location);
320 CheckGLError("glEnableVertexAttribArray");
321 Dart_ExitScope();
322 }
323
324 void GLGetAttribLocation(Dart_NativeArguments arguments) {
325 LOGI("GLGetAttribLocation");
326 Dart_EnterScope();
327
328 int64_t program = GetArgAsInt(arguments, 0);
329
330 Dart_Handle nameHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
331 intptr_t length;
332 HandleError(Dart_StringLength(nameHandle, &length));
333 uint8_t* str;
334 HandleError(Dart_StringToUTF8(nameHandle, &str, &length));
335 str[length] = 0;
336
337 int64_t location = glGetAttribLocation(program,
338 const_cast<const GLchar*>(reinterpret_cast<GLchar*>(str)));
339 CheckGLError("glGetAttribLocation");
340 SetIntReturnValue(arguments, location);
341 Dart_ExitScope();
342 }
343
344 void GLGetError(Dart_NativeArguments arguments) {
345 LOGI("GLGetError");
346 Dart_EnterScope();
347 SetIntReturnValue(arguments, glGetError());
348 Dart_ExitScope();
349 }
350
351 void GLGetProgramParameter(Dart_NativeArguments arguments) {
352 LOGI("GLGetProgramParameter");
353 Dart_EnterScope();
354
355 int64_t program = GetArgAsInt(arguments, 0);
356 int64_t param = GetArgAsInt(arguments, 1);
357
358 GLint value = -1;
359 glGetProgramiv(program, param, &value);
360 CheckGLError("glGetProgramiv");
361
362 SetIntReturnValue(arguments, value);
363 Dart_ExitScope();
364 }
365
366 void GLGetShaderParameter(Dart_NativeArguments arguments) {
367 LOGI("GLGetShaderParameter");
368 Dart_EnterScope();
369
370 int64_t shader = GetArgAsInt(arguments, 0);
371 int64_t param = GetArgAsInt(arguments, 1);
372
373 GLint value = -1;
374 glGetShaderiv((GLuint)shader, (GLenum)param, &value);
375 CheckGLError("glGetShaderiv");
376
377 SetIntReturnValue(arguments, value);
378 Dart_ExitScope();
379 }
380
381 void GLGetShaderInfoLog(Dart_NativeArguments arguments) {
382 LOGI("GLGetShaderInfoLog");
383 Dart_EnterScope();
384
385 int64_t shader = GetArgAsInt(arguments, 0);
386
387 GLint infoLogLength = 0;
388 glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);
389
390 GLchar* strInfoLog = new GLchar[infoLogLength + 1];
391 glGetShaderInfoLog(shader, infoLogLength, NULL, strInfoLog);
392 strInfoLog[infoLogLength] = 0;
393
394 SetStringReturnValue(arguments, strInfoLog);
395 Dart_ExitScope();
396 delete[] strInfoLog;
397 }
398
399 void GLGetProgramInfoLog(Dart_NativeArguments arguments) {
400 LOGI("GLGetProgramInfoLog");
401 Dart_EnterScope();
402
403 int64_t program = GetArgAsInt(arguments, 0);
404
405 GLint infoLogLength;
406 glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);
407
408 GLchar* strInfoLog = new GLchar[infoLogLength + 1];
409 glGetProgramInfoLog(program, infoLogLength, NULL, strInfoLog);
410 strInfoLog[infoLogLength] = 0;
411
412 SetStringReturnValue(arguments, strInfoLog);
413 Dart_ExitScope();
414 delete[] strInfoLog;
415 }
416
417 void GLGetUniformLocation(Dart_NativeArguments arguments) {
418 LOGI("GLGetUniformLocation");
419 Dart_EnterScope();
420
421 int64_t program = GetArgAsInt(arguments, 0);
422
423
424 Dart_Handle nameHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
425 intptr_t length;
426 HandleError(Dart_StringLength(nameHandle, &length));
427 uint8_t* str;
428 HandleError(Dart_StringToUTF8(nameHandle, &str, &length));
429 str[length] = 0;
430
431 int64_t location = glGetUniformLocation(program,
432 const_cast<const GLchar*>(reinterpret_cast<GLchar*>(str)));
433 CheckGLError("glGetUniformLocation");
434 SetIntReturnValue(arguments, location);
435 Dart_ExitScope();
436 }
437
438 void GLLinkProgram(Dart_NativeArguments arguments) {
439 LOGI("GLLinkProgram");
440 Dart_EnterScope();
441 int64_t program = GetArgAsInt(arguments, 0);
442 glLinkProgram(program);
443 CheckGLError("glLinkProgram");
444 Dart_ExitScope();
445 }
446
447 void GLShaderSource(Dart_NativeArguments arguments) {
448 LOGI("GLShaderSource");
449 Dart_EnterScope();
450
451 int64_t shader = GetArgAsInt(arguments, 0);
452
453 Dart_Handle sourceHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
454 intptr_t length[1];
455 HandleError(Dart_StringLength(sourceHandle, length));
456 LOGI("Source length is %d", static_cast<int>(length[0]));
457 uint8_t* str[1];
458 HandleError(Dart_StringToUTF8(sourceHandle, &str[0], length));
459 LOGI("Converted length is %d", static_cast<int>(length[0]));
460 str[0][*length] = 0;
461
462 const GLchar* source =
463 const_cast<const GLchar*>(reinterpret_cast<GLchar*>(str[0]));
464 LOGI("Source: %s", source);
465 glShaderSource(shader, 1,
466 const_cast<const GLchar**>(reinterpret_cast<GLchar**>(str)), NULL);
467 CheckGLError("glShaderSource");
468 Dart_ExitScope();
469 }
470
471 void GLUseProgram(Dart_NativeArguments arguments) {
472 LOGI("GLUseProgram");
473 Dart_EnterScope();
474 int64_t program = GetArgAsInt(arguments, 0);
475 glUseProgram(program);
476 CheckGLError("glUseProgram");
477 Dart_ExitScope();
478 }
479
480 void GLUniform1i(Dart_NativeArguments arguments) {
481 LOGI("GLUniform1i");
482 Dart_EnterScope();
483 int64_t location = GetArgAsInt(arguments, 0);
484 int64_t v0 = GetArgAsInt(arguments, 1);
485 glUniform1i(location, v0);
486 CheckGLError("glUniform1i");
487 Dart_ExitScope();
488 }
489
490 void GLUniform2i(Dart_NativeArguments arguments) {
491 LOGI("GLUniform2i");
492 Dart_EnterScope();
493 int64_t location = GetArgAsInt(arguments, 0);
494 int64_t v0 = GetArgAsInt(arguments, 1);
495 int64_t v1 = GetArgAsInt(arguments, 2);
496 glUniform2i(location, v0, v1);
497 CheckGLError("glUniform2i");
498 Dart_ExitScope();
499 }
500
501 void GLUniform3i(Dart_NativeArguments arguments) {
502 LOGI("GLUniform3i");
503 Dart_EnterScope();
504 int64_t location = GetArgAsInt(arguments, 0);
505 int64_t v0 = GetArgAsInt(arguments, 1);
506 int64_t v1 = GetArgAsInt(arguments, 2);
507 int64_t v2 = GetArgAsInt(arguments, 3);
508 glUniform3i(location, v0, v1, v2);
509 CheckGLError("glUniform3i");
510 Dart_ExitScope();
511 }
512
513 void GLUniform4i(Dart_NativeArguments arguments) {
514 LOGI("GLUniform4i");
515 Dart_EnterScope();
516 int64_t location = GetArgAsInt(arguments, 0);
517 int64_t v0 = GetArgAsInt(arguments, 1);
518 int64_t v1 = GetArgAsInt(arguments, 2);
519 int64_t v2 = GetArgAsInt(arguments, 3);
520 int64_t v3 = GetArgAsInt(arguments, 4);
521 glUniform4i(location, v0, v1, v2, v3);
522 CheckGLError("glUniform4i");
523 Dart_ExitScope();
524 }
525
526 void GLUniform1f(Dart_NativeArguments arguments) {
527 LOGI("GLUniform1f");
528 Dart_EnterScope();
529 int64_t location = GetArgAsInt(arguments, 0);
530 double v0 = GetArgAsDouble(arguments, 1);
531 glUniform1f(location, v0);
532 CheckGLError("glUniform1f");
533 Dart_ExitScope();
534 }
535
536 void GLUniform2f(Dart_NativeArguments arguments) {
537 LOGI("GLUniform2f");
538 Dart_EnterScope();
539 int64_t location = GetArgAsInt(arguments, 0);
540 double v0 = GetArgAsDouble(arguments, 1);
541 double v1 = GetArgAsDouble(arguments, 2);
542 glUniform2f(location, v0, v1);
543 CheckGLError("glUniform2f");
544 Dart_ExitScope();
545 }
546
547 void GLUniform3f(Dart_NativeArguments arguments) {
548 LOGI("GLUniform3f");
549 Dart_EnterScope();
550 int64_t location = GetArgAsInt(arguments, 0);
551 double v0 = GetArgAsDouble(arguments, 1);
552 double v1 = GetArgAsDouble(arguments, 2);
553 double v2 = GetArgAsDouble(arguments, 3);
554 glUniform3f(location, v0, v1, v2);
555 CheckGLError("glUniform3f");
556 Dart_ExitScope();
557 }
558
559 void GLUniform4f(Dart_NativeArguments arguments) {
560 LOGI("GLUniform4f");
561 Dart_EnterScope();
562 int64_t location = GetArgAsInt(arguments, 0);
563 double v0 = GetArgAsDouble(arguments, 1);
564 double v1 = GetArgAsDouble(arguments, 2);
565 double v2 = GetArgAsDouble(arguments, 3);
566 double v3 = GetArgAsDouble(arguments, 4);
567 glUniform4f(location, v0, v1, v2, v3);
568 CheckGLError("glUniform4f");
569 Dart_ExitScope();
570 }
571
572 void GLUniform1iv(Dart_NativeArguments arguments) {
573 LOGI("GLUniform1iv");
574 Dart_EnterScope();
575 int64_t location = GetArgAsInt(arguments, 0);
576 int len;
577 GLint* list = GetArgsAsGLintList(arguments, 1, &len);
578 if (list != NULL) {
579 glUniform1iv(location, len, list);
580 delete [] list;
581 CheckGLError("glUniform1iv");
582 }
583 Dart_ExitScope();
584 }
585
586 void GLUniform2iv(Dart_NativeArguments arguments) {
587 LOGI("GLUniform2iv");
588 Dart_EnterScope();
589 int64_t location = GetArgAsInt(arguments, 0);
590 int len;
591 GLint* list = GetArgsAsGLintList(arguments, 1, &len);
592 if (list != NULL) {
593 glUniform2iv(location, len / 2, list);
594 delete [] list;
595 CheckGLError("glUniform2iv");
596 }
597 Dart_ExitScope();
598 }
599
600 void GLUniform3iv(Dart_NativeArguments arguments) {
601 LOGI("GLUniform3iv");
602 Dart_EnterScope();
603 int64_t location = GetArgAsInt(arguments, 0);
604 int len;
605 GLint* list = GetArgsAsGLintList(arguments, 1, &len);
606 if (list != NULL) {
607 glUniform3iv(location, len / 3, list);
608 delete [] list;
609 CheckGLError("glUniform3iv");
610 }
611 Dart_ExitScope();
612 }
613
614 void GLUniform4iv(Dart_NativeArguments arguments) {
615 LOGI("GLUniform4iv");
616 Dart_EnterScope();
617 int64_t location = GetArgAsInt(arguments, 0);
618 int len;
619 GLint* list = GetArgsAsGLintList(arguments, 1, &len);
620 if (list != NULL) {
621 glUniform1iv(location, len / 4, list);
622 delete [] list;
623 CheckGLError("glUniform4iv");
624 }
625 Dart_ExitScope();
626 }
627
628 void GLUniform1fv(Dart_NativeArguments arguments) {
629 LOGI("GLUniform1fv");
630 Dart_EnterScope();
631 int64_t location = GetArgAsInt(arguments, 0);
632 int len;
633 GLfloat* list = GetArgsAsFloatList(arguments, 1, &len);
634 if (list != NULL) {
635 glUniform1fv(location, len, list);
636 delete [] list;
637 CheckGLError("glUniform1fv");
638 }
639 Dart_ExitScope();
640 }
641
642 void GLUniform2fv(Dart_NativeArguments arguments) {
643 LOGI("GLUniform2fv");
644 Dart_EnterScope();
645 int64_t location = GetArgAsInt(arguments, 0);
646 int len;
647 GLfloat* list = GetArgsAsFloatList(arguments, 1, &len);
648 if (list != NULL) {
649 glUniform2fv(location, len / 2, list);
650 delete [] list;
651 CheckGLError("glUniform2fv");
652 }
653 Dart_ExitScope();
654 }
655
656 void GLUniform3fv(Dart_NativeArguments arguments) {
657 LOGI("GLUniform3fv");
658 Dart_EnterScope();
659 int64_t location = GetArgAsInt(arguments, 0);
660 int len;
661 GLfloat* list = GetArgsAsFloatList(arguments, 1, &len);
662 if (list != NULL) {
663 glUniform3fv(location, len / 3, list);
664 delete [] list;
665 CheckGLError("glUniform3fv");
666 }
667 Dart_ExitScope();
668 }
669
670 void GLUniform4fv(Dart_NativeArguments arguments) {
671 LOGI("In GLUniform4fv");
672 Dart_EnterScope();
673 int64_t location = GetArgAsInt(arguments, 0);
674 int len;
675 GLfloat* list = GetArgsAsFloatList(arguments, 1, &len);
676 if (list != NULL) {
677 glUniform4fv(location, len / 4, list);
678 delete [] list;
679 CheckGLError("glUniform4fv");
680 }
681 Dart_ExitScope();
682 }
683
684 void GLViewport(Dart_NativeArguments arguments) {
685 LOGI("GLViewport");
686 Dart_EnterScope();
687 int64_t x = GetArgAsInt(arguments, 0);
688 int64_t y = GetArgAsInt(arguments, 1);
689 int64_t width = GetArgAsInt(arguments, 2);
690 int64_t height = GetArgAsInt(arguments, 3);
691 glViewport(x, y, width, height);
692 CheckGLError("glViewPort");
693 Dart_ExitScope();
694 }
695
696 void GLVertexAttribPointer(Dart_NativeArguments arguments) {
697 LOGI("GLVertexAttribPointer");
698 Dart_EnterScope();
699 int64_t index = GetArgAsInt(arguments, 0);
700 int64_t size = GetArgAsInt(arguments, 1);
701 int64_t type = GetArgAsInt(arguments, 2);
702 bool normalized = GetArgAsBool(arguments, 3);
703 int64_t stride = GetArgAsInt(arguments, 4);
704
705 Dart_Handle pointerHandle = HandleError(Dart_GetNativeArgument(arguments, 5));
706 int64_t pointerValue;
707 HandleError(Dart_IntegerToInt64(pointerHandle, &pointerValue));
708 const void* pointer;
709 pointer = const_cast<const void*>(reinterpret_cast<void*>(pointerValue));
710
711 glVertexAttribPointer(index, size, type, normalized, stride, pointer);
712 CheckGLError("glVertexAttribPointer");
713 Dart_ExitScope();
714 }
715
716 void GLClearColor(Dart_NativeArguments arguments) {
717 LOGI("GLClearColor");
718 Dart_EnterScope();
719 double red = GetArgAsDouble(arguments, 0);
720 double green = GetArgAsDouble(arguments, 1);
721 double blue = GetArgAsDouble(arguments, 2);
722 double alpha = GetArgAsDouble(arguments, 3);
723 glClearColor(red, green, blue, alpha);
724 CheckGLError("glClearColor");
725 Dart_ExitScope();
726 }
727
728 void GLClearDepth(Dart_NativeArguments arguments) {
729 LOGI("GLClearDepth");
730 Dart_EnterScope();
731 double depth = GetArgAsDouble(arguments, 0);
732 #if defined(__ANDROID__)
733 glClearDepthf(depth);
734 #else
735 glClearDepth(depth);
736 #endif
737 CheckGLError("glClearDepth");
738 Dart_ExitScope();
739 }
740
741 void GLClear(Dart_NativeArguments arguments) {
742 LOGI("GLClear");
743 Dart_EnterScope();
744 Dart_Handle maskHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
745 int64_t mask;
746 HandleError(Dart_IntegerToInt64(maskHandle, &mask));
747 glClear(mask);
748 CheckGLError("glClear");
749 Dart_ExitScope();
750 }
751
752 void ReturnGLIntConstant(Dart_NativeArguments arguments, int c) {
753 Dart_EnterScope();
754 SetIntReturnValue(arguments, c);
755 Dart_ExitScope();
756 }
757
758 void GLArrayBuffer(Dart_NativeArguments arguments) {
759 ReturnGLIntConstant(arguments, GL_ARRAY_BUFFER);
760 }
761
762 void GLColorBufferBit(Dart_NativeArguments arguments) {
763 ReturnGLIntConstant(arguments, GL_COLOR_BUFFER_BIT);
764 }
765
766 void GLCompileStatus(Dart_NativeArguments arguments) {
767 ReturnGLIntConstant(arguments, GL_COMPILE_STATUS);
768 }
769
770 void GLDepthBufferBit(Dart_NativeArguments arguments) {
771 ReturnGLIntConstant(arguments, GL_DEPTH_BUFFER_BIT);
772 }
773
774 void GLFloat(Dart_NativeArguments arguments) {
775 ReturnGLIntConstant(arguments, GL_FLOAT);
776 }
777
778 void GLFragmentShader(Dart_NativeArguments arguments) {
779 ReturnGLIntConstant(arguments, GL_FRAGMENT_SHADER);
780 }
781
782 void GLLinkStatus(Dart_NativeArguments arguments) {
783 ReturnGLIntConstant(arguments, GL_LINK_STATUS);
784 }
785
786 void GLStaticDraw(Dart_NativeArguments arguments) {
787 ReturnGLIntConstant(arguments, GL_STATIC_DRAW);
788 }
789
790 void GLTriangleStrip(Dart_NativeArguments arguments) {
791 ReturnGLIntConstant(arguments, GL_TRIANGLE_STRIP);
792 }
793
794 void GLTriangles(Dart_NativeArguments arguments) {
795 ReturnGLIntConstant(arguments, GL_TRIANGLES);
796 }
797
798 void GLTrue(Dart_NativeArguments arguments) {
799 ReturnGLIntConstant(arguments, GL_TRUE);
800 }
801
802 void GLVertexShader(Dart_NativeArguments arguments) {
803 ReturnGLIntConstant(arguments, GL_VERTEX_SHADER);
804 }
805
806 uint8_t* RandomArray(int seed, int length) {
807 if (length <= 0 || length > 10000000) return NULL;
808 uint8_t* values = reinterpret_cast<uint8_t*>(malloc(length));
809 if (NULL == values) return NULL;
810 srand(seed);
811 for (int i = 0; i < length; ++i) {
812 values[i] = rand() % 256;
813 }
814 return values;
815 }
816
817 void WrappedRandomArray(Dart_Port dest_port_id,
818 Dart_Port reply_port_id,
819 Dart_CObject* message) {
820 if (message->type == Dart_CObject::kArray &&
821 2 == message->value.as_array.length) {
822 // Use .as_array and .as_int32 to access the data in the Dart_CObject.
823 Dart_CObject* param0 = message->value.as_array.values[0];
824 Dart_CObject* param1 = message->value.as_array.values[1];
825 if (param0->type == Dart_CObject::kInt32 &&
826 param1->type == Dart_CObject::kInt32) {
827 int length = param0->value.as_int32;
828 int seed = param1->value.as_int32;
829
830 uint8_t* values = RandomArray(seed, length);
831
832 if (values != NULL) {
833 Dart_CObject result;
834 result.type = Dart_CObject::kUint8Array;
835 result.value.as_byte_array.values = values;
836 result.value.as_byte_array.length = length;
837 Dart_PostCObject(reply_port_id, &result);
838 free(values);
839 // It is OK that result is destroyed when function exits.
840 // Dart_PostCObject has copied its data.
841 return;
842 }
843 }
844 }
845 Dart_CObject result;
846 result.type = Dart_CObject::kNull;
847 Dart_PostCObject(reply_port_id, &result);
848 }
849
850 void RandomArrayServicePort(Dart_NativeArguments arguments) {
851 Dart_EnterScope();
852 Dart_SetReturnValue(arguments, Dart_Null());
853 Dart_Port service_port =
854 Dart_NewNativePort("RandomArrayService", WrappedRandomArray, true);
855 if (service_port != ((Dart_Port)0)) {
856 Dart_Handle send_port = HandleError(Dart_NewSendPort(service_port));
857 Dart_SetReturnValue(arguments, send_port);
858 }
859 Dart_ExitScope();
860 }
861
862 void PlayBackground(Dart_NativeArguments arguments) {
863 LOGI("PlayBackground");
864 Dart_EnterScope();
865 const char* what = GetArgAsString(arguments, 0);
866 int rtn = PlayBackgroundSound(what);
867 SetIntReturnValue(arguments, rtn);
868 Dart_ExitScope();
869 }
870
871 void StopBackground(Dart_NativeArguments arguments) {
872 LOGI("StopBackground");
873 Dart_EnterScope();
874 StopBackgroundSound();
875 Dart_ExitScope();
876 }
877
878 void LoadSample(Dart_NativeArguments arguments) {
879 LOGI("LoadSample");
880 Dart_EnterScope();
881 const char* what = GetArgAsString(arguments, 0);
882 int rtn = LoadSoundSample(what);
883 SetIntReturnValue(arguments, rtn);
884 Dart_ExitScope();
885 }
886
887 void PlaySample(Dart_NativeArguments arguments) {
888 LOGI("PlaySample");
889 Dart_EnterScope();
890 const char* what = GetArgAsString(arguments, 0);
891 int rtn = PlaySoundSample(what);
892 SetIntReturnValue(arguments, rtn);
893 Dart_ExitScope();
894 }
895
896 struct FunctionLookup {
897 const char* name;
898 Dart_NativeFunction function;
899 };
900
901 FunctionLookup function_list[] = {
902 {"Log", Log},
903 {"LogError", LogError},
904 {"SystemRand", SystemRand},
905 {"SystemSrand", SystemSrand},
906 {"SwapBuffers", SwapBuffers},
907 {"GLAttachShader", GLAttachShader},
908 {"GLBindBuffer", GLBindBuffer},
909 {"GLBufferData", GLBufferData},
910 {"GLClear", GLClear},
911 {"GLClearColor", GLClearColor},
912 {"GLClearDepth", GLClearDepth},
913 {"GLCompileShader", GLCompileShader},
914 {"GLCreateBuffer", GLCreateBuffer},
915 {"GLCreateProgram", GLCreateProgram},
916 {"GLCreateShader", GLCreateShader},
917 {"GLDrawArrays", GLDrawArrays},
918 {"GLEnableVertexAttribArray", GLEnableVertexAttribArray},
919 {"GLGetAttribLocation", GLGetAttribLocation},
920 {"GLGetError", GLGetError},
921 {"GLGetProgramParameter", GLGetProgramParameter},
922 {"GLGetShaderParameter", GLGetShaderParameter},
923 {"GLGetUniformLocation", GLGetUniformLocation},
924 {"GLLinkProgram", GLLinkProgram},
925 {"GLShaderSource", GLShaderSource},
926 {"GLUniform1f", GLUniform1f},
927 {"GLUniform2f", GLUniform2f},
928 {"GLUniform3f", GLUniform3f},
929 {"GLUniform4f", GLUniform4f},
930 {"GLUniform1i", GLUniform1i},
931 {"GLUniform2i", GLUniform2i},
932 {"GLUniform3i", GLUniform3i},
933 {"GLUniform4i", GLUniform4i},
934 {"GLUniform1fv", GLUniform1fv},
935 {"GLUniform2fv", GLUniform2fv},
936 {"GLUniform3fv", GLUniform3fv},
937 {"GLUniform4fv", GLUniform4fv},
938 {"GLUniform1iv", GLUniform1iv},
939 {"GLUniform2iv", GLUniform2iv},
940 {"GLUniform3iv", GLUniform3iv},
941 {"GLUniform4iv", GLUniform4iv},
942 {"GLUseProgram", GLUseProgram},
943 {"GLVertexAttribPointer", GLVertexAttribPointer},
944 {"GLViewport", GLViewport},
945 {"GLArrayBuffer", GLArrayBuffer},
946 {"GLColorBufferBit", GLColorBufferBit},
947 {"GLCompileStatus", GLCompileStatus},
948 {"GLDepthBufferBit", GLDepthBufferBit},
949 {"GLFloat", GLFloat},
950 {"GLFragmentShader", GLFragmentShader},
951 {"GLLinkStatus", GLLinkStatus},
952 {"GLTriangleStrip", GLTriangleStrip},
953 {"GLTriangles", GLTriangles},
954 {"GLTrue", GLTrue},
955 {"GLStaticDraw", GLStaticDraw},
956 {"GLVertexShader", GLVertexShader},
957 {"GLGetShaderInfoLog", GLGetShaderInfoLog},
958 {"GLGetProgramInfoLog", GLGetProgramInfoLog},
959 {"RandomArray_ServicePort", RandomArrayServicePort},
960
961 // Audio support.
962 {"PlayBackground", PlayBackground},
963 {"StopBackground", StopBackground},
964 {"LoadSample", LoadSample},
965 {"PlaySample", PlaySample},
966
967 {NULL, NULL}};
968
969 Dart_NativeFunction ResolveName(Dart_Handle name, int argc) {
970 if (!Dart_IsString(name)) return NULL;
971 Dart_NativeFunction result = NULL;
972 Dart_EnterScope();
973 const char* cname;
974 HandleError(Dart_StringToCString(name, &cname));
975 for (int i = 0; function_list[i].name != NULL; ++i) {
976 if (strcmp(function_list[i].name, cname) == 0) {
977 result = function_list[i].function;
978 break;
979 }
980 }
981 Dart_ExitScope();
982 return result;
983 }
984
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698