Index: runtime/embedders/openglui/common/extension.cc |
=================================================================== |
--- runtime/embedders/openglui/common/extension.cc (revision 0) |
+++ runtime/embedders/openglui/common/extension.cc (revision 0) |
@@ -0,0 +1,993 @@ |
+// 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 "embedders/openglui/common/extension.h" |
+ |
+#include <stdio.h> |
+#include <stdlib.h> |
+#include <string.h> |
+ |
+#include "embedders/openglui/common/log.h" |
+#include "embedders/openglui/common/opengl.h" |
+#include "include/dart_api.h" |
+ |
+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) { |
+ if (error == GL_INVALID_ENUM) { |
+ LOGE("%s: An unacceptable value is given for an enumerated argument.", |
+ function); |
+ } else if (error == GL_INVALID_VALUE) { |
+ LOGE("%s: A numeric argument is out of range.", function); |
+ } else if (error == GL_INVALID_OPERATION) { |
+ LOGE("%s: The specified operation is not allowed in the current state.", |
+ function); |
+ } else if (error == GL_INVALID_FRAMEBUFFER_OPERATION) { |
+ LOGE("%s: The framebuffer object is not complete.", function); |
+ } else if (error == GL_OUT_OF_MEMORY) { |
+ LOGE("%s: There is not enough memory left to execute the command.", |
+ function); |
+ } else { |
+ LOGE("ERROR!: %s returns %d", function, error); |
+ } |
+ } |
+} |
+ |
+const char* GetArgAsString(Dart_NativeArguments arguments, int idx) { |
+ Dart_Handle whatHandle = HandleError(Dart_GetNativeArgument(arguments, idx)); |
+ uint8_t* str; |
+ intptr_t length; |
+ HandleError(Dart_StringLength(whatHandle, &length)); |
+ HandleError(Dart_StringToUTF8(whatHandle, &str, &length)); |
+ str[length] = 0; |
+ return const_cast<const char*>(reinterpret_cast<char*>(str)); |
+} |
+ |
+double GetArgAsDouble(Dart_NativeArguments arguments, int index) { |
+ Dart_Handle handle = HandleError(Dart_GetNativeArgument(arguments, index)); |
+ if (Dart_IsDouble(handle)) { |
+ double v; |
+ HandleError(Dart_DoubleValue(handle, &v)); |
+ return v; |
+ } |
+ if (Dart_IsInteger(handle)) { |
+ int64_t v; |
+ HandleError(Dart_IntegerToInt64(handle, &v)); |
+ return static_cast<double>(v); |
+ } |
+ LOGE("Argument at index %d has non-numeric type", index); |
+ Dart_ThrowException(Dart_NewStringFromCString("Numeric argument expected.")); |
+ return 0; |
+} |
+ |
+int64_t GetArgAsInt(Dart_NativeArguments arguments, int index) { |
+ Dart_Handle handle = HandleError(Dart_GetNativeArgument(arguments, index)); |
+ if (Dart_IsDouble(handle)) { |
+ double v; |
+ HandleError(Dart_DoubleValue(handle, &v)); |
+ return static_cast<int64_t>(v); |
+ } |
+ if (Dart_IsInteger(handle)) { |
+ int64_t v; |
+ HandleError(Dart_IntegerToInt64(handle, &v)); |
+ return v; |
+ } |
+ LOGE("Argument at index %d has non-numeric type", index); |
+ Dart_ThrowException(Dart_NewStringFromCString("Numeric argument expected.")); |
+ return 0; |
+} |
+ |
+bool GetArgAsBool(Dart_NativeArguments arguments, int index) { |
+ Dart_Handle handle = HandleError(Dart_GetNativeArgument(arguments, index)); |
+ if (Dart_IsBoolean(handle)) { |
+ bool v; |
+ HandleError(Dart_BooleanValue(handle, &v)); |
+ return v; |
+ } |
+ LOGI("Argument at index %d has non-Boolean type", index); |
+ Dart_ThrowException(Dart_NewStringFromCString("Boolean argument expected.")); |
+ return false; |
+} |
+ |
+GLint* GetArgsAsGLintList(Dart_NativeArguments arguments, int index, |
+ int* len_out) { |
+ Dart_Handle argHandle = HandleError(Dart_GetNativeArgument(arguments, index)); |
+ if (Dart_IsList(argHandle)) { |
+ intptr_t 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; |
+ } |
+ *len_out = len; |
+ return list; |
+ } |
+ LOGI("Argument at index %d has non-List type", index); |
+ Dart_ThrowException(Dart_NewStringFromCString("List argument expected.")); |
+ return NULL; |
+} |
+ |
+GLfloat* GetArgsAsFloatList(Dart_NativeArguments arguments, int index, |
+ int* len_out) { |
+ 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)) { |
+ intptr_t 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; |
+ } |
+ *len_out = len; |
+ return list; |
+ } |
+ LOGI("Argument at index %d has non-List type", index); |
+ Dart_ThrowException(Dart_NewStringFromCString("List argument expected.")); |
+ return NULL; |
+} |
+ |
+void SetBoolReturnValue(Dart_NativeArguments arguments, bool b) { |
+ Dart_Handle result = HandleError(Dart_NewBoolean(b)); |
+ Dart_SetReturnValue(arguments, result); |
+} |
+ |
+void SetIntReturnValue(Dart_NativeArguments arguments, int v) { |
+ Dart_Handle result = HandleError(Dart_NewInteger(v)); |
+ Dart_SetReturnValue(arguments, result); |
+} |
+ |
+void SetStringReturnValue(Dart_NativeArguments arguments, const char* s) { |
+ Dart_Handle result = HandleError(Dart_NewStringFromCString(s)); |
+ Dart_SetReturnValue(arguments, result); |
+} |
+ |
+void Log(Dart_NativeArguments arguments) { |
+ Dart_EnterScope(); |
+ LOGI("%s", GetArgAsString(arguments, 0)); |
+ Dart_ExitScope(); |
+} |
+ |
+void LogError(Dart_NativeArguments arguments) { |
+ Dart_EnterScope(); |
+ LOGE("%s", GetArgAsString(arguments, 0)); |
+ Dart_ExitScope(); |
+} |
+ |
+void SystemRand(Dart_NativeArguments arguments) { |
+ Dart_EnterScope(); |
+ SetIntReturnValue(arguments, rand()); |
+ 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; |
+ } |
+ } |
+ SetBoolReturnValue(arguments, success); |
+ Dart_ExitScope(); |
+} |
+ |
+void SwapBuffers(Dart_NativeArguments arguments) { |
+ LOGI("SwapBuffers"); |
+ Dart_EnterScope(); |
+ GLSwapBuffers(); |
+ CheckGLError("GLSwapBuffers"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLAttachShader(Dart_NativeArguments arguments) { |
+ LOGI("GLAttachShader"); |
+ Dart_EnterScope(); |
+ |
+ int64_t program = GetArgAsInt(arguments, 0); |
+ int64_t shader = GetArgAsInt(arguments, 1); |
+ |
+ glAttachShader(program, shader); |
+ CheckGLError("glAttachShader"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLBindBuffer(Dart_NativeArguments arguments) { |
+ LOGI("GLBindBuffer"); |
+ Dart_EnterScope(); |
+ |
+ int64_t target = GetArgAsInt(arguments, 0); |
+ int64_t buffer = GetArgAsInt(arguments, 1); |
+ |
+ glBindBuffer(target, buffer); |
+ CheckGLError("glBindBuffer"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLBufferData(Dart_NativeArguments arguments) { |
+ LOGI("GLBufferData"); |
+ Dart_EnterScope(); |
+ |
+ int64_t target = GetArgAsInt(arguments, 0); |
+ |
+ Dart_Handle dataHandle = HandleError(Dart_GetNativeArgument(arguments, 1)); |
+ intptr_t size; |
+ HandleError(Dart_ListLength(dataHandle, &size)); |
+ |
+ LOGI("Size: %d", static_cast<int>(size)); |
+ |
+ // TODO(vsm): No guarantee that this is a float! |
+ float* data = new float[size]; |
+ 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); |
+ LOGI("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(data[0]), data, usage); |
+ CheckGLError("glBufferData"); |
+ delete[] data; |
+ Dart_ExitScope(); |
+} |
+ |
+void GLCompileShader(Dart_NativeArguments arguments) { |
+ LOGI("GLCompileShader"); |
+ Dart_EnterScope(); |
+ int64_t shader = GetArgAsInt(arguments, 0); |
+ glCompileShader(shader); |
+ CheckGLError("glCompileShader"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLCreateBuffer(Dart_NativeArguments arguments) { |
+ LOGI("GLCreateBuffer"); |
+ Dart_EnterScope(); |
+ GLuint buffer; |
+ glGenBuffers(1, &buffer); |
+ CheckGLError("glGenBuffers"); |
+ SetIntReturnValue(arguments, buffer); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLCreateProgram(Dart_NativeArguments arguments) { |
+ LOGI("GLCreateProgram"); |
+ Dart_EnterScope(); |
+ int64_t program = glCreateProgram(); |
+ CheckGLError("glCreateProgram"); |
+ SetIntReturnValue(arguments, program); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLCreateShader(Dart_NativeArguments arguments) { |
+ LOGI("GLCreateShader"); |
+ Dart_EnterScope(); |
+ int64_t type = GetArgAsInt(arguments, 0); |
+ int64_t shader = glCreateShader((GLenum)type); |
+ CheckGLError("glCreateShader"); |
+ SetIntReturnValue(arguments, shader); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLDrawArrays(Dart_NativeArguments arguments) { |
+ LOGI("GLDrawArrays"); |
+ Dart_EnterScope(); |
+ |
+ int64_t mode = GetArgAsInt(arguments, 0); |
+ int64_t first = GetArgAsInt(arguments, 1); |
+ int64_t count = GetArgAsInt(arguments, 2); |
+ |
+ glDrawArrays(mode, first, count); |
+ CheckGLError("glDrawArrays"); |
+ Dart_ExitScope(); |
+ LOGI("Done GLDrawArrays"); |
+} |
+ |
+void GLEnableVertexAttribArray(Dart_NativeArguments arguments) { |
+ LOGI("GLEnableVertexAttribArray"); |
+ Dart_EnterScope(); |
+ |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ |
+ glEnableVertexAttribArray(location); |
+ CheckGLError("glEnableVertexAttribArray"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLGetAttribLocation(Dart_NativeArguments arguments) { |
+ LOGI("GLGetAttribLocation"); |
+ Dart_EnterScope(); |
+ |
+ int64_t program = GetArgAsInt(arguments, 0); |
+ |
+ Dart_Handle nameHandle = HandleError(Dart_GetNativeArgument(arguments, 1)); |
+ intptr_t length; |
+ HandleError(Dart_StringLength(nameHandle, &length)); |
+ uint8_t* str; |
+ HandleError(Dart_StringToUTF8(nameHandle, &str, &length)); |
+ str[length] = 0; |
+ |
+ int64_t location = glGetAttribLocation(program, |
+ const_cast<const GLchar*>(reinterpret_cast<GLchar*>(str))); |
+ CheckGLError("glGetAttribLocation"); |
+ SetIntReturnValue(arguments, location); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLGetError(Dart_NativeArguments arguments) { |
+ LOGI("GLGetError"); |
+ Dart_EnterScope(); |
+ SetIntReturnValue(arguments, glGetError()); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLGetProgramParameter(Dart_NativeArguments arguments) { |
+ LOGI("GLGetProgramParameter"); |
+ Dart_EnterScope(); |
+ |
+ int64_t program = GetArgAsInt(arguments, 0); |
+ int64_t param = GetArgAsInt(arguments, 1); |
+ |
+ GLint value = -1; |
+ glGetProgramiv(program, param, &value); |
+ CheckGLError("glGetProgramiv"); |
+ |
+ SetIntReturnValue(arguments, value); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLGetShaderParameter(Dart_NativeArguments arguments) { |
+ LOGI("GLGetShaderParameter"); |
+ Dart_EnterScope(); |
+ |
+ int64_t shader = GetArgAsInt(arguments, 0); |
+ int64_t param = GetArgAsInt(arguments, 1); |
+ |
+ GLint value = -1; |
+ glGetShaderiv((GLuint)shader, (GLenum)param, &value); |
+ CheckGLError("glGetShaderiv"); |
+ |
+ SetIntReturnValue(arguments, value); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLGetShaderInfoLog(Dart_NativeArguments arguments) { |
+ LOGI("GLGetShaderInfoLog"); |
+ Dart_EnterScope(); |
+ |
+ int64_t shader = GetArgAsInt(arguments, 0); |
+ |
+ GLint infoLogLength = 0; |
+ glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength); |
+ GLchar* strInfoLog = new GLchar[infoLogLength + 1]; |
+ glGetShaderInfoLog(shader, infoLogLength, NULL, strInfoLog); |
+ strInfoLog[infoLogLength] = 0; |
+ |
+ SetStringReturnValue(arguments, strInfoLog); |
+ Dart_ExitScope(); |
+ delete[] strInfoLog; |
+} |
+ |
+void GLGetProgramInfoLog(Dart_NativeArguments arguments) { |
+ LOGI("GLGetProgramInfoLog"); |
+ Dart_EnterScope(); |
+ |
+ int64_t program = GetArgAsInt(arguments, 0); |
+ |
+ GLint infoLogLength; |
+ glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength); |
+ |
+ GLchar* strInfoLog = new GLchar[infoLogLength + 1]; |
+ glGetProgramInfoLog(program, infoLogLength, NULL, strInfoLog); |
+ strInfoLog[infoLogLength] = 0; |
+ |
+ SetStringReturnValue(arguments, strInfoLog); |
+ Dart_ExitScope(); |
+ delete[] strInfoLog; |
+} |
+ |
+void GLGetUniformLocation(Dart_NativeArguments arguments) { |
+ LOGI("GLGetUniformLocation"); |
+ Dart_EnterScope(); |
+ |
+ int64_t program = GetArgAsInt(arguments, 0); |
+ |
+ |
+ Dart_Handle nameHandle = HandleError(Dart_GetNativeArgument(arguments, 1)); |
+ intptr_t length; |
+ HandleError(Dart_StringLength(nameHandle, &length)); |
+ uint8_t* str; |
+ HandleError(Dart_StringToUTF8(nameHandle, &str, &length)); |
+ str[length] = 0; |
+ |
+ int64_t location = glGetUniformLocation(program, |
+ const_cast<const GLchar*>(reinterpret_cast<GLchar*>(str))); |
+ CheckGLError("glGetUniformLocation"); |
+ SetIntReturnValue(arguments, location); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLLinkProgram(Dart_NativeArguments arguments) { |
+ LOGI("GLLinkProgram"); |
+ Dart_EnterScope(); |
+ int64_t program = GetArgAsInt(arguments, 0); |
+ glLinkProgram(program); |
+ CheckGLError("glLinkProgram"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLShaderSource(Dart_NativeArguments arguments) { |
+ LOGI("GLShaderSource"); |
+ Dart_EnterScope(); |
+ |
+ int64_t shader = GetArgAsInt(arguments, 0); |
+ |
+ Dart_Handle sourceHandle = HandleError(Dart_GetNativeArgument(arguments, 1)); |
+ intptr_t length[1]; |
+ HandleError(Dart_StringLength(sourceHandle, length)); |
+ LOGI("Source length is %d", static_cast<int>(length[0])); |
+ uint8_t* str[1]; |
+ HandleError(Dart_StringToUTF8(sourceHandle, &str[0], length)); |
+ LOGI("Converted length is %d", static_cast<int>(length[0])); |
+ str[0][*length] = 0; |
+ |
+ const GLchar* source = |
+ const_cast<const GLchar*>(reinterpret_cast<GLchar*>(str[0])); |
+ LOGI("Source: %s", source); |
+ glShaderSource(shader, 1, |
+ const_cast<const GLchar**>(reinterpret_cast<GLchar**>(str)), NULL); |
+ CheckGLError("glShaderSource"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUseProgram(Dart_NativeArguments arguments) { |
+ LOGI("GLUseProgram"); |
+ Dart_EnterScope(); |
+ int64_t program = GetArgAsInt(arguments, 0); |
+ glUseProgram(program); |
+ CheckGLError("glUseProgram"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform1i(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform1i"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ int64_t v0 = GetArgAsInt(arguments, 1); |
+ glUniform1i(location, v0); |
+ CheckGLError("glUniform1i"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform2i(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform2i"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ int64_t v0 = GetArgAsInt(arguments, 1); |
+ int64_t v1 = GetArgAsInt(arguments, 2); |
+ glUniform2i(location, v0, v1); |
+ CheckGLError("glUniform2i"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform3i(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform3i"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ int64_t v0 = GetArgAsInt(arguments, 1); |
+ int64_t v1 = GetArgAsInt(arguments, 2); |
+ int64_t v2 = GetArgAsInt(arguments, 3); |
+ glUniform3i(location, v0, v1, v2); |
+ CheckGLError("glUniform3i"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform4i(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform4i"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ int64_t v0 = GetArgAsInt(arguments, 1); |
+ int64_t v1 = GetArgAsInt(arguments, 2); |
+ int64_t v2 = GetArgAsInt(arguments, 3); |
+ int64_t v3 = GetArgAsInt(arguments, 4); |
+ glUniform4i(location, v0, v1, v2, v3); |
+ CheckGLError("glUniform4i"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform1f(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform1f"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ double v0 = GetArgAsDouble(arguments, 1); |
+ glUniform1f(location, v0); |
+ CheckGLError("glUniform1f"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform2f(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform2f"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ double v0 = GetArgAsDouble(arguments, 1); |
+ double v1 = GetArgAsDouble(arguments, 2); |
+ glUniform2f(location, v0, v1); |
+ CheckGLError("glUniform2f"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform3f(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform3f"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ double v0 = GetArgAsDouble(arguments, 1); |
+ double v1 = GetArgAsDouble(arguments, 2); |
+ double v2 = GetArgAsDouble(arguments, 3); |
+ glUniform3f(location, v0, v1, v2); |
+ CheckGLError("glUniform3f"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform4f(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform4f"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ double v0 = GetArgAsDouble(arguments, 1); |
+ double v1 = GetArgAsDouble(arguments, 2); |
+ double v2 = GetArgAsDouble(arguments, 3); |
+ double v3 = GetArgAsDouble(arguments, 4); |
+ glUniform4f(location, v0, v1, v2, v3); |
+ CheckGLError("glUniform4f"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform1iv(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform1iv"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ int len; |
+ GLint* list = GetArgsAsGLintList(arguments, 1, &len); |
+ if (list != NULL) { |
+ glUniform1iv(location, len, list); |
+ delete [] list; |
+ CheckGLError("glUniform1iv"); |
+ } |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform2iv(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform2iv"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ int len; |
+ GLint* list = GetArgsAsGLintList(arguments, 1, &len); |
+ if (list != NULL) { |
+ glUniform2iv(location, len / 2, list); |
+ delete [] list; |
+ CheckGLError("glUniform2iv"); |
+ } |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform3iv(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform3iv"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ int len; |
+ GLint* list = GetArgsAsGLintList(arguments, 1, &len); |
+ if (list != NULL) { |
+ glUniform3iv(location, len / 3, list); |
+ delete [] list; |
+ CheckGLError("glUniform3iv"); |
+ } |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform4iv(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform4iv"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ int len; |
+ GLint* list = GetArgsAsGLintList(arguments, 1, &len); |
+ if (list != NULL) { |
+ glUniform1iv(location, len / 4, list); |
+ delete [] list; |
+ CheckGLError("glUniform4iv"); |
+ } |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform1fv(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform1fv"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ int len; |
+ GLfloat* list = GetArgsAsFloatList(arguments, 1, &len); |
+ if (list != NULL) { |
+ glUniform1fv(location, len, list); |
+ delete [] list; |
+ CheckGLError("glUniform1fv"); |
+ } |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform2fv(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform2fv"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ int len; |
+ GLfloat* list = GetArgsAsFloatList(arguments, 1, &len); |
+ if (list != NULL) { |
+ glUniform2fv(location, len / 2, list); |
+ delete [] list; |
+ CheckGLError("glUniform2fv"); |
+ } |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform3fv(Dart_NativeArguments arguments) { |
+ LOGI("GLUniform3fv"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ int len; |
+ GLfloat* list = GetArgsAsFloatList(arguments, 1, &len); |
+ if (list != NULL) { |
+ glUniform3fv(location, len / 3, list); |
+ delete [] list; |
+ CheckGLError("glUniform3fv"); |
+ } |
+ Dart_ExitScope(); |
+} |
+ |
+void GLUniform4fv(Dart_NativeArguments arguments) { |
+ LOGI("In GLUniform4fv"); |
+ Dart_EnterScope(); |
+ int64_t location = GetArgAsInt(arguments, 0); |
+ int len; |
+ GLfloat* list = GetArgsAsFloatList(arguments, 1, &len); |
+ if (list != NULL) { |
+ glUniform4fv(location, len / 4, list); |
+ delete [] list; |
+ CheckGLError("glUniform4fv"); |
+ } |
+ Dart_ExitScope(); |
+} |
+ |
+void GLViewport(Dart_NativeArguments arguments) { |
+ LOGI("GLViewport"); |
+ Dart_EnterScope(); |
+ int64_t x = GetArgAsInt(arguments, 0); |
+ int64_t y = GetArgAsInt(arguments, 1); |
+ int64_t width = GetArgAsInt(arguments, 2); |
+ int64_t height = GetArgAsInt(arguments, 3); |
+ glViewport(x, y, width, height); |
+ CheckGLError("glViewPort"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLVertexAttribPointer(Dart_NativeArguments arguments) { |
+ LOGI("GLVertexAttribPointer"); |
+ Dart_EnterScope(); |
+ int64_t index = GetArgAsInt(arguments, 0); |
+ int64_t size = GetArgAsInt(arguments, 1); |
+ int64_t type = GetArgAsInt(arguments, 2); |
+ bool normalized = GetArgAsBool(arguments, 3); |
+ int64_t stride = GetArgAsInt(arguments, 4); |
+ |
+ 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, size, type, normalized, stride, pointer); |
+ CheckGLError("glVertexAttribPointer"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLClearColor(Dart_NativeArguments arguments) { |
+ LOGI("GLClearColor"); |
+ Dart_EnterScope(); |
+ double red = GetArgAsDouble(arguments, 0); |
+ double green = GetArgAsDouble(arguments, 1); |
+ double blue = GetArgAsDouble(arguments, 2); |
+ double alpha = GetArgAsDouble(arguments, 3); |
+ glClearColor(red, green, blue, alpha); |
+ CheckGLError("glClearColor"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLClearDepth(Dart_NativeArguments arguments) { |
+ LOGI("GLClearDepth"); |
+ Dart_EnterScope(); |
+ double depth = GetArgAsDouble(arguments, 0); |
+#if defined(__ANDROID__) |
+ glClearDepthf(depth); |
+#else |
+ glClearDepth(depth); |
+#endif |
+ CheckGLError("glClearDepth"); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLClear(Dart_NativeArguments arguments) { |
+ LOGI("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 ReturnGLIntConstant(Dart_NativeArguments arguments, int c) { |
+ Dart_EnterScope(); |
+ SetIntReturnValue(arguments, c); |
+ Dart_ExitScope(); |
+} |
+ |
+void GLArrayBuffer(Dart_NativeArguments arguments) { |
+ ReturnGLIntConstant(arguments, GL_ARRAY_BUFFER); |
+} |
+ |
+void GLColorBufferBit(Dart_NativeArguments arguments) { |
+ ReturnGLIntConstant(arguments, GL_COLOR_BUFFER_BIT); |
+} |
+ |
+void GLCompileStatus(Dart_NativeArguments arguments) { |
+ ReturnGLIntConstant(arguments, GL_COMPILE_STATUS); |
+} |
+ |
+void GLDeleteStatus(Dart_NativeArguments arguments) { |
+ ReturnGLIntConstant(arguments, GL_DELETE_STATUS); |
+} |
+ |
+void GLDepthBufferBit(Dart_NativeArguments arguments) { |
+ ReturnGLIntConstant(arguments, GL_DEPTH_BUFFER_BIT); |
+} |
+ |
+void GLFloat(Dart_NativeArguments arguments) { |
+ ReturnGLIntConstant(arguments, GL_FLOAT); |
+} |
+ |
+void GLFragmentShader(Dart_NativeArguments arguments) { |
+ ReturnGLIntConstant(arguments, GL_FRAGMENT_SHADER); |
+} |
+ |
+void GLLinkStatus(Dart_NativeArguments arguments) { |
+ ReturnGLIntConstant(arguments, GL_LINK_STATUS); |
+} |
+ |
+void GLStaticDraw(Dart_NativeArguments arguments) { |
+ ReturnGLIntConstant(arguments, GL_STATIC_DRAW); |
+} |
+ |
+void GLTriangleStrip(Dart_NativeArguments arguments) { |
+ ReturnGLIntConstant(arguments, GL_TRIANGLE_STRIP); |
+} |
+ |
+void GLTriangles(Dart_NativeArguments arguments) { |
+ ReturnGLIntConstant(arguments, GL_TRIANGLES); |
+} |
+ |
+void GLTrue(Dart_NativeArguments arguments) { |
+ ReturnGLIntConstant(arguments, GL_TRUE); |
+} |
+ |
+void GLValidateStatus(Dart_NativeArguments arguments) { |
+ ReturnGLIntConstant(arguments, GL_VALIDATE_STATUS); |
+} |
+ |
+void GLVertexShader(Dart_NativeArguments arguments) { |
+ ReturnGLIntConstant(arguments, GL_VERTEX_SHADER); |
+} |
+ |
+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(); |
+} |
+ |
+void PlayBackground(Dart_NativeArguments arguments) { |
+ LOGI("PlayBackground"); |
+ Dart_EnterScope(); |
+ const char* what = GetArgAsString(arguments, 0); |
+ int rtn = PlayBackgroundSound(what); |
+ SetIntReturnValue(arguments, rtn); |
+ Dart_ExitScope(); |
+} |
+ |
+void StopBackground(Dart_NativeArguments arguments) { |
+ LOGI("StopBackground"); |
+ Dart_EnterScope(); |
+ StopBackgroundSound(); |
+ Dart_ExitScope(); |
+} |
+ |
+void LoadSample(Dart_NativeArguments arguments) { |
+ LOGI("LoadSample"); |
+ Dart_EnterScope(); |
+ const char* what = GetArgAsString(arguments, 0); |
+ int rtn = LoadSoundSample(what); |
+ SetIntReturnValue(arguments, rtn); |
+ Dart_ExitScope(); |
+} |
+ |
+void PlaySample(Dart_NativeArguments arguments) { |
+ LOGI("PlaySample"); |
+ Dart_EnterScope(); |
+ const char* what = GetArgAsString(arguments, 0); |
+ int rtn = PlaySoundSample(what); |
+ SetIntReturnValue(arguments, rtn); |
+ Dart_ExitScope(); |
+} |
+ |
+struct FunctionLookup { |
+ const char* name; |
+ Dart_NativeFunction function; |
+}; |
+ |
+FunctionLookup function_list[] = { |
+ {"Log", Log}, |
+ {"LogError", LogError}, |
+ {"SystemRand", SystemRand}, |
+ {"SystemSrand", SystemSrand}, |
+ {"SwapBuffers", SwapBuffers}, |
+ {"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}, |
+ {"GLDeleteStatus", GLDeleteStatus}, |
+ {"GLDepthBufferBit", GLDepthBufferBit}, |
+ {"GLFloat", GLFloat}, |
+ {"GLFragmentShader", GLFragmentShader}, |
+ {"GLLinkStatus", GLLinkStatus}, |
+ {"GLTriangleStrip", GLTriangleStrip}, |
+ {"GLTriangles", GLTriangles}, |
+ {"GLTrue", GLTrue}, |
+ {"GLStaticDraw", GLStaticDraw}, |
+ {"GLValidateStatus", GLValidateStatus}, |
+ {"GLVertexShader", GLVertexShader}, |
+ {"GLGetShaderInfoLog", GLGetShaderInfoLog}, |
+ {"GLGetProgramInfoLog", GLGetProgramInfoLog}, |
+ {"RandomArray_ServicePort", RandomArrayServicePort}, |
+ |
+ // Audio support. |
+ {"PlayBackground", PlayBackground}, |
+ {"StopBackground", StopBackground}, |
+ {"LoadSample", LoadSample}, |
+ {"PlaySample", PlaySample}, |
+ |
+ {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; |
+} |
+ |