Android rayshader sample.

samples/android_sample/jni/android_extension.cc

+// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+#include <jni.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <EGL/egl.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+#include <android/log.h>
+
+#include "include/dart_api.h"
+#include "bin/log.h"
+
+Dart_NativeFunction ResolveName(Dart_Handle name, int argc);
+
+DART_EXPORT Dart_Handle android_extension_Init(Dart_Handle parent_library) {
+  if (Dart_IsError(parent_library)) { return parent_library; }
+
+  Dart_Handle result_code = Dart_SetNativeResolver(parent_library, ResolveName);
+  if (Dart_IsError(result_code)) return result_code;
+
+  return Dart_Null();
+}
+
+Dart_Handle HandleError(Dart_Handle handle) {
+  if (Dart_IsError(handle)) Dart_PropagateError(handle);
+  return handle;
+}
+
+void CheckGLError(const char *function) {
+  int error = glGetError();
+  if (error != GL_NO_ERROR) {
+    int x = 0;
+    int y = *(int*)x;

[vsm, 2012/11/30 18:38:31]

You can get rid of this.  I used this to force a stack trace on any error before
you added logging.  :-)

[gram, 2012/11/30 22:09:22]

Done.

+    Log::PrintErr("ERROR!: %s returns %d", function, y);
+  }
+}
+
+void Log(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+  Dart_Handle whatHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  intptr_t length[1];
+  HandleError(Dart_StringLength(whatHandle, length));
+  uint8_t* str[1];
+  HandleError(Dart_StringToUTF8(whatHandle, &str[0], length));
+  str[0][*length] = 0;
+  Log::Print(const_cast<const GLchar*>(reinterpret_cast<GLchar*>(str[0])));
+  Dart_ExitScope();
+}
+
+void SystemRand(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+  Dart_Handle result = HandleError(Dart_NewInteger(rand()));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void SystemSrand(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+  bool success = false;
+  Dart_Handle seed_object = HandleError(Dart_GetNativeArgument(arguments, 0));
+  if (Dart_IsInteger(seed_object)) {
+    bool fits;
+    HandleError(Dart_IntegerFitsIntoInt64(seed_object, &fits));
+    if (fits) {
+      int64_t seed;
+      HandleError(Dart_IntegerToInt64(seed_object, &seed));
+      srand(static_cast<unsigned>(seed));
+      success = true;
+    }
+  }
+  Dart_SetReturnValue(arguments, HandleError(Dart_NewBoolean(success)));
+  Dart_ExitScope();
+}
+
+void EGLSwapBuffers(Dart_NativeArguments arguments) {
+  Log::Print("GLSwapBuffers");
+  Dart_EnterScope();
+
+  EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  EGLSurface surface = eglGetCurrentSurface(EGL_DRAW);
+  eglSwapBuffers(display, surface);
+
+  CheckGLError("eglSwapBuffers");
+  Dart_ExitScope();
+}
+
+void GLAttachShader(Dart_NativeArguments arguments) {
+  Log::Print("GLAttachShader");
+  Dart_EnterScope();
+
+  Dart_Handle programHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t program;
+  HandleError(Dart_IntegerToInt64(programHandle, &program));
+
+  Dart_Handle shaderHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  int64_t shader;
+  HandleError(Dart_IntegerToInt64(shaderHandle, &shader));
+
+  glAttachShader(program, shader);
+  CheckGLError("glAttachShader");
+  Dart_ExitScope();
+}
+
+void GLBindBuffer(Dart_NativeArguments arguments) {
+  Log::Print("GLBindBuffer");
+  Dart_EnterScope();
+
+  Dart_Handle targetHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t target;
+  HandleError(Dart_IntegerToInt64(targetHandle, &target));
+
+  Dart_Handle bufferHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  int64_t buffer;
+  HandleError(Dart_IntegerToInt64(bufferHandle, &buffer));
+
+  glBindBuffer(target, buffer);
+  CheckGLError("glBindBuffer");
+  Dart_ExitScope();
+}
+
+void GLBufferData(Dart_NativeArguments arguments) {
+  Log::Print("GLBufferData");
+  Dart_EnterScope();
+
+  Dart_Handle targetHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t target;
+  HandleError(Dart_IntegerToInt64(targetHandle, &target));
+
+  Dart_Handle dataHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  intptr_t size;
+  HandleError(Dart_ListLength(dataHandle, &size));
+
+  Log::Print("Size: %d", size);
+
+  // TODO(vsm): No guarantee that this is a float!
+  float* data = reinterpret_cast<float*>(malloc(size * sizeof(float)));
+  for (int i = 0; i < size; i++) {
+    Dart_Handle elemHandle = HandleError(Dart_ListGetAt(dataHandle, i));
+    double value;
+    Dart_DoubleValue(elemHandle, &value);
+    data[i] = static_cast<float>(value);
+    Log::Print("Value[%d]: %f", i, data[i]);
+  }
+
+  Dart_Handle usageHandle = HandleError(Dart_GetNativeArgument(arguments, 2));
+  int64_t usage;
+  HandleError(Dart_IntegerToInt64(usageHandle, &usage));
+
+  glBufferData(target, size * sizeof(float), data, usage);
+  CheckGLError("glBufferData");
+  free(data);
+  Dart_ExitScope();
+}
+
+void GLCompileShader(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+
+  Dart_Handle shaderHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t shader;
+  HandleError(Dart_IntegerToInt64(shaderHandle, &shader));
+
+  Log::Print("GLCompileShader(%d)", (int)shader);
+  glCompileShader(shader);
+  CheckGLError("glCompileShader");
+  Dart_ExitScope();
+}
+
+void GLCreateBuffer(Dart_NativeArguments arguments) {
+  Log::Print("GLCreateBuffer");
+  Dart_EnterScope();
+  GLuint buffer;
+
+  glGenBuffers(1, &buffer);
+  CheckGLError("glGenBuffers");
+  Dart_Handle result = HandleError(Dart_NewInteger(buffer));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLCreateProgram(Dart_NativeArguments arguments) {
+  Log::Print("GLCreateProgram");
+  Dart_EnterScope();
+
+  int64_t program = glCreateProgram();
+  CheckGLError("glCreateProgram");
+  Dart_Handle result = HandleError(Dart_NewInteger(program));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLCreateShader(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+
+  Dart_Handle typeHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t type;
+  HandleError(Dart_IntegerToInt64(typeHandle, &type));
+
+  int64_t shader = glCreateShader((GLenum)type);
+  Log::Print("GLCreateShader(%d)=>%d", (int)type, (int)shader);
+  CheckGLError("glCreateShader");
+  Dart_Handle result = HandleError(Dart_NewInteger(shader));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLDrawArrays(Dart_NativeArguments arguments) {
+  Log::Print("GLDrawArrays");
+  Dart_EnterScope();
+
+  Dart_Handle modeHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t mode;
+  HandleError(Dart_IntegerToInt64(modeHandle, &mode));
+
+  Dart_Handle firstHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  int64_t first;
+  HandleError(Dart_IntegerToInt64(firstHandle, &first));
+
+  Dart_Handle countHandle = HandleError(Dart_GetNativeArgument(arguments, 2));
+  int64_t count;
+  HandleError(Dart_IntegerToInt64(countHandle, &count));
+
+  glDrawArrays(mode, first, count);
+  CheckGLError("glDrawArrays");
+  Dart_ExitScope();
+}
+
+void GLEnableVertexAttribArray(Dart_NativeArguments arguments) {
+  Log::Print("GLEnableVertexAttribArray");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle =
+      HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  glEnableVertexAttribArray(location);
+  CheckGLError("glEnableVertexAttribArray");
+  Dart_ExitScope();
+}
+
+void GLGetAttribLocation(Dart_NativeArguments arguments) {
+  Log::Print("GLGetAttribLocation");
+  Dart_EnterScope();
+
+  Dart_Handle programHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t program;
+  HandleError(Dart_IntegerToInt64(programHandle, &program));
+
+  Dart_Handle nameHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  intptr_t length;
+  HandleError(Dart_StringLength(nameHandle, &length));
+  uint8_t* str;
+  //str = reinterpret_cast<uint8_t*>(malloc(length+1));
+  HandleError(Dart_StringToUTF8(nameHandle, &str, &length));
+  str[length] = 0;
+  
+  int64_t location = glGetAttribLocation(program,
+      const_cast<const GLchar*>(reinterpret_cast<GLchar*>(str)));
+  CheckGLError("glGetAttribLocation");
+  Dart_Handle result = HandleError(Dart_NewInteger(location));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLGetError(Dart_NativeArguments arguments) {
+  Log::Print("GLGetError");
+  Dart_EnterScope();
+
+  int64_t error = glGetError();
+  Dart_Handle result = HandleError(Dart_NewInteger(error));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLGetProgramParameter(Dart_NativeArguments arguments) {
+  Log::Print("GLGetProgramParameter");
+  Dart_EnterScope();
+
+  Dart_Handle programHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t program;
+  HandleError(Dart_IntegerToInt64(programHandle, &program));
+
+  Dart_Handle paramHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  int64_t param;
+  HandleError(Dart_IntegerToInt64(paramHandle, &param));
+
+  GLint value = -1;
+  glGetProgramiv(program, param, &value);
+  CheckGLError("glGetProgramiv");
+
+  Dart_Handle result = HandleError(Dart_NewInteger(value));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLGetShaderParameter(Dart_NativeArguments arguments) {
+  Log::Print("GLGetShaderParameter");
+  Dart_EnterScope();
+
+  Dart_Handle shaderHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t shader;
+  HandleError(Dart_IntegerToInt64(shaderHandle, &shader));
+
+  Dart_Handle paramHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  int64_t param;
+  HandleError(Dart_IntegerToInt64(paramHandle, &param));
+
+  GLint value = -1;
+  glGetShaderiv((GLuint)shader, (GLenum)param, &value);
+  CheckGLError("glGetShaderiv");
+
+  Dart_Handle result = HandleError(Dart_NewInteger(value));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLGetShaderInfoLog(Dart_NativeArguments arguments) {
+  Log::Print("GLGetShaderInfoLog");
+  Dart_EnterScope();
+
+  Dart_Handle shaderHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t shader;
+  HandleError(Dart_IntegerToInt64(shaderHandle, &shader));
+
+  GLint infoLogLength = 0;
+  glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);
+
+  GLchar* strInfoLog = new GLchar[infoLogLength + 1];
+  glGetShaderInfoLog(shader, infoLogLength, NULL, strInfoLog);
+  strInfoLog[infoLogLength] = 0;
+
+  Dart_Handle result = HandleError(Dart_NewStringFromCString(strInfoLog));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+  delete[] strInfoLog;
+}
+
+void GLGetProgramInfoLog(Dart_NativeArguments arguments) {
+  Log::Print("GLGetProgramInfoLog");
+  Dart_EnterScope();
+
+  Dart_Handle programHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t program;
+  HandleError(Dart_IntegerToInt64(programHandle, &program));
+
+  GLint infoLogLength;
+  glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);
+
+  GLchar* strInfoLog = new GLchar[infoLogLength + 1];
+  glGetProgramInfoLog(program, infoLogLength, NULL, strInfoLog);
+  strInfoLog[infoLogLength] = 0;
+
+  Dart_Handle result = HandleError(Dart_NewStringFromCString(strInfoLog));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+  delete[] strInfoLog;
+}
+void GLGetUniformLocation(Dart_NativeArguments arguments) {
+  Log::Print("GLGetUniformLocation");
+  Dart_EnterScope();
+
+  Dart_Handle programHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t program;
+  HandleError(Dart_IntegerToInt64(programHandle, &program));
+
+  Dart_Handle nameHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  intptr_t length;
+  HandleError(Dart_StringLength(nameHandle, &length));
+  uint8_t* str;
+  //str = reinterpret_cast<uint8_t*>(malloc(length+1));
+  HandleError(Dart_StringToUTF8(nameHandle, &str, &length));
+  str[length] = 0;
+  
+  int64_t location = glGetUniformLocation(program, const_cast<const GLchar*>(reinterpret_cast<GLchar*>(str)));
+  CheckGLError("glGetUniformLocation");
+  Dart_Handle result = HandleError(Dart_NewInteger(location));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLLinkProgram(Dart_NativeArguments arguments) {
+  Log::Print("GLLinkProgram");
+  Dart_EnterScope();
+
+  Dart_Handle programHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t program;
+  HandleError(Dart_IntegerToInt64(programHandle, &program));
+
+  glLinkProgram(program);
+  CheckGLError("glLinkProgram");
+  Dart_ExitScope();
+}
+
+void GLShaderSource(Dart_NativeArguments arguments) {
+  Log::Print("GLShaderSource");
+  Dart_EnterScope();
+
+  Dart_Handle shaderHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t shader;
+  HandleError(Dart_IntegerToInt64(shaderHandle, &shader));
+
+  Dart_Handle sourceHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  intptr_t length[1];
+  HandleError(Dart_StringLength(sourceHandle, length));
+  Log::Print("Source length is %d", length[0]);
+  uint8_t* str[1];
+  //str[0] = reinterpret_cast<uint8_t*>(malloc(length[0]+1));
+  HandleError(Dart_StringToUTF8(sourceHandle, &str[0], length));
+  Log::Print("Converted length is %d", length[0]);
+  str[0][*length] = 0;
+  
+  const GLchar* source = const_cast<const GLchar*>(reinterpret_cast<GLchar*>(str[0]));
+  Log::Print("Source: %s", source);
+  glShaderSource(shader, 1, const_cast<const GLchar**>(reinterpret_cast<GLchar**>(str)), NULL);
+  CheckGLError("glShaderSource");
+  Dart_ExitScope();
+}
+
+void GLUseProgram(Dart_NativeArguments arguments) {
+  Log::Print("GLUseProgram");
+  Dart_EnterScope();
+
+  Dart_Handle programHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t program;
+  HandleError(Dart_IntegerToInt64(programHandle, &program));
+
+  glUseProgram(program);
+  CheckGLError("glUseProgram");
+  Dart_ExitScope();
+}
+
+void GLUniform1i(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform1i");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle v0Handle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  int64_t v0;
+  HandleError(Dart_IntegerToInt64(v0Handle, &v0));
+
+  glUniform1i(location, v0);
+  CheckGLError("glUniform1i");
+  Dart_ExitScope();
+}
+
+void GLUniform2i(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform2i");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle v0Handle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  int64_t v0;
+  HandleError(Dart_IntegerToInt64(v0Handle, &v0));
+
+  Dart_Handle v1Handle = HandleError(Dart_GetNativeArgument(arguments, 2));
+  int64_t v1;
+  HandleError(Dart_IntegerToInt64(v1Handle, &v1));
+
+  glUniform2i(location, v0, v1);
+  CheckGLError("glUniform2i");
+  Dart_ExitScope();
+}
+
+void GLUniform3i(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform3i");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle v0Handle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  int64_t v0;
+  HandleError(Dart_IntegerToInt64(v0Handle, &v0));
+
+  Dart_Handle v1Handle = HandleError(Dart_GetNativeArgument(arguments, 2));
+  int64_t v1;
+  HandleError(Dart_IntegerToInt64(v1Handle, &v1));
+
+  Dart_Handle v2Handle = HandleError(Dart_GetNativeArgument(arguments, 3));
+  int64_t v2;
+  HandleError(Dart_IntegerToInt64(v2Handle, &v2));
+
+  glUniform3i(location, v0, v1, v2);
+  CheckGLError("glUniform3i");
+  Dart_ExitScope();
+}
+
+void GLUniform4i(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform4i");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle v0Handle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  int64_t v0;
+  HandleError(Dart_IntegerToInt64(v0Handle, &v0));
+
+  Dart_Handle v1Handle = HandleError(Dart_GetNativeArgument(arguments, 2));
+  int64_t v1;
+  HandleError(Dart_IntegerToInt64(v1Handle, &v1));
+
+  Dart_Handle v2Handle = HandleError(Dart_GetNativeArgument(arguments, 3));
+  int64_t v2;
+  HandleError(Dart_IntegerToInt64(v2Handle, &v2));
+
+  Dart_Handle v3Handle = HandleError(Dart_GetNativeArgument(arguments, 4));
+  int64_t v3;
+  HandleError(Dart_IntegerToInt64(v3Handle, &v3));
+
+  glUniform4i(location, v0, v1, v2, v3);
+  CheckGLError("glUniform4i");
+  Dart_ExitScope();
+}
+
+void GLUniform1f(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform1f");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle v0Handle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  double v0;
+  HandleError(Dart_DoubleValue(v0Handle, &v0));
+
+  glUniform1f(location, v0);
+  CheckGLError("glUniform1f");
+  Dart_ExitScope();
+}
+
+void GLUniform2f(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform2f");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle v0Handle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  double v0;
+  HandleError(Dart_DoubleValue(v0Handle, &v0));
+
+  Dart_Handle v1Handle = HandleError(Dart_GetNativeArgument(arguments, 2));
+  double v1;
+  HandleError(Dart_DoubleValue(v1Handle, &v1));
+
+  glUniform2f(location, v0, v1);
+  CheckGLError("glUniform2f");
+  Dart_ExitScope();
+}
+
+void GLUniform3f(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform3f");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle v0Handle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  double v0;
+  HandleError(Dart_DoubleValue(v0Handle, &v0));
+
+  Dart_Handle v1Handle = HandleError(Dart_GetNativeArgument(arguments, 2));
+  double v1;
+  HandleError(Dart_DoubleValue(v1Handle, &v1));
+
+  Dart_Handle v2Handle = HandleError(Dart_GetNativeArgument(arguments, 3));
+  double v2;
+  HandleError(Dart_DoubleValue(v2Handle, &v2));
+
+  glUniform3f(location, v0, v1, v2);
+  CheckGLError("glUniform3f");
+  Dart_ExitScope();
+}
+
+void GLUniform4f(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform4f");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle v0Handle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  double v0;
+  HandleError(Dart_DoubleValue(v0Handle, &v0));
+
+  Dart_Handle v1Handle = HandleError(Dart_GetNativeArgument(arguments, 2));
+  double v1;
+  HandleError(Dart_DoubleValue(v1Handle, &v1));
+
+  Dart_Handle v2Handle = HandleError(Dart_GetNativeArgument(arguments, 3));
+  double v2;
+  HandleError(Dart_DoubleValue(v2Handle, &v2));
+
+  Dart_Handle v3Handle = HandleError(Dart_GetNativeArgument(arguments, 4));
+  double v3;
+  HandleError(Dart_DoubleValue(v3Handle, &v3));
+
+  glUniform4f(location, v0, v1, v2, v3);
+  CheckGLError("glUniform4f");
+  Dart_ExitScope();
+}
+
+void GLUniform1iv(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform1iv");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle argHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+
+  if (Dart_IsList(argHandle)) {
+    int len;
+    HandleError(Dart_ListLength(argHandle, &len));
+    GLint* list = new GLint[len];
+    for (int i = 0; i < len; i++) {
+      Dart_Handle vHandle = Dart_ListGetAt(argHandle, i);
+      int64_t v;
+      HandleError(Dart_IntegerToInt64(vHandle, &v));
+      list[i] = v;
+    }
+    glUniform1iv(location, len, list);
+    delete [] list;
+    CheckGLError("glUniform1iv");
+  }
+  Dart_ExitScope();
+}
+
+void GLUniform2iv(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform2iv");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle argHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+
+  if (Dart_IsList(argHandle)) {
+    int len;
+    HandleError(Dart_ListLength(argHandle, &len));
+    GLint* list = new GLint[len];
+    for (int i = 0; i < len; i++) {
+      Dart_Handle vHandle = Dart_ListGetAt(argHandle, i);
+      int64_t v;
+      HandleError(Dart_IntegerToInt64(vHandle, &v));
+      list[i] = v;
+    }
+    glUniform2iv(location, len / 2, list);
+    delete [] list;
+    CheckGLError("glUniform2iv");
+  }
+  Dart_ExitScope();
+}
+
+void GLUniform3iv(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform3iv");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle argHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+
+  if (Dart_IsList(argHandle)) {
+    int len;
+    HandleError(Dart_ListLength(argHandle, &len));
+    GLint* list = new GLint[len];
+    for (int i = 0; i < len; i++) {
+      Dart_Handle vHandle = Dart_ListGetAt(argHandle, i);
+      int64_t v;
+      HandleError(Dart_IntegerToInt64(vHandle, &v));
+      list[i] = v;
+    }
+    glUniform3iv(location, len / 3, list);
+    delete [] list;
+    CheckGLError("glUniform3iv");
+  }
+  Dart_ExitScope();
+}
+
+void GLUniform4iv(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform4iv");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle argHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+
+  if (Dart_IsList(argHandle)) {
+    int len;
+    HandleError(Dart_ListLength(argHandle, &len));
+    GLint* list = new GLint[len];
+    for (int i = 0; i < len; i++) {
+      Dart_Handle vHandle = Dart_ListGetAt(argHandle, i);
+      int64_t v;
+      HandleError(Dart_IntegerToInt64(vHandle, &v));
+      list[i] = v;
+    }
+    glUniform1iv(location, len / 4, list);
+    delete [] list;
+    CheckGLError("glUniform4iv");
+  }
+  Dart_ExitScope();
+}
+
+void GLUniform1fv(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform1fv");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle argHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+
+  if (Dart_IsList(argHandle)) {
+    int len;
+    HandleError(Dart_ListLength(argHandle, &len));
+    GLfloat* list = new GLfloat[len];
+    for (int i = 0; i < len; i++) {
+      Dart_Handle vHandle = Dart_ListGetAt(argHandle, i);
+      double v;
+      HandleError(Dart_DoubleValue(vHandle, &v));
+      list[i] = v;
+    }
+    glUniform1fv(location, len, list);
+    delete [] list;
+    CheckGLError("glUniform1fv");
+  }
+  Dart_ExitScope();
+}
+
+void GLUniform2fv(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform2fv");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle argHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+
+  if (Dart_IsList(argHandle)) {
+    int len;
+    HandleError(Dart_ListLength(argHandle, &len));
+    GLfloat* list = new GLfloat[len];
+    for (int i = 0; i < len; i++) {
+      Dart_Handle vHandle = Dart_ListGetAt(argHandle, i);
+      double v;
+      HandleError(Dart_DoubleValue(vHandle, &v));
+      list[i] = v;
+    }
+    glUniform2fv(location, len / 2, list);
+    delete [] list;
+    CheckGLError("glUniform2fv");
+  }
+  Dart_ExitScope();
+}
+
+void GLUniform3fv(Dart_NativeArguments arguments) {
+  Log::Print("GLUniform3fv");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle argHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+
+  if (Dart_IsList(argHandle)) {
+    int len;
+    HandleError(Dart_ListLength(argHandle, &len));
+    GLfloat* list = new GLfloat[len];
+    for (int i = 0; i < len; i++) {
+      Dart_Handle vHandle = Dart_ListGetAt(argHandle, i);
+      double v;
+      HandleError(Dart_DoubleValue(vHandle, &v));
+      list[i] = v;
+    }
+    glUniform3fv(location, len / 3, list);
+    delete [] list;
+    CheckGLError("glUniform3fv");
+  }
+  Dart_ExitScope();
+}
+
+void GLUniform4fv(Dart_NativeArguments arguments) {
+  Log::Print("In GLUniform4fv");
+  Dart_EnterScope();
+
+  Dart_Handle locationHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t location;
+  HandleError(Dart_IntegerToInt64(locationHandle, &location));
+
+  Dart_Handle argHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+
+  if (Dart_IsList(argHandle)) {
+    int len;
+    HandleError(Dart_ListLength(argHandle, &len));
+    GLfloat* list = new GLfloat[len];
+    for (int i = 0; i < len; i++) {
+      Dart_Handle vHandle = Dart_ListGetAt(argHandle, i);
+      double v;
+      HandleError(Dart_DoubleValue(vHandle, &v));
+      list[i] = v;
+    }
+    glUniform4fv(location, len / 4, list);
+    delete [] list;
+    CheckGLError("glUniform4fv");
+  }
+  Dart_ExitScope();
+}
+
+void GLViewport(Dart_NativeArguments arguments) {
+  Log::Print("GLViewport");
+  Dart_EnterScope();
+
+  Dart_Handle xHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t x;
+  HandleError(Dart_IntegerToInt64(xHandle, &x));
+
+  Dart_Handle yHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  int64_t y;
+  HandleError(Dart_IntegerToInt64(yHandle, &y));
+
+  Dart_Handle widthHandle = HandleError(Dart_GetNativeArgument(arguments, 2));
+  int64_t width;
+  HandleError(Dart_IntegerToInt64(widthHandle, &width));
+
+  Dart_Handle heightHandle = HandleError(Dart_GetNativeArgument(arguments, 3));
+  int64_t height;
+  HandleError(Dart_IntegerToInt64(heightHandle, &height));
+
+  Log::Print("Dimensions: [%d, %d, %d, %d]", (int) x, (int)y, (int) width, (int) height);
+
+  glViewport((int) x, (int) y, (int) width, (int) height);
+  CheckGLError("glViewPort");
+  Dart_ExitScope();
+}
+
+void GLVertexAttribPointer(Dart_NativeArguments arguments) {
+  Log::Print("GLVertexAttribPointer");
+  Dart_EnterScope();
+
+  Dart_Handle indexHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t index;
+  HandleError(Dart_IntegerToInt64(indexHandle, &index));
+
+  Dart_Handle sizeHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  int64_t size;
+  HandleError(Dart_IntegerToInt64(sizeHandle, &size));
+
+  Dart_Handle typeHandle = HandleError(Dart_GetNativeArgument(arguments, 2));
+  int64_t type;
+  HandleError(Dart_IntegerToInt64(typeHandle, &type));
+
+  Dart_Handle normalizedHandle = HandleError(Dart_GetNativeArgument(arguments, 3));
+  bool normalized;
+  HandleError(Dart_BooleanValue(normalizedHandle, &normalized));
+
+  Dart_Handle strideHandle = HandleError(Dart_GetNativeArgument(arguments, 4));
+  int64_t stride;
+  HandleError(Dart_IntegerToInt64(strideHandle, &stride));
+
+  Dart_Handle pointerHandle = HandleError(Dart_GetNativeArgument(arguments, 5));
+  int64_t pointerValue;
+  HandleError(Dart_IntegerToInt64(pointerHandle, &pointerValue));
+  const void* pointer;
+  pointer = const_cast<const void*>(reinterpret_cast<void*>(pointerValue));
+
+  glVertexAttribPointer(index, (int) size, (int) type, normalized, (int) stride, pointer);
+  CheckGLError("glVertexAttribPointer");
+  Dart_ExitScope();
+}
+
+void GLClearColor(Dart_NativeArguments arguments) {
+  Log::Print("GLClearColor");
+  Dart_EnterScope();
+
+  Dart_Handle redHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  double red;
+  HandleError(Dart_DoubleValue(redHandle, &red));
+
+  Dart_Handle greenHandle = HandleError(Dart_GetNativeArgument(arguments, 1));
+  double green;
+  HandleError(Dart_DoubleValue(greenHandle, &green));
+
+  Dart_Handle blueHandle = HandleError(Dart_GetNativeArgument(arguments, 2));
+  double blue;
+  HandleError(Dart_DoubleValue(blueHandle, &blue));
+
+  Dart_Handle alphaHandle = HandleError(Dart_GetNativeArgument(arguments, 3));
+  double alpha;
+  HandleError(Dart_DoubleValue(alphaHandle, &alpha));
+
+  glClearColor(red, green, blue, alpha);
+  CheckGLError("glClearColor");
+  Dart_ExitScope();
+}
+
+void GLClearDepth(Dart_NativeArguments arguments) {
+  Log::Print("GLClearDepth");
+  Dart_EnterScope();
+
+  Dart_Handle depthHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  double depth;
+  HandleError(Dart_DoubleValue(depthHandle, &depth));
+
+  glClearDepthf(depth);
+  CheckGLError("glClearDepthf");
+  Dart_ExitScope();
+}
+
+void GLClear(Dart_NativeArguments arguments) {
+  Log::Print("GLClear");
+  Dart_EnterScope();
+  Dart_Handle maskHandle = HandleError(Dart_GetNativeArgument(arguments, 0));
+  int64_t mask;
+  HandleError(Dart_IntegerToInt64(maskHandle, &mask));
+  glClear(mask);
+  CheckGLError("glClear");
+  Dart_ExitScope();
+}
+
+void GLArrayBuffer(Dart_NativeArguments arguments) {
+  Log::Print("GLArrayBuffer");
+  Dart_EnterScope();
+  Dart_Handle result = HandleError(Dart_NewInteger(GL_ARRAY_BUFFER));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLColorBufferBit(Dart_NativeArguments arguments) {
+  Log::Print("GLColorBuffer");
+  Dart_EnterScope();
+  Dart_Handle result = HandleError(Dart_NewInteger(GL_COLOR_BUFFER_BIT));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLCompileStatus(Dart_NativeArguments arguments) {
+  Log::Print("GLCompileStatus");
+  Dart_EnterScope();
+  Dart_Handle result = HandleError(Dart_NewInteger(GL_COMPILE_STATUS));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLDepthBufferBit(Dart_NativeArguments arguments) {
+  Log::Print("GLDepthBufferBit");
+  Dart_EnterScope();
+  Dart_Handle result = HandleError(Dart_NewInteger(GL_DEPTH_BUFFER_BIT));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLFloat(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+  Dart_Handle result = HandleError(Dart_NewInteger(GL_FLOAT));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLFragmentShader(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+  Dart_Handle result = HandleError(Dart_NewInteger(GL_FRAGMENT_SHADER));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLLinkStatus(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+  Dart_Handle result = HandleError(Dart_NewInteger(GL_LINK_STATUS));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLStaticDraw(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+  Dart_Handle result = HandleError(Dart_NewInteger(GL_STATIC_DRAW));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLTriangleStrip(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+  Dart_Handle result = HandleError(Dart_NewInteger(GL_TRIANGLE_STRIP));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLTriangles(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+  Dart_Handle result = HandleError(Dart_NewInteger(GL_TRIANGLES));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLTrue(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+  Dart_Handle result = HandleError(Dart_NewInteger(GL_TRUE));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+void GLVertexShader(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+  Dart_Handle result = HandleError(Dart_NewInteger(GL_VERTEX_SHADER));
+  Dart_SetReturnValue(arguments, result);
+  Dart_ExitScope();
+}
+
+uint8_t* randomArray(int seed, int length) {
+  if (length <= 0 || length > 10000000) return NULL;
+  uint8_t* values = reinterpret_cast<uint8_t*>(malloc(length));
+  if (NULL == values) return NULL;
+  srand(seed);
+  for (int i = 0; i < length; ++i) {
+    values[i] = rand() % 256;
+  }
+  return values;
+}
+
+void wrappedRandomArray(Dart_Port dest_port_id,
+                        Dart_Port reply_port_id,
+                        Dart_CObject* message) {
+  if (message->type == Dart_CObject::kArray &&
+      2 == message->value.as_array.length) {
+    // Use .as_array and .as_int32 to access the data in the Dart_CObject.
+    Dart_CObject* param0 = message->value.as_array.values[0];
+    Dart_CObject* param1 = message->value.as_array.values[1];
+    if (param0->type == Dart_CObject::kInt32 &&
+        param1->type == Dart_CObject::kInt32) {
+      int length = param0->value.as_int32;
+      int seed = param1->value.as_int32;
+
+      uint8_t* values = randomArray(seed, length);
+
+      if (values != NULL) {
+        Dart_CObject result;
+        result.type = Dart_CObject::kUint8Array;
+        result.value.as_byte_array.values = values;
+        result.value.as_byte_array.length = length;
+        Dart_PostCObject(reply_port_id, &result);
+        free(values);
+        // It is OK that result is destroyed when function exits.
+        // Dart_PostCObject has copied its data.
+        return;
+      }
+    }
+  }
+  Dart_CObject result;
+  result.type = Dart_CObject::kNull;
+  Dart_PostCObject(reply_port_id, &result);
+}
+
+void randomArrayServicePort(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+  Dart_SetReturnValue(arguments, Dart_Null());
+  Dart_Port service_port =
+      Dart_NewNativePort("RandomArrayService", wrappedRandomArray, true);
+  if (service_port != ((Dart_Port)0)) {
+    Dart_Handle send_port = HandleError(Dart_NewSendPort(service_port));
+    Dart_SetReturnValue(arguments, send_port);
+  }
+  Dart_ExitScope();
+}
+
+
+struct FunctionLookup {
+  const char* name;
+  Dart_NativeFunction function;
+};
+
+FunctionLookup function_list[] = {
+    {"Log", Log},
+    {"SystemRand", SystemRand},
+    {"SystemSrand", SystemSrand},
+    {"EGLSwapBuffers", EGLSwapBuffers},
+    {"GLAttachShader", GLAttachShader},
+    {"GLBindBuffer", GLBindBuffer},
+    {"GLBufferData", GLBufferData},
+    {"GLClear", GLClear},
+    {"GLClearColor", GLClearColor},
+    {"GLClearDepth", GLClearDepth},
+    {"GLCompileShader", GLCompileShader},
+    {"GLCreateBuffer", GLCreateBuffer},
+    {"GLCreateProgram", GLCreateProgram},
+    {"GLCreateShader", GLCreateShader},
+    {"GLDrawArrays", GLDrawArrays},    
+    {"GLEnableVertexAttribArray", GLEnableVertexAttribArray},  
+    {"GLGetAttribLocation", GLGetAttribLocation},    
+    {"GLGetError", GLGetError},    
+    {"GLGetProgramParameter", GLGetProgramParameter},    
+    {"GLGetShaderParameter", GLGetShaderParameter},    
+    {"GLGetUniformLocation", GLGetUniformLocation},    
+    {"GLLinkProgram", GLLinkProgram},
+    {"GLShaderSource", GLShaderSource},
+    {"GLUniform1f", GLUniform1f},
+    {"GLUniform2f", GLUniform2f},
+    {"GLUniform3f", GLUniform3f},
+    {"GLUniform4f", GLUniform4f},
+    {"GLUniform1i", GLUniform1i},
+    {"GLUniform2i", GLUniform2i},
+    {"GLUniform3i", GLUniform3i},
+    {"GLUniform4i", GLUniform4i},
+    {"GLUniform1fv", GLUniform1fv},
+    {"GLUniform2fv", GLUniform2fv},
+    {"GLUniform3fv", GLUniform3fv},
+    {"GLUniform4fv", GLUniform4fv},
+    {"GLUniform1iv", GLUniform1iv},
+    {"GLUniform2iv", GLUniform2iv},
+    {"GLUniform3iv", GLUniform3iv},
+    {"GLUniform4iv", GLUniform4iv},
+    {"GLUseProgram", GLUseProgram},
+    {"GLVertexAttribPointer", GLVertexAttribPointer},
+    {"GLViewport", GLViewport},
+    {"GLArrayBuffer", GLArrayBuffer},
+    {"GLColorBufferBit", GLColorBufferBit},
+    {"GLCompileStatus", GLCompileStatus},
+    {"GLDepthBufferBit", GLDepthBufferBit},
+    {"GLFloat", GLFloat},
+    {"GLFragmentShader", GLFragmentShader},
+    {"GLLinkStatus", GLLinkStatus},
+    {"GLTriangleStrip", GLTriangleStrip},
+    {"GLTriangles", GLTriangles},
+    {"GLTrue", GLTrue},
+    {"GLStaticDraw", GLStaticDraw},
+    {"GLVertexShader", GLVertexShader},
+    {"GLGetShaderInfoLog", GLGetShaderInfoLog},
+    {"GLGetProgramInfoLog", GLGetProgramInfoLog},
+    {"RandomArray_ServicePort", randomArrayServicePort},
+    {NULL, NULL}};
+
+Dart_NativeFunction ResolveName(Dart_Handle name, int argc) {
+  if (!Dart_IsString(name)) return NULL;
+  Dart_NativeFunction result = NULL;
+  Dart_EnterScope();
+  const char* cname;
+  HandleError(Dart_StringToCString(name, &cname));
+  for (int i=0; function_list[i].name != NULL; ++i) {
+    if (strcmp(function_list[i].name, cname) == 0) {
+      result = function_list[i].function;
+      break;
+    }
+  }
+  Dart_ExitScope();
+  return result;
+}