lib/src/generated/gl_bindings.cc

// Copyright (c) 2015, the Dart GL extension authors. All rights reserved.
// Please see the AUTHORS file for details. Use of this source code is governed
// by a BSD-style license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd

// This file is auto-generated by scripts in the tools/ directory.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>

#include "../util.h"
#include "gl_bindings.h"

// Generated GL function bindings for Dart.

void glActiveTexture_native(Dart_NativeArguments arguments) {
  TRACE_START(glActiveTexture_);
  int64_t texture;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &texture));

  glActiveTexture(texture);

  TRACE_END(glActiveTexture_);
}

void glAttachShader_native(Dart_NativeArguments arguments) {
  TRACE_START(glAttachShader_);
  int64_t program;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &program));

  int64_t shader;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &shader));

  glAttachShader(program, shader);

  TRACE_END(glAttachShader_);
}

void glBindAttribLocation_native(Dart_NativeArguments arguments) {
  TRACE_START(glBindAttribLocation_);
  int64_t program;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &program));

  int64_t index;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &index));

  void* name_peer = NULL;
  Dart_Handle name_arg =
      HANDLE(Dart_GetNativeStringArgument(arguments, 2, (void**)&name_peer));
  const char* name;
  HANDLE(Dart_StringToCString(name_arg, &name));

  glBindAttribLocation(program, index, name);

  TRACE_END(glBindAttribLocation_);
}

void glBindBuffer_native(Dart_NativeArguments arguments) {
  TRACE_START(glBindBuffer_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t buffer;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &buffer));

  glBindBuffer(target, buffer);

  TRACE_END(glBindBuffer_);
}

void glBindFramebuffer_native(Dart_NativeArguments arguments) {
  TRACE_START(glBindFramebuffer_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t framebuffer;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &framebuffer));

  glBindFramebuffer(target, framebuffer);

  TRACE_END(glBindFramebuffer_);
}

void glBindRenderbuffer_native(Dart_NativeArguments arguments) {
  TRACE_START(glBindRenderbuffer_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t renderbuffer;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &renderbuffer));

  glBindRenderbuffer(target, renderbuffer);

  TRACE_END(glBindRenderbuffer_);
}

void glBindTexture_native(Dart_NativeArguments arguments) {
  TRACE_START(glBindTexture_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t texture;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &texture));

  glBindTexture(target, texture);

  TRACE_END(glBindTexture_);
}

void glBlendColor_native(Dart_NativeArguments arguments) {
  TRACE_START(glBlendColor_);
  double red;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 0, &red));

  double green;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 1, &green));

  double blue;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 2, &blue));

  double alpha;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 3, &alpha));

  glBlendColor(red, green, blue, alpha);

  TRACE_END(glBlendColor_);
}

void glBlendEquation_native(Dart_NativeArguments arguments) {
  TRACE_START(glBlendEquation_);
  int64_t mode;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &mode));

  glBlendEquation(mode);

  TRACE_END(glBlendEquation_);
}

void glBlendEquationSeparate_native(Dart_NativeArguments arguments) {
  TRACE_START(glBlendEquationSeparate_);
  int64_t modeRGB;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &modeRGB));

  int64_t modeAlpha;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &modeAlpha));

  glBlendEquationSeparate(modeRGB, modeAlpha);

  TRACE_END(glBlendEquationSeparate_);
}

void glBlendFunc_native(Dart_NativeArguments arguments) {
  TRACE_START(glBlendFunc_);
  int64_t sfactor;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &sfactor));

  int64_t dfactor;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &dfactor));

  glBlendFunc(sfactor, dfactor);

  TRACE_END(glBlendFunc_);
}

void glBlendFuncSeparate_native(Dart_NativeArguments arguments) {
  TRACE_START(glBlendFuncSeparate_);
  int64_t sfactorRGB;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &sfactorRGB));

  int64_t dfactorRGB;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &dfactorRGB));

  int64_t sfactorAlpha;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &sfactorAlpha));

  int64_t dfactorAlpha;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &dfactorAlpha));

  glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);

  TRACE_END(glBlendFuncSeparate_);
}

void glBufferData_native(Dart_NativeArguments arguments) {
  TRACE_START(glBufferData_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t size;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &size));

  Dart_Handle data_obj = HANDLE(Dart_GetNativeArgument(arguments, 2));
  void* data_data = nullptr;
  Dart_TypedData_Type data_typeddata_type;
  intptr_t data_typeddata_length;
  if (!Dart_IsNull(data_obj)) {
    HANDLE(Dart_TypedDataAcquireData(data_obj, &data_typeddata_type, &data_data,
                                     &data_typeddata_length));
  }
  const void* data = static_cast<const void*>(data_data);

  int64_t usage;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &usage));

  glBufferData(target, size, data, usage);

  if (!Dart_IsNull(data_obj)) {
    HANDLE(Dart_TypedDataReleaseData(data_obj));
  }

  TRACE_END(glBufferData_);
}

void glBufferSubData_native(Dart_NativeArguments arguments) {
  TRACE_START(glBufferSubData_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t offset;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &offset));

  int64_t size;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &size));

  Dart_Handle data_obj = HANDLE(Dart_GetNativeArgument(arguments, 3));
  void* data_data = nullptr;
  Dart_TypedData_Type data_typeddata_type;
  intptr_t data_typeddata_length;
  if (!Dart_IsNull(data_obj)) {
    HANDLE(Dart_TypedDataAcquireData(data_obj, &data_typeddata_type, &data_data,
                                     &data_typeddata_length));
  }
  const void* data = static_cast<const void*>(data_data);

  glBufferSubData(target, offset, size, data);

  if (!Dart_IsNull(data_obj)) {
    HANDLE(Dart_TypedDataReleaseData(data_obj));
  }

  TRACE_END(glBufferSubData_);
}

void glCheckFramebufferStatus_native(Dart_NativeArguments arguments) {
  TRACE_START(glCheckFramebufferStatus_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  GLenum ret = glCheckFramebufferStatus(target);
  Dart_SetIntegerReturnValue(arguments, ret);
  TRACE_END(glCheckFramebufferStatus_);
}

void glClear_native(Dart_NativeArguments arguments) {
  TRACE_START(glClear_);
  int64_t mask;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &mask));

  glClear(mask);

  TRACE_END(glClear_);
}

void glClearColor_native(Dart_NativeArguments arguments) {
  TRACE_START(glClearColor_);
  double red;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 0, &red));

  double green;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 1, &green));

  double blue;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 2, &blue));

  double alpha;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 3, &alpha));

  glClearColor(red, green, blue, alpha);

  TRACE_END(glClearColor_);
}

void glClearDepthf_native(Dart_NativeArguments arguments) {
  TRACE_START(glClearDepthf_);
  double d;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 0, &d));

  glClearDepthf(d);

  TRACE_END(glClearDepthf_);
}

void glClearStencil_native(Dart_NativeArguments arguments) {
  TRACE_START(glClearStencil_);
  int64_t s;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &s));

  glClearStencil(s);

  TRACE_END(glClearStencil_);
}

void glColorMask_native(Dart_NativeArguments arguments) {
  TRACE_START(glColorMask_);
  int64_t red;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &red));

  int64_t green;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &green));

  int64_t blue;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &blue));

  int64_t alpha;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &alpha));

  glColorMask(red, green, blue, alpha);

  TRACE_END(glColorMask_);
}

void glCompileShader_native(Dart_NativeArguments arguments) {
  TRACE_START(glCompileShader_);
  int64_t shader;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &shader));

  glCompileShader(shader);

  TRACE_END(glCompileShader_);
}

void glCompressedTexImage2D_native(Dart_NativeArguments arguments) {
  TRACE_START(glCompressedTexImage2D_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t level;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &level));

  int64_t internalformat;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &internalformat));

  int64_t width;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &width));

  int64_t height;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 4, &height));

  int64_t border;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 5, &border));

  int64_t imageSize;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 6, &imageSize));

  Dart_Handle data_obj = HANDLE(Dart_GetNativeArgument(arguments, 7));
  void* data_data = nullptr;
  Dart_TypedData_Type data_typeddata_type;
  intptr_t data_typeddata_length;
  if (!Dart_IsNull(data_obj)) {
    HANDLE(Dart_TypedDataAcquireData(data_obj, &data_typeddata_type, &data_data,
                                     &data_typeddata_length));
  }
  const void* data = static_cast<const void*>(data_data);

  glCompressedTexImage2D(target, level, internalformat, width, height, border,
                         imageSize, data);

  if (!Dart_IsNull(data_obj)) {
    HANDLE(Dart_TypedDataReleaseData(data_obj));
  }

  TRACE_END(glCompressedTexImage2D_);
}

void glCompressedTexSubImage2D_native(Dart_NativeArguments arguments) {
  TRACE_START(glCompressedTexSubImage2D_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t level;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &level));

  int64_t xoffset;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &xoffset));

  int64_t yoffset;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &yoffset));

  int64_t width;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 4, &width));

  int64_t height;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 5, &height));

  int64_t format;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 6, &format));

  int64_t imageSize;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 7, &imageSize));

  Dart_Handle data_obj = HANDLE(Dart_GetNativeArgument(arguments, 8));
  void* data_data = nullptr;
  Dart_TypedData_Type data_typeddata_type;
  intptr_t data_typeddata_length;
  if (!Dart_IsNull(data_obj)) {
    HANDLE(Dart_TypedDataAcquireData(data_obj, &data_typeddata_type, &data_data,
                                     &data_typeddata_length));
  }
  const void* data = static_cast<const void*>(data_data);

  glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height,
                            format, imageSize, data);

  if (!Dart_IsNull(data_obj)) {
    HANDLE(Dart_TypedDataReleaseData(data_obj));
  }

  TRACE_END(glCompressedTexSubImage2D_);
}

void glCopyTexImage2D_native(Dart_NativeArguments arguments) {
  TRACE_START(glCopyTexImage2D_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t level;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &level));

  int64_t internalformat;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &internalformat));

  int64_t x;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &x));

  int64_t y;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 4, &y));

  int64_t width;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 5, &width));

  int64_t height;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 6, &height));

  int64_t border;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 7, &border));

  glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);

  TRACE_END(glCopyTexImage2D_);
}

void glCopyTexSubImage2D_native(Dart_NativeArguments arguments) {
  TRACE_START(glCopyTexSubImage2D_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t level;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &level));

  int64_t xoffset;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &xoffset));

  int64_t yoffset;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &yoffset));

  int64_t x;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 4, &x));

  int64_t y;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 5, &y));

  int64_t width;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 6, &width));

  int64_t height;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 7, &height));

  glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);

  TRACE_END(glCopyTexSubImage2D_);
}

void glCreateProgram_native(Dart_NativeArguments arguments) {
  TRACE_START(glCreateProgram_);
  GLuint ret = glCreateProgram();
  Dart_SetIntegerReturnValue(arguments, ret);
  TRACE_END(glCreateProgram_);
}

void glCreateShader_native(Dart_NativeArguments arguments) {
  TRACE_START(glCreateShader_);
  int64_t type;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &type));

  GLuint ret = glCreateShader(type);
  Dart_SetIntegerReturnValue(arguments, ret);
  TRACE_END(glCreateShader_);
}

void glCullFace_native(Dart_NativeArguments arguments) {
  TRACE_START(glCullFace_);
  int64_t mode;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &mode));

  glCullFace(mode);

  TRACE_END(glCullFace_);
}

void glDeleteBuffers_native(Dart_NativeArguments arguments) {
  TRACE_START(glDeleteBuffers_);
  Dart_Handle values_obj = HANDLE(Dart_GetNativeArgument(arguments, 0));
  GLuint* values = NULL;
  intptr_t n = 0;
  HANDLE(Dart_ListLength(values_obj, &n));
  values = static_cast<GLuint*>(malloc(sizeof(GLuint) * n));
  for (int i = 0; i < n; i++) {
    Dart_Handle i_obj = HANDLE(Dart_ListGetAt(values_obj, i));
    HANDLE(Dart_IntegerToUInt(i_obj, &values[i]));
  }
  glDeleteBuffers(n, values);
  free(values);

  TRACE_END(glDeleteBuffers_);
}

void glDeleteFramebuffers_native(Dart_NativeArguments arguments) {
  TRACE_START(glDeleteFramebuffers_);
  Dart_Handle values_obj = HANDLE(Dart_GetNativeArgument(arguments, 0));
  GLuint* values = NULL;
  intptr_t n = 0;
  HANDLE(Dart_ListLength(values_obj, &n));
  values = static_cast<GLuint*>(malloc(sizeof(GLuint) * n));
  for (int i = 0; i < n; i++) {
    Dart_Handle i_obj = HANDLE(Dart_ListGetAt(values_obj, i));
    HANDLE(Dart_IntegerToUInt(i_obj, &values[i]));
  }
  glDeleteFramebuffers(n, values);
  free(values);

  TRACE_END(glDeleteFramebuffers_);
}

void glDeleteProgram_native(Dart_NativeArguments arguments) {
  TRACE_START(glDeleteProgram_);
  int64_t program;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &program));

  glDeleteProgram(program);

  TRACE_END(glDeleteProgram_);
}

void glDeleteRenderbuffers_native(Dart_NativeArguments arguments) {
  TRACE_START(glDeleteRenderbuffers_);
  Dart_Handle values_obj = HANDLE(Dart_GetNativeArgument(arguments, 0));
  GLuint* values = NULL;
  intptr_t n = 0;
  HANDLE(Dart_ListLength(values_obj, &n));
  values = static_cast<GLuint*>(malloc(sizeof(GLuint) * n));
  for (int i = 0; i < n; i++) {
    Dart_Handle i_obj = HANDLE(Dart_ListGetAt(values_obj, i));
    HANDLE(Dart_IntegerToUInt(i_obj, &values[i]));
  }
  glDeleteRenderbuffers(n, values);
  free(values);

  TRACE_END(glDeleteRenderbuffers_);
}

void glDeleteShader_native(Dart_NativeArguments arguments) {
  TRACE_START(glDeleteShader_);
  int64_t shader;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &shader));

  glDeleteShader(shader);

  TRACE_END(glDeleteShader_);
}

void glDeleteTextures_native(Dart_NativeArguments arguments) {
  TRACE_START(glDeleteTextures_);
  Dart_Handle values_obj = HANDLE(Dart_GetNativeArgument(arguments, 0));
  GLuint* values = NULL;
  intptr_t n = 0;
  HANDLE(Dart_ListLength(values_obj, &n));
  values = static_cast<GLuint*>(malloc(sizeof(GLuint) * n));
  for (int i = 0; i < n; i++) {
    Dart_Handle i_obj = HANDLE(Dart_ListGetAt(values_obj, i));
    HANDLE(Dart_IntegerToUInt(i_obj, &values[i]));
  }
  glDeleteTextures(n, values);
  free(values);

  TRACE_END(glDeleteTextures_);
}

void glDepthFunc_native(Dart_NativeArguments arguments) {
  TRACE_START(glDepthFunc_);
  int64_t func;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &func));

  glDepthFunc(func);

  TRACE_END(glDepthFunc_);
}

void glDepthMask_native(Dart_NativeArguments arguments) {
  TRACE_START(glDepthMask_);
  int64_t flag;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &flag));

  glDepthMask(flag);

  TRACE_END(glDepthMask_);
}

void glDepthRangef_native(Dart_NativeArguments arguments) {
  TRACE_START(glDepthRangef_);
  double n;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 0, &n));

  double f;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 1, &f));

  glDepthRangef(n, f);

  TRACE_END(glDepthRangef_);
}

void glDetachShader_native(Dart_NativeArguments arguments) {
  TRACE_START(glDetachShader_);
  int64_t program;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &program));

  int64_t shader;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &shader));

  glDetachShader(program, shader);

  TRACE_END(glDetachShader_);
}

void glDisable_native(Dart_NativeArguments arguments) {
  TRACE_START(glDisable_);
  int64_t cap;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &cap));

  glDisable(cap);

  TRACE_END(glDisable_);
}

void glDisableVertexAttribArray_native(Dart_NativeArguments arguments) {
  TRACE_START(glDisableVertexAttribArray_);
  int64_t index;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &index));

  glDisableVertexAttribArray(index);

  TRACE_END(glDisableVertexAttribArray_);
}

void glDrawArrays_native(Dart_NativeArguments arguments) {
  TRACE_START(glDrawArrays_);
  int64_t mode;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &mode));

  int64_t first;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &first));

  int64_t count;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &count));

  glDrawArrays(mode, first, count);

  TRACE_END(glDrawArrays_);
}

void glDrawElements_native(Dart_NativeArguments arguments) {
  TRACE_START(glDrawElements_);
  int64_t mode;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &mode));

  int64_t count;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &count));

  int64_t type;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &type));

  Dart_Handle indices_obj = HANDLE(Dart_GetNativeArgument(arguments, 3));
  void* indices_data = nullptr;
  Dart_TypedData_Type indices_typeddata_type;
  intptr_t indices_typeddata_length;
  if (!Dart_IsNull(indices_obj)) {
    HANDLE(Dart_TypedDataAcquireData(indices_obj, &indices_typeddata_type,
                                     &indices_data, &indices_typeddata_length));
  }
  const void* indices = static_cast<const void*>(indices_data);

  glDrawElements(mode, count, type, indices);

  if (!Dart_IsNull(indices_obj)) {
    HANDLE(Dart_TypedDataReleaseData(indices_obj));
  }

  TRACE_END(glDrawElements_);
}

void glEnable_native(Dart_NativeArguments arguments) {
  TRACE_START(glEnable_);
  int64_t cap;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &cap));

  glEnable(cap);

  TRACE_END(glEnable_);
}

void glEnableVertexAttribArray_native(Dart_NativeArguments arguments) {
  TRACE_START(glEnableVertexAttribArray_);
  int64_t index;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &index));

  glEnableVertexAttribArray(index);

  TRACE_END(glEnableVertexAttribArray_);
}

void glFinish_native(Dart_NativeArguments arguments) {
  TRACE_START(glFinish_);
  glFinish();

  TRACE_END(glFinish_);
}

void glFlush_native(Dart_NativeArguments arguments) {
  TRACE_START(glFlush_);
  glFlush();

  TRACE_END(glFlush_);
}

void glFramebufferRenderbuffer_native(Dart_NativeArguments arguments) {
  TRACE_START(glFramebufferRenderbuffer_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t attachment;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &attachment));

  int64_t renderbuffertarget;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &renderbuffertarget));

  int64_t renderbuffer;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &renderbuffer));

  glFramebufferRenderbuffer(target, attachment, renderbuffertarget,
                            renderbuffer);

  TRACE_END(glFramebufferRenderbuffer_);
}

void glFramebufferTexture2D_native(Dart_NativeArguments arguments) {
  TRACE_START(glFramebufferTexture2D_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t attachment;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &attachment));

  int64_t textarget;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &textarget));

  int64_t texture;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &texture));

  int64_t level;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 4, &level));

  glFramebufferTexture2D(target, attachment, textarget, texture, level);

  TRACE_END(glFramebufferTexture2D_);
}

void glFrontFace_native(Dart_NativeArguments arguments) {
  TRACE_START(glFrontFace_);
  int64_t mode;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &mode));

  glFrontFace(mode);

  TRACE_END(glFrontFace_);
}

void glGenBuffers_native(Dart_NativeArguments arguments) {
  TRACE_START(glGenBuffers_);
  int64_t n;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &n));

  GLuint* values = static_cast<GLuint*>(malloc(sizeof(GLuint) * n));
  glGenBuffers(n, values);
  Dart_Handle values_obj = Dart_NewList(n);
  for (int i = 0; i < n; i++) {
    Dart_Handle i_obj = HANDLE(Dart_NewInteger(values[i]));
    HANDLE(Dart_ListSetAt(values_obj, i, i_obj));
  }
  Dart_SetReturnValue(arguments, values_obj);
  free(values);

  TRACE_END(glGenBuffers_);
}

void glGenerateMipmap_native(Dart_NativeArguments arguments) {
  TRACE_START(glGenerateMipmap_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  glGenerateMipmap(target);

  TRACE_END(glGenerateMipmap_);
}

void glGenFramebuffers_native(Dart_NativeArguments arguments) {
  TRACE_START(glGenFramebuffers_);
  int64_t n;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &n));

  GLuint* values = static_cast<GLuint*>(malloc(sizeof(GLuint) * n));
  glGenFramebuffers(n, values);
  Dart_Handle values_obj = Dart_NewList(n);
  for (int i = 0; i < n; i++) {
    Dart_Handle i_obj = HANDLE(Dart_NewInteger(values[i]));
    HANDLE(Dart_ListSetAt(values_obj, i, i_obj));
  }
  Dart_SetReturnValue(arguments, values_obj);
  free(values);

  TRACE_END(glGenFramebuffers_);
}

void glGenRenderbuffers_native(Dart_NativeArguments arguments) {
  TRACE_START(glGenRenderbuffers_);
  int64_t n;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &n));

  GLuint* values = static_cast<GLuint*>(malloc(sizeof(GLuint) * n));
  glGenRenderbuffers(n, values);
  Dart_Handle values_obj = Dart_NewList(n);
  for (int i = 0; i < n; i++) {
    Dart_Handle i_obj = HANDLE(Dart_NewInteger(values[i]));
    HANDLE(Dart_ListSetAt(values_obj, i, i_obj));
  }
  Dart_SetReturnValue(arguments, values_obj);
  free(values);

  TRACE_END(glGenRenderbuffers_);
}

void glGenTextures_native(Dart_NativeArguments arguments) {
  TRACE_START(glGenTextures_);
  int64_t n;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &n));

  GLuint* values = static_cast<GLuint*>(malloc(sizeof(GLuint) * n));
  glGenTextures(n, values);
  Dart_Handle values_obj = Dart_NewList(n);
  for (int i = 0; i < n; i++) {
    Dart_Handle i_obj = HANDLE(Dart_NewInteger(values[i]));
    HANDLE(Dart_ListSetAt(values_obj, i, i_obj));
  }
  Dart_SetReturnValue(arguments, values_obj);
  free(values);

  TRACE_END(glGenTextures_);
}

void glGetAttribLocation_native(Dart_NativeArguments arguments) {
  TRACE_START(glGetAttribLocation_);
  int64_t program;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &program));

  void* name_peer = NULL;
  Dart_Handle name_arg =
      HANDLE(Dart_GetNativeStringArgument(arguments, 1, (void**)&name_peer));
  const char* name;
  HANDLE(Dart_StringToCString(name_arg, &name));

  GLint ret = glGetAttribLocation(program, name);
  Dart_SetIntegerReturnValue(arguments, ret);
  TRACE_END(glGetAttribLocation_);
}

void glGetError_native(Dart_NativeArguments arguments) {
  TRACE_START(glGetError_);
  GLenum ret = glGetError();
  Dart_SetIntegerReturnValue(arguments, ret);
  TRACE_END(glGetError_);
}

void glGetString_native(Dart_NativeArguments arguments) {
  TRACE_START(glGetString_);
  int64_t name;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &name));

  const GLubyte* ret = glGetString(name);
  Dart_SetReturnValue(
      arguments,
      HANDLE(Dart_NewStringFromCString(reinterpret_cast<const char*>(ret))));
  TRACE_END(glGetString_);
}

void glGetUniformLocation_native(Dart_NativeArguments arguments) {
  TRACE_START(glGetUniformLocation_);
  int64_t program;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &program));

  void* name_peer = NULL;
  Dart_Handle name_arg =
      HANDLE(Dart_GetNativeStringArgument(arguments, 1, (void**)&name_peer));
  const char* name;
  HANDLE(Dart_StringToCString(name_arg, &name));

  GLint ret = glGetUniformLocation(program, name);
  Dart_SetIntegerReturnValue(arguments, ret);
  TRACE_END(glGetUniformLocation_);
}

void glHint_native(Dart_NativeArguments arguments) {
  TRACE_START(glHint_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t mode;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &mode));

  glHint(target, mode);

  TRACE_END(glHint_);
}

void glIsBuffer_native(Dart_NativeArguments arguments) {
  TRACE_START(glIsBuffer_);
  int64_t buffer;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &buffer));

  GLboolean ret = glIsBuffer(buffer);
  Dart_SetBooleanReturnValue(arguments, ret);
  TRACE_END(glIsBuffer_);
}

void glIsEnabled_native(Dart_NativeArguments arguments) {
  TRACE_START(glIsEnabled_);
  int64_t cap;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &cap));

  GLboolean ret = glIsEnabled(cap);
  Dart_SetBooleanReturnValue(arguments, ret);
  TRACE_END(glIsEnabled_);
}

void glIsFramebuffer_native(Dart_NativeArguments arguments) {
  TRACE_START(glIsFramebuffer_);
  int64_t framebuffer;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &framebuffer));

  GLboolean ret = glIsFramebuffer(framebuffer);
  Dart_SetBooleanReturnValue(arguments, ret);
  TRACE_END(glIsFramebuffer_);
}

void glIsProgram_native(Dart_NativeArguments arguments) {
  TRACE_START(glIsProgram_);
  int64_t program;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &program));

  GLboolean ret = glIsProgram(program);
  Dart_SetBooleanReturnValue(arguments, ret);
  TRACE_END(glIsProgram_);
}

void glIsRenderbuffer_native(Dart_NativeArguments arguments) {
  TRACE_START(glIsRenderbuffer_);
  int64_t renderbuffer;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &renderbuffer));

  GLboolean ret = glIsRenderbuffer(renderbuffer);
  Dart_SetBooleanReturnValue(arguments, ret);
  TRACE_END(glIsRenderbuffer_);
}

void glIsShader_native(Dart_NativeArguments arguments) {
  TRACE_START(glIsShader_);
  int64_t shader;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &shader));

  GLboolean ret = glIsShader(shader);
  Dart_SetBooleanReturnValue(arguments, ret);
  TRACE_END(glIsShader_);
}

void glIsTexture_native(Dart_NativeArguments arguments) {
  TRACE_START(glIsTexture_);
  int64_t texture;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &texture));

  GLboolean ret = glIsTexture(texture);
  Dart_SetBooleanReturnValue(arguments, ret);
  TRACE_END(glIsTexture_);
}

void glLineWidth_native(Dart_NativeArguments arguments) {
  TRACE_START(glLineWidth_);
  double width;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 0, &width));

  glLineWidth(width);

  TRACE_END(glLineWidth_);
}

void glLinkProgram_native(Dart_NativeArguments arguments) {
  TRACE_START(glLinkProgram_);
  int64_t program;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &program));

  glLinkProgram(program);

  TRACE_END(glLinkProgram_);
}

void glPixelStorei_native(Dart_NativeArguments arguments) {
  TRACE_START(glPixelStorei_);
  int64_t pname;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &pname));

  int64_t param;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &param));

  glPixelStorei(pname, param);

  TRACE_END(glPixelStorei_);
}

void glPolygonOffset_native(Dart_NativeArguments arguments) {
  TRACE_START(glPolygonOffset_);
  double factor;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 0, &factor));

  double units;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 1, &units));

  glPolygonOffset(factor, units);

  TRACE_END(glPolygonOffset_);
}

void glReleaseShaderCompiler_native(Dart_NativeArguments arguments) {
  TRACE_START(glReleaseShaderCompiler_);
  glReleaseShaderCompiler();

  TRACE_END(glReleaseShaderCompiler_);
}

void glRenderbufferStorage_native(Dart_NativeArguments arguments) {
  TRACE_START(glRenderbufferStorage_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t internalformat;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &internalformat));

  int64_t width;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &width));

  int64_t height;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &height));

  glRenderbufferStorage(target, internalformat, width, height);

  TRACE_END(glRenderbufferStorage_);
}

void glSampleCoverage_native(Dart_NativeArguments arguments) {
  TRACE_START(glSampleCoverage_);
  double value;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 0, &value));

  int64_t invert;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &invert));

  glSampleCoverage(value, invert);

  TRACE_END(glSampleCoverage_);
}

void glScissor_native(Dart_NativeArguments arguments) {
  TRACE_START(glScissor_);
  int64_t x;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &x));

  int64_t y;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &y));

  int64_t width;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &width));

  int64_t height;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &height));

  glScissor(x, y, width, height);

  TRACE_END(glScissor_);
}

void glStencilFunc_native(Dart_NativeArguments arguments) {
  TRACE_START(glStencilFunc_);
  int64_t func;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &func));

  int64_t ref;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &ref));

  int64_t mask;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &mask));

  glStencilFunc(func, ref, mask);

  TRACE_END(glStencilFunc_);
}

void glStencilFuncSeparate_native(Dart_NativeArguments arguments) {
  TRACE_START(glStencilFuncSeparate_);
  int64_t face;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &face));

  int64_t func;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &func));

  int64_t ref;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &ref));

  int64_t mask;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &mask));

  glStencilFuncSeparate(face, func, ref, mask);

  TRACE_END(glStencilFuncSeparate_);
}

void glStencilMask_native(Dart_NativeArguments arguments) {
  TRACE_START(glStencilMask_);
  int64_t mask;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &mask));

  glStencilMask(mask);

  TRACE_END(glStencilMask_);
}

void glStencilMaskSeparate_native(Dart_NativeArguments arguments) {
  TRACE_START(glStencilMaskSeparate_);
  int64_t face;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &face));

  int64_t mask;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &mask));

  glStencilMaskSeparate(face, mask);

  TRACE_END(glStencilMaskSeparate_);
}

void glStencilOp_native(Dart_NativeArguments arguments) {
  TRACE_START(glStencilOp_);
  int64_t fail;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &fail));

  int64_t zfail;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &zfail));

  int64_t zpass;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &zpass));

  glStencilOp(fail, zfail, zpass);

  TRACE_END(glStencilOp_);
}

void glStencilOpSeparate_native(Dart_NativeArguments arguments) {
  TRACE_START(glStencilOpSeparate_);
  int64_t face;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &face));

  int64_t sfail;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &sfail));

  int64_t dpfail;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &dpfail));

  int64_t dppass;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &dppass));

  glStencilOpSeparate(face, sfail, dpfail, dppass);

  TRACE_END(glStencilOpSeparate_);
}

void glTexImage2D_native(Dart_NativeArguments arguments) {
  TRACE_START(glTexImage2D_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t level;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &level));

  int64_t internalformat;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &internalformat));

  int64_t width;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &width));

  int64_t height;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 4, &height));

  int64_t border;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 5, &border));

  int64_t format;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 6, &format));

  int64_t type;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 7, &type));

  Dart_Handle pixels_obj = HANDLE(Dart_GetNativeArgument(arguments, 8));
  void* pixels_data = nullptr;
  Dart_TypedData_Type pixels_typeddata_type;
  intptr_t pixels_typeddata_length;
  if (!Dart_IsNull(pixels_obj)) {
    HANDLE(Dart_TypedDataAcquireData(pixels_obj, &pixels_typeddata_type,
                                     &pixels_data, &pixels_typeddata_length));
  }
  const void* pixels = static_cast<const void*>(pixels_data);

  glTexImage2D(target, level, internalformat, width, height, border, format,
               type, pixels);

  if (!Dart_IsNull(pixels_obj)) {
    HANDLE(Dart_TypedDataReleaseData(pixels_obj));
  }

  TRACE_END(glTexImage2D_);
}

void glTexParameterf_native(Dart_NativeArguments arguments) {
  TRACE_START(glTexParameterf_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t pname;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &pname));

  double param;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 2, &param));

  glTexParameterf(target, pname, param);

  TRACE_END(glTexParameterf_);
}

void glTexParameteri_native(Dart_NativeArguments arguments) {
  TRACE_START(glTexParameteri_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t pname;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &pname));

  int64_t param;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &param));

  glTexParameteri(target, pname, param);

  TRACE_END(glTexParameteri_);
}

void glTexSubImage2D_native(Dart_NativeArguments arguments) {
  TRACE_START(glTexSubImage2D_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t level;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &level));

  int64_t xoffset;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &xoffset));

  int64_t yoffset;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &yoffset));

  int64_t width;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 4, &width));

  int64_t height;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 5, &height));

  int64_t format;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 6, &format));

  int64_t type;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 7, &type));

  Dart_Handle pixels_obj = HANDLE(Dart_GetNativeArgument(arguments, 8));
  void* pixels_data = nullptr;
  Dart_TypedData_Type pixels_typeddata_type;
  intptr_t pixels_typeddata_length;
  if (!Dart_IsNull(pixels_obj)) {
    HANDLE(Dart_TypedDataAcquireData(pixels_obj, &pixels_typeddata_type,
                                     &pixels_data, &pixels_typeddata_length));
  }
  const void* pixels = static_cast<const void*>(pixels_data);

  glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type,
                  pixels);

  if (!Dart_IsNull(pixels_obj)) {
    HANDLE(Dart_TypedDataReleaseData(pixels_obj));
  }

  TRACE_END(glTexSubImage2D_);
}

void glUniform1f_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform1f_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  double v0;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 1, &v0));

  glUniform1f(location, v0);

  TRACE_END(glUniform1f_);
}

void glUniform1fv_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform1fv_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t count;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &count));

  Dart_Handle value_obj = HANDLE(Dart_GetNativeArgument(arguments, 2));
  void* value_data = nullptr;
  Dart_TypedData_Type value_typeddata_type;
  intptr_t value_typeddata_length;
  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataAcquireData(value_obj, &value_typeddata_type,
                                     &value_data, &value_typeddata_length));
  }
  const GLfloat* value = static_cast<const GLfloat*>(value_data);

  glUniform1fv(location, count, value);

  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataReleaseData(value_obj));
  }

  TRACE_END(glUniform1fv_);
}

void glUniform1i_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform1i_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t v0;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &v0));

  glUniform1i(location, v0);

  TRACE_END(glUniform1i_);
}

void glUniform1iv_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform1iv_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t count;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &count));

  Dart_Handle value_obj = HANDLE(Dart_GetNativeArgument(arguments, 2));
  void* value_data = nullptr;
  Dart_TypedData_Type value_typeddata_type;
  intptr_t value_typeddata_length;
  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataAcquireData(value_obj, &value_typeddata_type,
                                     &value_data, &value_typeddata_length));
  }
  const GLint* value = static_cast<const GLint*>(value_data);

  glUniform1iv(location, count, value);

  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataReleaseData(value_obj));
  }

  TRACE_END(glUniform1iv_);
}

void glUniform2f_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform2f_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  double v0;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 1, &v0));

  double v1;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 2, &v1));

  glUniform2f(location, v0, v1);

  TRACE_END(glUniform2f_);
}

void glUniform2fv_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform2fv_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t count;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &count));

  Dart_Handle value_obj = HANDLE(Dart_GetNativeArgument(arguments, 2));
  void* value_data = nullptr;
  Dart_TypedData_Type value_typeddata_type;
  intptr_t value_typeddata_length;
  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataAcquireData(value_obj, &value_typeddata_type,
                                     &value_data, &value_typeddata_length));
  }
  const GLfloat* value = static_cast<const GLfloat*>(value_data);

  glUniform2fv(location, count, value);

  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataReleaseData(value_obj));
  }

  TRACE_END(glUniform2fv_);
}

void glUniform2i_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform2i_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t v0;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &v0));

  int64_t v1;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &v1));

  glUniform2i(location, v0, v1);

  TRACE_END(glUniform2i_);
}

void glUniform2iv_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform2iv_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t count;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &count));

  Dart_Handle value_obj = HANDLE(Dart_GetNativeArgument(arguments, 2));
  void* value_data = nullptr;
  Dart_TypedData_Type value_typeddata_type;
  intptr_t value_typeddata_length;
  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataAcquireData(value_obj, &value_typeddata_type,
                                     &value_data, &value_typeddata_length));
  }
  const GLint* value = static_cast<const GLint*>(value_data);

  glUniform2iv(location, count, value);

  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataReleaseData(value_obj));
  }

  TRACE_END(glUniform2iv_);
}

void glUniform3f_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform3f_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  double v0;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 1, &v0));

  double v1;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 2, &v1));

  double v2;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 3, &v2));

  glUniform3f(location, v0, v1, v2);

  TRACE_END(glUniform3f_);
}

void glUniform3fv_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform3fv_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t count;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &count));

  Dart_Handle value_obj = HANDLE(Dart_GetNativeArgument(arguments, 2));
  void* value_data = nullptr;
  Dart_TypedData_Type value_typeddata_type;
  intptr_t value_typeddata_length;
  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataAcquireData(value_obj, &value_typeddata_type,
                                     &value_data, &value_typeddata_length));
  }
  const GLfloat* value = static_cast<const GLfloat*>(value_data);

  glUniform3fv(location, count, value);

  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataReleaseData(value_obj));
  }

  TRACE_END(glUniform3fv_);
}

void glUniform3i_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform3i_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t v0;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &v0));

  int64_t v1;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &v1));

  int64_t v2;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &v2));

  glUniform3i(location, v0, v1, v2);

  TRACE_END(glUniform3i_);
}

void glUniform3iv_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform3iv_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t count;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &count));

  Dart_Handle value_obj = HANDLE(Dart_GetNativeArgument(arguments, 2));
  void* value_data = nullptr;
  Dart_TypedData_Type value_typeddata_type;
  intptr_t value_typeddata_length;
  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataAcquireData(value_obj, &value_typeddata_type,
                                     &value_data, &value_typeddata_length));
  }
  const GLint* value = static_cast<const GLint*>(value_data);

  glUniform3iv(location, count, value);

  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataReleaseData(value_obj));
  }

  TRACE_END(glUniform3iv_);
}

void glUniform4f_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform4f_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  double v0;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 1, &v0));

  double v1;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 2, &v1));

  double v2;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 3, &v2));

  double v3;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 4, &v3));

  glUniform4f(location, v0, v1, v2, v3);

  TRACE_END(glUniform4f_);
}

void glUniform4fv_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform4fv_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t count;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &count));

  Dart_Handle value_obj = HANDLE(Dart_GetNativeArgument(arguments, 2));
  void* value_data = nullptr;
  Dart_TypedData_Type value_typeddata_type;
  intptr_t value_typeddata_length;
  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataAcquireData(value_obj, &value_typeddata_type,
                                     &value_data, &value_typeddata_length));
  }
  const GLfloat* value = static_cast<const GLfloat*>(value_data);

  glUniform4fv(location, count, value);

  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataReleaseData(value_obj));
  }

  TRACE_END(glUniform4fv_);
}

void glUniform4i_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform4i_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t v0;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &v0));

  int64_t v1;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &v1));

  int64_t v2;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &v2));

  int64_t v3;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 4, &v3));

  glUniform4i(location, v0, v1, v2, v3);

  TRACE_END(glUniform4i_);
}

void glUniform4iv_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniform4iv_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t count;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &count));

  Dart_Handle value_obj = HANDLE(Dart_GetNativeArgument(arguments, 2));
  void* value_data = nullptr;
  Dart_TypedData_Type value_typeddata_type;
  intptr_t value_typeddata_length;
  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataAcquireData(value_obj, &value_typeddata_type,
                                     &value_data, &value_typeddata_length));
  }
  const GLint* value = static_cast<const GLint*>(value_data);

  glUniform4iv(location, count, value);

  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataReleaseData(value_obj));
  }

  TRACE_END(glUniform4iv_);
}

void glUniformMatrix2fv_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniformMatrix2fv_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t count;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &count));

  int64_t transpose;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &transpose));

  Dart_Handle value_obj = HANDLE(Dart_GetNativeArgument(arguments, 3));
  void* value_data = nullptr;
  Dart_TypedData_Type value_typeddata_type;
  intptr_t value_typeddata_length;
  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataAcquireData(value_obj, &value_typeddata_type,
                                     &value_data, &value_typeddata_length));
  }
  const GLfloat* value = static_cast<const GLfloat*>(value_data);

  glUniformMatrix2fv(location, count, transpose, value);

  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataReleaseData(value_obj));
  }

  TRACE_END(glUniformMatrix2fv_);
}

void glUniformMatrix3fv_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniformMatrix3fv_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t count;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &count));

  int64_t transpose;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &transpose));

  Dart_Handle value_obj = HANDLE(Dart_GetNativeArgument(arguments, 3));
  void* value_data = nullptr;
  Dart_TypedData_Type value_typeddata_type;
  intptr_t value_typeddata_length;
  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataAcquireData(value_obj, &value_typeddata_type,
                                     &value_data, &value_typeddata_length));
  }
  const GLfloat* value = static_cast<const GLfloat*>(value_data);

  glUniformMatrix3fv(location, count, transpose, value);

  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataReleaseData(value_obj));
  }

  TRACE_END(glUniformMatrix3fv_);
}

void glUniformMatrix4fv_native(Dart_NativeArguments arguments) {
  TRACE_START(glUniformMatrix4fv_);
  int64_t location;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &location));

  int64_t count;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &count));

  int64_t transpose;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &transpose));

  Dart_Handle value_obj = HANDLE(Dart_GetNativeArgument(arguments, 3));
  void* value_data = nullptr;
  Dart_TypedData_Type value_typeddata_type;
  intptr_t value_typeddata_length;
  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataAcquireData(value_obj, &value_typeddata_type,
                                     &value_data, &value_typeddata_length));
  }
  const GLfloat* value = static_cast<const GLfloat*>(value_data);

  glUniformMatrix4fv(location, count, transpose, value);

  if (!Dart_IsNull(value_obj)) {
    HANDLE(Dart_TypedDataReleaseData(value_obj));
  }

  TRACE_END(glUniformMatrix4fv_);
}

void glUseProgram_native(Dart_NativeArguments arguments) {
  TRACE_START(glUseProgram_);
  int64_t program;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &program));

  glUseProgram(program);

  TRACE_END(glUseProgram_);
}

void glValidateProgram_native(Dart_NativeArguments arguments) {
  TRACE_START(glValidateProgram_);
  int64_t program;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &program));

  glValidateProgram(program);

  TRACE_END(glValidateProgram_);
}

void glVertexAttrib1f_native(Dart_NativeArguments arguments) {
  TRACE_START(glVertexAttrib1f_);
  int64_t index;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &index));

  double x;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 1, &x));

  glVertexAttrib1f(index, x);

  TRACE_END(glVertexAttrib1f_);
}

void glVertexAttrib1fv_native(Dart_NativeArguments arguments) {
  TRACE_START(glVertexAttrib1fv_);
  int64_t index;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &index));

  Dart_Handle v_obj = HANDLE(Dart_GetNativeArgument(arguments, 1));
  void* v_data = nullptr;
  Dart_TypedData_Type v_typeddata_type;
  intptr_t v_typeddata_length;
  if (!Dart_IsNull(v_obj)) {
    HANDLE(Dart_TypedDataAcquireData(v_obj, &v_typeddata_type, &v_data,
                                     &v_typeddata_length));
  }
  const GLfloat* v = static_cast<const GLfloat*>(v_data);

  glVertexAttrib1fv(index, v);

  if (!Dart_IsNull(v_obj)) {
    HANDLE(Dart_TypedDataReleaseData(v_obj));
  }

  TRACE_END(glVertexAttrib1fv_);
}

void glVertexAttrib2f_native(Dart_NativeArguments arguments) {
  TRACE_START(glVertexAttrib2f_);
  int64_t index;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &index));

  double x;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 1, &x));

  double y;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 2, &y));

  glVertexAttrib2f(index, x, y);

  TRACE_END(glVertexAttrib2f_);
}

void glVertexAttrib2fv_native(Dart_NativeArguments arguments) {
  TRACE_START(glVertexAttrib2fv_);
  int64_t index;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &index));

  Dart_Handle v_obj = HANDLE(Dart_GetNativeArgument(arguments, 1));
  void* v_data = nullptr;
  Dart_TypedData_Type v_typeddata_type;
  intptr_t v_typeddata_length;
  if (!Dart_IsNull(v_obj)) {
    HANDLE(Dart_TypedDataAcquireData(v_obj, &v_typeddata_type, &v_data,
                                     &v_typeddata_length));
  }
  const GLfloat* v = static_cast<const GLfloat*>(v_data);

  glVertexAttrib2fv(index, v);

  if (!Dart_IsNull(v_obj)) {
    HANDLE(Dart_TypedDataReleaseData(v_obj));
  }

  TRACE_END(glVertexAttrib2fv_);
}

void glVertexAttrib3f_native(Dart_NativeArguments arguments) {
  TRACE_START(glVertexAttrib3f_);
  int64_t index;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &index));

  double x;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 1, &x));

  double y;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 2, &y));

  double z;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 3, &z));

  glVertexAttrib3f(index, x, y, z);

  TRACE_END(glVertexAttrib3f_);
}

void glVertexAttrib3fv_native(Dart_NativeArguments arguments) {
  TRACE_START(glVertexAttrib3fv_);
  int64_t index;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &index));

  Dart_Handle v_obj = HANDLE(Dart_GetNativeArgument(arguments, 1));
  void* v_data = nullptr;
  Dart_TypedData_Type v_typeddata_type;
  intptr_t v_typeddata_length;
  if (!Dart_IsNull(v_obj)) {
    HANDLE(Dart_TypedDataAcquireData(v_obj, &v_typeddata_type, &v_data,
                                     &v_typeddata_length));
  }
  const GLfloat* v = static_cast<const GLfloat*>(v_data);

  glVertexAttrib3fv(index, v);

  if (!Dart_IsNull(v_obj)) {
    HANDLE(Dart_TypedDataReleaseData(v_obj));
  }

  TRACE_END(glVertexAttrib3fv_);
}

void glVertexAttrib4f_native(Dart_NativeArguments arguments) {
  TRACE_START(glVertexAttrib4f_);
  int64_t index;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &index));

  double x;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 1, &x));

  double y;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 2, &y));

  double z;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 3, &z));

  double w;
  HANDLE(Dart_GetNativeDoubleArgument(arguments, 4, &w));

  glVertexAttrib4f(index, x, y, z, w);

  TRACE_END(glVertexAttrib4f_);
}

void glVertexAttrib4fv_native(Dart_NativeArguments arguments) {
  TRACE_START(glVertexAttrib4fv_);
  int64_t index;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &index));

  Dart_Handle v_obj = HANDLE(Dart_GetNativeArgument(arguments, 1));
  void* v_data = nullptr;
  Dart_TypedData_Type v_typeddata_type;
  intptr_t v_typeddata_length;
  if (!Dart_IsNull(v_obj)) {
    HANDLE(Dart_TypedDataAcquireData(v_obj, &v_typeddata_type, &v_data,
                                     &v_typeddata_length));
  }
  const GLfloat* v = static_cast<const GLfloat*>(v_data);

  glVertexAttrib4fv(index, v);

  if (!Dart_IsNull(v_obj)) {
    HANDLE(Dart_TypedDataReleaseData(v_obj));
  }

  TRACE_END(glVertexAttrib4fv_);
}

void glViewport_native(Dart_NativeArguments arguments) {
  TRACE_START(glViewport_);
  int64_t x;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &x));

  int64_t y;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &y));

  int64_t width;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &width));

  int64_t height;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &height));

  glViewport(x, y, width, height);

  TRACE_END(glViewport_);
}

void glProgramBinaryOES_native(Dart_NativeArguments arguments) {
  TRACE_START(glProgramBinaryOES_);
  int64_t program;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &program));

  int64_t binaryFormat;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &binaryFormat));

  Dart_Handle binary_obj = HANDLE(Dart_GetNativeArgument(arguments, 2));
  void* binary_data = nullptr;
  Dart_TypedData_Type binary_typeddata_type;
  intptr_t binary_typeddata_length;
  if (!Dart_IsNull(binary_obj)) {
    HANDLE(Dart_TypedDataAcquireData(binary_obj, &binary_typeddata_type,
                                     &binary_data, &binary_typeddata_length));
  }
  const void* binary = static_cast<const void*>(binary_data);

  int64_t length;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &length));

  glProgramBinaryOES(program, binaryFormat, binary, length);

  if (!Dart_IsNull(binary_obj)) {
    HANDLE(Dart_TypedDataReleaseData(binary_obj));
  }

  TRACE_END(glProgramBinaryOES_);
}

void glUnmapBufferOES_native(Dart_NativeArguments arguments) {
  TRACE_START(glUnmapBufferOES_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  GLboolean ret = glUnmapBufferOES(target);
  Dart_SetBooleanReturnValue(arguments, ret);
  TRACE_END(glUnmapBufferOES_);
}

void glBindVertexArrayOES_native(Dart_NativeArguments arguments) {
  TRACE_START(glBindVertexArrayOES_);
  int64_t array;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &array));

  glBindVertexArrayOES(array);

  TRACE_END(glBindVertexArrayOES_);
}

void glDeleteVertexArraysOES_native(Dart_NativeArguments arguments) {
  TRACE_START(glDeleteVertexArraysOES_);
  Dart_Handle values_obj = HANDLE(Dart_GetNativeArgument(arguments, 0));
  GLuint* values = NULL;
  intptr_t n = 0;
  HANDLE(Dart_ListLength(values_obj, &n));
  values = static_cast<GLuint*>(malloc(sizeof(GLuint) * n));
  for (int i = 0; i < n; i++) {
    Dart_Handle i_obj = HANDLE(Dart_ListGetAt(values_obj, i));
    HANDLE(Dart_IntegerToUInt(i_obj, &values[i]));
  }
  glDeleteVertexArraysOES(n, values);
  free(values);

  TRACE_END(glDeleteVertexArraysOES_);
}

void glGenVertexArraysOES_native(Dart_NativeArguments arguments) {
  TRACE_START(glGenVertexArraysOES_);
  int64_t n;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &n));

  GLuint* values = static_cast<GLuint*>(malloc(sizeof(GLuint) * n));
  glGenVertexArraysOES(n, values);
  Dart_Handle values_obj = Dart_NewList(n);
  for (int i = 0; i < n; i++) {
    Dart_Handle i_obj = HANDLE(Dart_NewInteger(values[i]));
    HANDLE(Dart_ListSetAt(values_obj, i, i_obj));
  }
  Dart_SetReturnValue(arguments, values_obj);
  free(values);

  TRACE_END(glGenVertexArraysOES_);
}

void glIsVertexArrayOES_native(Dart_NativeArguments arguments) {
  TRACE_START(glIsVertexArrayOES_);
  int64_t array;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &array));

  GLboolean ret = glIsVertexArrayOES(array);
  Dart_SetBooleanReturnValue(arguments, ret);
  TRACE_END(glIsVertexArrayOES_);
}

void glRenderbufferStorageMultisampleEXT_native(
    Dart_NativeArguments arguments) {
  TRACE_START(glRenderbufferStorageMultisampleEXT_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t samples;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &samples));

  int64_t internalformat;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &internalformat));

  int64_t width;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &width));

  int64_t height;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 4, &height));

  glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width,
                                      height);

  TRACE_END(glRenderbufferStorageMultisampleEXT_);
}

void glFramebufferTexture2DMultisampleEXT_native(
    Dart_NativeArguments arguments) {
  TRACE_START(glFramebufferTexture2DMultisampleEXT_);
  int64_t target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &target));

  int64_t attachment;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 1, &attachment));

  int64_t textarget;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 2, &textarget));

  int64_t texture;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 3, &texture));

  int64_t level;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 4, &level));

  int64_t samples;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 5, &samples));

  glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture,
                                       level, samples);

  TRACE_END(glFramebufferTexture2DMultisampleEXT_);
}

void glGetGraphicsResetStatusEXT_native(Dart_NativeArguments arguments) {
  TRACE_START(glGetGraphicsResetStatusEXT_);
  GLenum ret = glGetGraphicsResetStatusEXT();
  Dart_SetIntegerReturnValue(arguments, ret);
  TRACE_END(glGetGraphicsResetStatusEXT_);
}

void glTexDirectInvalidateVIV_native(Dart_NativeArguments arguments) {
  TRACE_START(glTexDirectInvalidateVIV_);
  int64_t Target;
  HANDLE(Dart_GetNativeIntegerArgument(arguments, 0, &Target));

  glTexDirectInvalidateVIV(Target);

  TRACE_END(glTexDirectInvalidateVIV_);
}