| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | |
| 2 // for details. All rights reserved. Use of this source code is governed by a | |
| 3 // BSD-style license that can be found in the LICENSE file. | |
| 4 | |
| 5 #include "embedders/openglui/common/extension.h" | |
| 6 | |
| 7 #include <stdio.h> | |
| 8 #include <stdlib.h> | |
| 9 #include <string.h> | |
| 10 | |
| 11 #include "embedders/openglui/common/canvas_context.h" | |
| 12 #include "embedders/openglui/common/image_cache.h" | |
| 13 #include "embedders/openglui/common/graphics_handler.h" | |
| 14 #include "embedders/openglui/common/log.h" | |
| 15 #include "embedders/openglui/common/opengl.h" | |
| 16 #include "include/dart_api.h" | |
| 17 #include "include/dart_native_api.h" | |
| 18 | |
| 19 Dart_Handle HandleError(Dart_Handle handle) { | |
| 20 if (Dart_IsError(handle)) Dart_PropagateError(handle); | |
| 21 return handle; | |
| 22 } | |
| 23 | |
| 24 void CheckGLError(const char *function) { | |
| 25 int error = glGetError(); | |
| 26 if (error != GL_NO_ERROR) { | |
| 27 if (error == GL_INVALID_ENUM) { | |
| 28 LOGE("%s: An unacceptable value is given for an enumerated argument.", | |
| 29 function); | |
| 30 } else if (error == GL_INVALID_VALUE) { | |
| 31 LOGE("%s: A numeric argument is out of range.", function); | |
| 32 } else if (error == GL_INVALID_OPERATION) { | |
| 33 LOGE("%s: The specified operation is not allowed in the current state.", | |
| 34 function); | |
| 35 } else if (error == GL_INVALID_FRAMEBUFFER_OPERATION) { | |
| 36 LOGE("%s: The framebuffer object is not complete.", function); | |
| 37 } else if (error == GL_OUT_OF_MEMORY) { | |
| 38 LOGE("%s: There is not enough memory left to execute the command.", | |
| 39 function); | |
| 40 } else { | |
| 41 LOGE("ERROR!: %s returns %d", function, error); | |
| 42 } | |
| 43 } | |
| 44 } | |
| 45 | |
| 46 const char* GetArgAsString(Dart_NativeArguments arguments, int idx) { | |
| 47 Dart_Handle handle = HandleError(Dart_GetNativeArgument(arguments, idx)); | |
| 48 uint8_t* str; | |
| 49 intptr_t length; | |
| 50 HandleError(Dart_StringLength(handle, &length)); | |
| 51 HandleError(Dart_StringToUTF8(handle, &str, &length)); | |
| 52 str[length] = 0; | |
| 53 return const_cast<const char*>(reinterpret_cast<char*>(str)); | |
| 54 } | |
| 55 | |
| 56 double GetArgAsDouble(Dart_NativeArguments arguments, int index) { | |
| 57 Dart_Handle handle = HandleError(Dart_GetNativeArgument(arguments, index)); | |
| 58 if (Dart_IsDouble(handle)) { | |
| 59 double v; | |
| 60 HandleError(Dart_DoubleValue(handle, &v)); | |
| 61 return v; | |
| 62 } | |
| 63 if (Dart_IsInteger(handle)) { | |
| 64 int64_t v; | |
| 65 HandleError(Dart_IntegerToInt64(handle, &v)); | |
| 66 return static_cast<double>(v); | |
| 67 } | |
| 68 LOGE("Argument at index %d has non-numeric type", index); | |
| 69 Dart_ThrowException(Dart_NewStringFromCString("Numeric argument expected.")); | |
| 70 return 0; | |
| 71 } | |
| 72 | |
| 73 int64_t GetArgAsInt(Dart_NativeArguments arguments, int index) { | |
| 74 Dart_Handle handle = HandleError(Dart_GetNativeArgument(arguments, index)); | |
| 75 if (Dart_IsDouble(handle)) { | |
| 76 double v; | |
| 77 HandleError(Dart_DoubleValue(handle, &v)); | |
| 78 return static_cast<int64_t>(v); | |
| 79 } | |
| 80 if (Dart_IsInteger(handle)) { | |
| 81 int64_t v; | |
| 82 HandleError(Dart_IntegerToInt64(handle, &v)); | |
| 83 return v; | |
| 84 } | |
| 85 LOGE("Argument at index %d has non-numeric type", index); | |
| 86 Dart_ThrowException(Dart_NewStringFromCString("Numeric argument expected.")); | |
| 87 return 0; | |
| 88 } | |
| 89 | |
| 90 bool GetArgAsBool(Dart_NativeArguments arguments, int index) { | |
| 91 Dart_Handle handle = HandleError(Dart_GetNativeArgument(arguments, index)); | |
| 92 if (Dart_IsBoolean(handle)) { | |
| 93 bool v; | |
| 94 HandleError(Dart_BooleanValue(handle, &v)); | |
| 95 return v; | |
| 96 } | |
| 97 LOGI("Argument at index %d has non-Boolean type", index); | |
| 98 Dart_ThrowException(Dart_NewStringFromCString("Boolean argument expected.")); | |
| 99 return false; | |
| 100 } | |
| 101 | |
| 102 int GetListLength(Dart_NativeArguments arguments, int index, | |
| 103 Dart_Handle& argHandle) { | |
| 104 argHandle = HandleError(Dart_GetNativeArgument(arguments, index)); | |
| 105 if (Dart_IsList(argHandle)) { | |
| 106 intptr_t len; | |
| 107 HandleError(Dart_ListLength(argHandle, &len)); | |
| 108 return len; | |
| 109 } | |
| 110 LOGI("Argument at index %d has non-List type", index); | |
| 111 Dart_ThrowException(Dart_NewStringFromCString("List argument expected.")); | |
| 112 return -1; | |
| 113 } | |
| 114 | |
| 115 GLint* GetArgsAsGLintList(Dart_NativeArguments arguments, int index, | |
| 116 int* len_out) { | |
| 117 Dart_Handle argHandle; | |
| 118 int len = GetListLength(arguments, index, argHandle); | |
| 119 if (len < 0) return NULL; | |
| 120 GLint* list = new GLint[len]; | |
| 121 for (int i = 0; i < len; i++) { | |
| 122 Dart_Handle vHandle = Dart_ListGetAt(argHandle, i); | |
| 123 int64_t v; | |
| 124 HandleError(Dart_IntegerToInt64(vHandle, &v)); | |
| 125 list[i] = v; | |
| 126 } | |
| 127 *len_out = len; | |
| 128 return list; | |
| 129 } | |
| 130 | |
| 131 GLfloat* GetArgsAsFloatList(Dart_NativeArguments arguments, int index, | |
| 132 int* len_out) { | |
| 133 Dart_Handle argHandle; | |
| 134 int len = GetListLength(arguments, index, argHandle); | |
| 135 if (len < 0) return NULL; | |
| 136 GLfloat* list = new GLfloat[len]; | |
| 137 for (int i = 0; i < len; i++) { | |
| 138 Dart_Handle vHandle = Dart_ListGetAt(argHandle, i); | |
| 139 double v; | |
| 140 HandleError(Dart_DoubleValue(vHandle, &v)); | |
| 141 list[i] = v; | |
| 142 } | |
| 143 *len_out = len; | |
| 144 return list; | |
| 145 } | |
| 146 | |
| 147 char** GetArgsAsStringList(Dart_NativeArguments arguments, int index, | |
| 148 int* len_out) { | |
| 149 Dart_Handle argHandle; | |
| 150 int len = GetListLength(arguments, index, argHandle); | |
| 151 if (len < 0) return NULL; | |
| 152 char** list = new char*[len]; | |
| 153 for (int i = 0; i < len; i++) { | |
| 154 Dart_Handle vHandle = Dart_ListGetAt(argHandle, i); | |
| 155 uint8_t* str; | |
| 156 intptr_t length; | |
| 157 HandleError(Dart_StringLength(vHandle, &length)); | |
| 158 HandleError(Dart_StringToUTF8(vHandle, &str, &length)); | |
| 159 str[length] = 0; | |
| 160 list[i] = reinterpret_cast<char*>(str); | |
| 161 } | |
| 162 *len_out = len; | |
| 163 return list; | |
| 164 } | |
| 165 | |
| 166 void SetBoolReturnValue(Dart_NativeArguments arguments, bool b) { | |
| 167 Dart_Handle result = HandleError(Dart_NewBoolean(b)); | |
| 168 Dart_SetReturnValue(arguments, result); | |
| 169 } | |
| 170 | |
| 171 void SetIntReturnValue(Dart_NativeArguments arguments, int v) { | |
| 172 Dart_Handle result = HandleError(Dart_NewInteger(v)); | |
| 173 Dart_SetReturnValue(arguments, result); | |
| 174 } | |
| 175 | |
| 176 void SetDoubleReturnValue(Dart_NativeArguments arguments, double v) { | |
| 177 Dart_Handle result = HandleError(Dart_NewDouble(v)); | |
| 178 Dart_SetReturnValue(arguments, result); | |
| 179 } | |
| 180 | |
| 181 void SetStringReturnValue(Dart_NativeArguments arguments, const char* s) { | |
| 182 Dart_Handle result = HandleError(Dart_NewStringFromCString(s)); | |
| 183 Dart_SetReturnValue(arguments, result); | |
| 184 } | |
| 185 | |
| 186 void Log(Dart_NativeArguments arguments) { | |
| 187 Dart_EnterScope(); | |
| 188 LOGI("%s", GetArgAsString(arguments, 0)); | |
| 189 Dart_ExitScope(); | |
| 190 } | |
| 191 | |
| 192 void LogError(Dart_NativeArguments arguments) { | |
| 193 Dart_EnterScope(); | |
| 194 LOGE("%s", GetArgAsString(arguments, 0)); | |
| 195 Dart_ExitScope(); | |
| 196 } | |
| 197 | |
| 198 void SystemRand(Dart_NativeArguments arguments) { | |
| 199 Dart_EnterScope(); | |
| 200 SetIntReturnValue(arguments, rand()); | |
| 201 Dart_ExitScope(); | |
| 202 } | |
| 203 | |
| 204 void SystemSrand(Dart_NativeArguments arguments) { | |
| 205 Dart_EnterScope(); | |
| 206 bool success = false; | |
| 207 Dart_Handle seed_object = HandleError(Dart_GetNativeArgument(arguments, 0)); | |
| 208 if (Dart_IsInteger(seed_object)) { | |
| 209 bool fits; | |
| 210 HandleError(Dart_IntegerFitsIntoInt64(seed_object, &fits)); | |
| 211 if (fits) { | |
| 212 int64_t seed; | |
| 213 HandleError(Dart_IntegerToInt64(seed_object, &seed)); | |
| 214 srand(static_cast<unsigned>(seed)); | |
| 215 success = true; | |
| 216 } | |
| 217 } | |
| 218 SetBoolReturnValue(arguments, success); | |
| 219 Dart_ExitScope(); | |
| 220 } | |
| 221 | |
| 222 void GetDeviceScreenWidth(Dart_NativeArguments arguments) { | |
| 223 LOGI("GetDeviceScreenWidth"); | |
| 224 Dart_EnterScope(); | |
| 225 SetIntReturnValue(arguments, graphics->width()); | |
| 226 Dart_ExitScope(); | |
| 227 } | |
| 228 | |
| 229 void GetDeviceScreenHeight(Dart_NativeArguments arguments) { | |
| 230 LOGI("GetDeviceScreenHeight"); | |
| 231 Dart_EnterScope(); | |
| 232 SetIntReturnValue(arguments, graphics->height()); | |
| 233 Dart_ExitScope(); | |
| 234 } | |
| 235 | |
| 236 void SwapBuffers(Dart_NativeArguments arguments) { | |
| 237 LOGI("SwapBuffers"); | |
| 238 Dart_EnterScope(); | |
| 239 GLSwapBuffers(); | |
| 240 CheckGLError("GLSwapBuffers"); | |
| 241 Dart_ExitScope(); | |
| 242 } | |
| 243 | |
| 244 void GLAttachShader(Dart_NativeArguments arguments) { | |
| 245 LOGI("GLAttachShader"); | |
| 246 Dart_EnterScope(); | |
| 247 | |
| 248 int64_t program = GetArgAsInt(arguments, 0); | |
| 249 int64_t shader = GetArgAsInt(arguments, 1); | |
| 250 | |
| 251 glAttachShader(program, shader); | |
| 252 CheckGLError("glAttachShader"); | |
| 253 Dart_ExitScope(); | |
| 254 } | |
| 255 | |
| 256 void GLBindBuffer(Dart_NativeArguments arguments) { | |
| 257 LOGI("GLBindBuffer"); | |
| 258 Dart_EnterScope(); | |
| 259 | |
| 260 int64_t target = GetArgAsInt(arguments, 0); | |
| 261 int64_t buffer = GetArgAsInt(arguments, 1); | |
| 262 | |
| 263 glBindBuffer(target, buffer); | |
| 264 CheckGLError("glBindBuffer"); | |
| 265 Dart_ExitScope(); | |
| 266 } | |
| 267 | |
| 268 void GLBufferData(Dart_NativeArguments arguments) { | |
| 269 LOGI("GLBufferData"); | |
| 270 Dart_EnterScope(); | |
| 271 | |
| 272 int64_t target = GetArgAsInt(arguments, 0); | |
| 273 | |
| 274 Dart_Handle dataHandle = HandleError(Dart_GetNativeArgument(arguments, 1)); | |
| 275 intptr_t size; | |
| 276 HandleError(Dart_ListLength(dataHandle, &size)); | |
| 277 | |
| 278 LOGI("Size: %d", static_cast<int>(size)); | |
| 279 | |
| 280 // TODO(vsm): No guarantee that this is a float! | |
| 281 float* data = new float[size]; | |
| 282 for (int i = 0; i < size; i++) { | |
| 283 Dart_Handle elemHandle = HandleError(Dart_ListGetAt(dataHandle, i)); | |
| 284 double value; | |
| 285 Dart_DoubleValue(elemHandle, &value); | |
| 286 data[i] = static_cast<float>(value); | |
| 287 LOGI("Value[%d]: %f", i, data[i]); | |
| 288 } | |
| 289 | |
| 290 Dart_Handle usageHandle = HandleError(Dart_GetNativeArgument(arguments, 2)); | |
| 291 int64_t usage; | |
| 292 HandleError(Dart_IntegerToInt64(usageHandle, &usage)); | |
| 293 | |
| 294 glBufferData(target, size * sizeof(data[0]), data, usage); | |
| 295 CheckGLError("glBufferData"); | |
| 296 delete[] data; | |
| 297 Dart_ExitScope(); | |
| 298 } | |
| 299 | |
| 300 void GLCompileShader(Dart_NativeArguments arguments) { | |
| 301 LOGI("GLCompileShader"); | |
| 302 Dart_EnterScope(); | |
| 303 int64_t shader = GetArgAsInt(arguments, 0); | |
| 304 glCompileShader(shader); | |
| 305 CheckGLError("glCompileShader"); | |
| 306 Dart_ExitScope(); | |
| 307 } | |
| 308 | |
| 309 void GLCreateBuffer(Dart_NativeArguments arguments) { | |
| 310 LOGI("GLCreateBuffer"); | |
| 311 Dart_EnterScope(); | |
| 312 GLuint buffer; | |
| 313 glGenBuffers(1, &buffer); | |
| 314 CheckGLError("glGenBuffers"); | |
| 315 SetIntReturnValue(arguments, buffer); | |
| 316 Dart_ExitScope(); | |
| 317 } | |
| 318 | |
| 319 void GLCreateProgram(Dart_NativeArguments arguments) { | |
| 320 LOGI("GLCreateProgram"); | |
| 321 Dart_EnterScope(); | |
| 322 int64_t program = glCreateProgram(); | |
| 323 CheckGLError("glCreateProgram"); | |
| 324 SetIntReturnValue(arguments, program); | |
| 325 Dart_ExitScope(); | |
| 326 } | |
| 327 | |
| 328 void GLCreateShader(Dart_NativeArguments arguments) { | |
| 329 LOGI("GLCreateShader"); | |
| 330 Dart_EnterScope(); | |
| 331 int64_t type = GetArgAsInt(arguments, 0); | |
| 332 int64_t shader = glCreateShader((GLenum)type); | |
| 333 CheckGLError("glCreateShader"); | |
| 334 SetIntReturnValue(arguments, shader); | |
| 335 Dart_ExitScope(); | |
| 336 } | |
| 337 | |
| 338 void GLDrawArrays(Dart_NativeArguments arguments) { | |
| 339 LOGI("GLDrawArrays"); | |
| 340 Dart_EnterScope(); | |
| 341 | |
| 342 int64_t mode = GetArgAsInt(arguments, 0); | |
| 343 int64_t first = GetArgAsInt(arguments, 1); | |
| 344 int64_t count = GetArgAsInt(arguments, 2); | |
| 345 | |
| 346 glDrawArrays(mode, first, count); | |
| 347 CheckGLError("glDrawArrays"); | |
| 348 Dart_ExitScope(); | |
| 349 LOGI("Done GLDrawArrays"); | |
| 350 } | |
| 351 | |
| 352 void GLEnableVertexAttribArray(Dart_NativeArguments arguments) { | |
| 353 LOGI("GLEnableVertexAttribArray"); | |
| 354 Dart_EnterScope(); | |
| 355 | |
| 356 int64_t location = GetArgAsInt(arguments, 0); | |
| 357 | |
| 358 glEnableVertexAttribArray(location); | |
| 359 CheckGLError("glEnableVertexAttribArray"); | |
| 360 Dart_ExitScope(); | |
| 361 } | |
| 362 | |
| 363 void GLGetAttribLocation(Dart_NativeArguments arguments) { | |
| 364 LOGI("GLGetAttribLocation"); | |
| 365 Dart_EnterScope(); | |
| 366 | |
| 367 int64_t program = GetArgAsInt(arguments, 0); | |
| 368 | |
| 369 Dart_Handle nameHandle = HandleError(Dart_GetNativeArgument(arguments, 1)); | |
| 370 intptr_t length; | |
| 371 HandleError(Dart_StringLength(nameHandle, &length)); | |
| 372 uint8_t* str; | |
| 373 HandleError(Dart_StringToUTF8(nameHandle, &str, &length)); | |
| 374 str[length] = 0; | |
| 375 | |
| 376 int64_t location = glGetAttribLocation(program, | |
| 377 const_cast<const GLchar*>(reinterpret_cast<GLchar*>(str))); | |
| 378 CheckGLError("glGetAttribLocation"); | |
| 379 SetIntReturnValue(arguments, location); | |
| 380 Dart_ExitScope(); | |
| 381 } | |
| 382 | |
| 383 void GLGetError(Dart_NativeArguments arguments) { | |
| 384 LOGI("GLGetError"); | |
| 385 Dart_EnterScope(); | |
| 386 SetIntReturnValue(arguments, glGetError()); | |
| 387 Dart_ExitScope(); | |
| 388 } | |
| 389 | |
| 390 void GLGetProgramParameter(Dart_NativeArguments arguments) { | |
| 391 LOGI("GLGetProgramParameter"); | |
| 392 Dart_EnterScope(); | |
| 393 | |
| 394 int64_t program = GetArgAsInt(arguments, 0); | |
| 395 int64_t param = GetArgAsInt(arguments, 1); | |
| 396 | |
| 397 GLint value = -1; | |
| 398 glGetProgramiv(program, param, &value); | |
| 399 CheckGLError("glGetProgramiv"); | |
| 400 | |
| 401 SetIntReturnValue(arguments, value); | |
| 402 Dart_ExitScope(); | |
| 403 } | |
| 404 | |
| 405 void GLGetShaderParameter(Dart_NativeArguments arguments) { | |
| 406 LOGI("GLGetShaderParameter"); | |
| 407 Dart_EnterScope(); | |
| 408 | |
| 409 int64_t shader = GetArgAsInt(arguments, 0); | |
| 410 int64_t param = GetArgAsInt(arguments, 1); | |
| 411 | |
| 412 GLint value = -1; | |
| 413 glGetShaderiv((GLuint)shader, (GLenum)param, &value); | |
| 414 CheckGLError("glGetShaderiv"); | |
| 415 | |
| 416 SetIntReturnValue(arguments, value); | |
| 417 Dart_ExitScope(); | |
| 418 } | |
| 419 | |
| 420 void GLGetShaderInfoLog(Dart_NativeArguments arguments) { | |
| 421 LOGI("GLGetShaderInfoLog"); | |
| 422 Dart_EnterScope(); | |
| 423 | |
| 424 int64_t shader = GetArgAsInt(arguments, 0); | |
| 425 | |
| 426 GLint infoLogLength = 0; | |
| 427 glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength); | |
| 428 GLchar* strInfoLog = new GLchar[infoLogLength + 1]; | |
| 429 glGetShaderInfoLog(shader, infoLogLength, NULL, strInfoLog); | |
| 430 strInfoLog[infoLogLength] = 0; | |
| 431 | |
| 432 SetStringReturnValue(arguments, strInfoLog); | |
| 433 Dart_ExitScope(); | |
| 434 delete[] strInfoLog; | |
| 435 } | |
| 436 | |
| 437 void GLGetProgramInfoLog(Dart_NativeArguments arguments) { | |
| 438 LOGI("GLGetProgramInfoLog"); | |
| 439 Dart_EnterScope(); | |
| 440 | |
| 441 int64_t program = GetArgAsInt(arguments, 0); | |
| 442 | |
| 443 GLint infoLogLength; | |
| 444 glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength); | |
| 445 | |
| 446 GLchar* strInfoLog = new GLchar[infoLogLength + 1]; | |
| 447 glGetProgramInfoLog(program, infoLogLength, NULL, strInfoLog); | |
| 448 strInfoLog[infoLogLength] = 0; | |
| 449 | |
| 450 SetStringReturnValue(arguments, strInfoLog); | |
| 451 Dart_ExitScope(); | |
| 452 delete[] strInfoLog; | |
| 453 } | |
| 454 | |
| 455 void GLGetUniformLocation(Dart_NativeArguments arguments) { | |
| 456 LOGI("GLGetUniformLocation"); | |
| 457 Dart_EnterScope(); | |
| 458 | |
| 459 int64_t program = GetArgAsInt(arguments, 0); | |
| 460 | |
| 461 | |
| 462 Dart_Handle nameHandle = HandleError(Dart_GetNativeArgument(arguments, 1)); | |
| 463 intptr_t length; | |
| 464 HandleError(Dart_StringLength(nameHandle, &length)); | |
| 465 uint8_t* str; | |
| 466 HandleError(Dart_StringToUTF8(nameHandle, &str, &length)); | |
| 467 str[length] = 0; | |
| 468 | |
| 469 int64_t location = glGetUniformLocation(program, | |
| 470 const_cast<const GLchar*>(reinterpret_cast<GLchar*>(str))); | |
| 471 CheckGLError("glGetUniformLocation"); | |
| 472 SetIntReturnValue(arguments, location); | |
| 473 Dart_ExitScope(); | |
| 474 } | |
| 475 | |
| 476 void GLLinkProgram(Dart_NativeArguments arguments) { | |
| 477 LOGI("GLLinkProgram"); | |
| 478 Dart_EnterScope(); | |
| 479 int64_t program = GetArgAsInt(arguments, 0); | |
| 480 glLinkProgram(program); | |
| 481 CheckGLError("glLinkProgram"); | |
| 482 Dart_ExitScope(); | |
| 483 } | |
| 484 | |
| 485 void GLShaderSource(Dart_NativeArguments arguments) { | |
| 486 LOGI("GLShaderSource"); | |
| 487 Dart_EnterScope(); | |
| 488 | |
| 489 int64_t shader = GetArgAsInt(arguments, 0); | |
| 490 | |
| 491 Dart_Handle sourceHandle = HandleError(Dart_GetNativeArgument(arguments, 1)); | |
| 492 intptr_t length[1]; | |
| 493 HandleError(Dart_StringLength(sourceHandle, length)); | |
| 494 LOGI("Source length is %d", static_cast<int>(length[0])); | |
| 495 uint8_t* str[1]; | |
| 496 HandleError(Dart_StringToUTF8(sourceHandle, &str[0], length)); | |
| 497 LOGI("Converted length is %d", static_cast<int>(length[0])); | |
| 498 str[0][*length] = 0; | |
| 499 | |
| 500 LOGI("Source: %s", | |
| 501 const_cast<const GLchar*>(reinterpret_cast<GLchar*>(str[0]))); | |
| 502 glShaderSource(shader, 1, | |
| 503 const_cast<const GLchar**>(reinterpret_cast<GLchar**>(str)), NULL); | |
| 504 CheckGLError("glShaderSource"); | |
| 505 Dart_ExitScope(); | |
| 506 } | |
| 507 | |
| 508 void GLUseProgram(Dart_NativeArguments arguments) { | |
| 509 LOGI("GLUseProgram"); | |
| 510 Dart_EnterScope(); | |
| 511 int64_t program = GetArgAsInt(arguments, 0); | |
| 512 glUseProgram(program); | |
| 513 CheckGLError("glUseProgram"); | |
| 514 Dart_ExitScope(); | |
| 515 } | |
| 516 | |
| 517 void GLUniform1i(Dart_NativeArguments arguments) { | |
| 518 LOGI("GLUniform1i"); | |
| 519 Dart_EnterScope(); | |
| 520 int64_t location = GetArgAsInt(arguments, 0); | |
| 521 int64_t v0 = GetArgAsInt(arguments, 1); | |
| 522 glUniform1i(location, v0); | |
| 523 CheckGLError("glUniform1i"); | |
| 524 Dart_ExitScope(); | |
| 525 } | |
| 526 | |
| 527 void GLUniform2i(Dart_NativeArguments arguments) { | |
| 528 LOGI("GLUniform2i"); | |
| 529 Dart_EnterScope(); | |
| 530 int64_t location = GetArgAsInt(arguments, 0); | |
| 531 int64_t v0 = GetArgAsInt(arguments, 1); | |
| 532 int64_t v1 = GetArgAsInt(arguments, 2); | |
| 533 glUniform2i(location, v0, v1); | |
| 534 CheckGLError("glUniform2i"); | |
| 535 Dart_ExitScope(); | |
| 536 } | |
| 537 | |
| 538 void GLUniform3i(Dart_NativeArguments arguments) { | |
| 539 LOGI("GLUniform3i"); | |
| 540 Dart_EnterScope(); | |
| 541 int64_t location = GetArgAsInt(arguments, 0); | |
| 542 int64_t v0 = GetArgAsInt(arguments, 1); | |
| 543 int64_t v1 = GetArgAsInt(arguments, 2); | |
| 544 int64_t v2 = GetArgAsInt(arguments, 3); | |
| 545 glUniform3i(location, v0, v1, v2); | |
| 546 CheckGLError("glUniform3i"); | |
| 547 Dart_ExitScope(); | |
| 548 } | |
| 549 | |
| 550 void GLUniform4i(Dart_NativeArguments arguments) { | |
| 551 LOGI("GLUniform4i"); | |
| 552 Dart_EnterScope(); | |
| 553 int64_t location = GetArgAsInt(arguments, 0); | |
| 554 int64_t v0 = GetArgAsInt(arguments, 1); | |
| 555 int64_t v1 = GetArgAsInt(arguments, 2); | |
| 556 int64_t v2 = GetArgAsInt(arguments, 3); | |
| 557 int64_t v3 = GetArgAsInt(arguments, 4); | |
| 558 glUniform4i(location, v0, v1, v2, v3); | |
| 559 CheckGLError("glUniform4i"); | |
| 560 Dart_ExitScope(); | |
| 561 } | |
| 562 | |
| 563 void GLUniform1f(Dart_NativeArguments arguments) { | |
| 564 LOGI("GLUniform1f"); | |
| 565 Dart_EnterScope(); | |
| 566 int64_t location = GetArgAsInt(arguments, 0); | |
| 567 double v0 = GetArgAsDouble(arguments, 1); | |
| 568 glUniform1f(location, v0); | |
| 569 CheckGLError("glUniform1f"); | |
| 570 Dart_ExitScope(); | |
| 571 } | |
| 572 | |
| 573 void GLUniform2f(Dart_NativeArguments arguments) { | |
| 574 LOGI("GLUniform2f"); | |
| 575 Dart_EnterScope(); | |
| 576 int64_t location = GetArgAsInt(arguments, 0); | |
| 577 double v0 = GetArgAsDouble(arguments, 1); | |
| 578 double v1 = GetArgAsDouble(arguments, 2); | |
| 579 glUniform2f(location, v0, v1); | |
| 580 CheckGLError("glUniform2f"); | |
| 581 Dart_ExitScope(); | |
| 582 } | |
| 583 | |
| 584 void GLUniform3f(Dart_NativeArguments arguments) { | |
| 585 LOGI("GLUniform3f"); | |
| 586 Dart_EnterScope(); | |
| 587 int64_t location = GetArgAsInt(arguments, 0); | |
| 588 double v0 = GetArgAsDouble(arguments, 1); | |
| 589 double v1 = GetArgAsDouble(arguments, 2); | |
| 590 double v2 = GetArgAsDouble(arguments, 3); | |
| 591 glUniform3f(location, v0, v1, v2); | |
| 592 CheckGLError("glUniform3f"); | |
| 593 Dart_ExitScope(); | |
| 594 } | |
| 595 | |
| 596 void GLUniform4f(Dart_NativeArguments arguments) { | |
| 597 LOGI("GLUniform4f"); | |
| 598 Dart_EnterScope(); | |
| 599 int64_t location = GetArgAsInt(arguments, 0); | |
| 600 double v0 = GetArgAsDouble(arguments, 1); | |
| 601 double v1 = GetArgAsDouble(arguments, 2); | |
| 602 double v2 = GetArgAsDouble(arguments, 3); | |
| 603 double v3 = GetArgAsDouble(arguments, 4); | |
| 604 glUniform4f(location, v0, v1, v2, v3); | |
| 605 CheckGLError("glUniform4f"); | |
| 606 Dart_ExitScope(); | |
| 607 } | |
| 608 | |
| 609 void GLUniform1iv(Dart_NativeArguments arguments) { | |
| 610 LOGI("GLUniform1iv"); | |
| 611 Dart_EnterScope(); | |
| 612 int64_t location = GetArgAsInt(arguments, 0); | |
| 613 int len; | |
| 614 GLint* list = GetArgsAsGLintList(arguments, 1, &len); | |
| 615 if (list != NULL) { | |
| 616 glUniform1iv(location, len, list); | |
| 617 delete [] list; | |
| 618 CheckGLError("glUniform1iv"); | |
| 619 } | |
| 620 Dart_ExitScope(); | |
| 621 } | |
| 622 | |
| 623 void GLUniform2iv(Dart_NativeArguments arguments) { | |
| 624 LOGI("GLUniform2iv"); | |
| 625 Dart_EnterScope(); | |
| 626 int64_t location = GetArgAsInt(arguments, 0); | |
| 627 int len; | |
| 628 GLint* list = GetArgsAsGLintList(arguments, 1, &len); | |
| 629 if (list != NULL) { | |
| 630 glUniform2iv(location, len / 2, list); | |
| 631 delete [] list; | |
| 632 CheckGLError("glUniform2iv"); | |
| 633 } | |
| 634 Dart_ExitScope(); | |
| 635 } | |
| 636 | |
| 637 void GLUniform3iv(Dart_NativeArguments arguments) { | |
| 638 LOGI("GLUniform3iv"); | |
| 639 Dart_EnterScope(); | |
| 640 int64_t location = GetArgAsInt(arguments, 0); | |
| 641 int len; | |
| 642 GLint* list = GetArgsAsGLintList(arguments, 1, &len); | |
| 643 if (list != NULL) { | |
| 644 glUniform3iv(location, len / 3, list); | |
| 645 delete [] list; | |
| 646 CheckGLError("glUniform3iv"); | |
| 647 } | |
| 648 Dart_ExitScope(); | |
| 649 } | |
| 650 | |
| 651 void GLUniform4iv(Dart_NativeArguments arguments) { | |
| 652 LOGI("GLUniform4iv"); | |
| 653 Dart_EnterScope(); | |
| 654 int64_t location = GetArgAsInt(arguments, 0); | |
| 655 int len; | |
| 656 GLint* list = GetArgsAsGLintList(arguments, 1, &len); | |
| 657 if (list != NULL) { | |
| 658 glUniform1iv(location, len / 4, list); | |
| 659 delete [] list; | |
| 660 CheckGLError("glUniform4iv"); | |
| 661 } | |
| 662 Dart_ExitScope(); | |
| 663 } | |
| 664 | |
| 665 void GLUniform1fv(Dart_NativeArguments arguments) { | |
| 666 LOGI("GLUniform1fv"); | |
| 667 Dart_EnterScope(); | |
| 668 int64_t location = GetArgAsInt(arguments, 0); | |
| 669 int len; | |
| 670 GLfloat* list = GetArgsAsFloatList(arguments, 1, &len); | |
| 671 if (list != NULL) { | |
| 672 glUniform1fv(location, len, list); | |
| 673 delete [] list; | |
| 674 CheckGLError("glUniform1fv"); | |
| 675 } | |
| 676 Dart_ExitScope(); | |
| 677 } | |
| 678 | |
| 679 void GLUniform2fv(Dart_NativeArguments arguments) { | |
| 680 LOGI("GLUniform2fv"); | |
| 681 Dart_EnterScope(); | |
| 682 int64_t location = GetArgAsInt(arguments, 0); | |
| 683 int len; | |
| 684 GLfloat* list = GetArgsAsFloatList(arguments, 1, &len); | |
| 685 if (list != NULL) { | |
| 686 glUniform2fv(location, len / 2, list); | |
| 687 delete [] list; | |
| 688 CheckGLError("glUniform2fv"); | |
| 689 } | |
| 690 Dart_ExitScope(); | |
| 691 } | |
| 692 | |
| 693 void GLUniform3fv(Dart_NativeArguments arguments) { | |
| 694 LOGI("GLUniform3fv"); | |
| 695 Dart_EnterScope(); | |
| 696 int64_t location = GetArgAsInt(arguments, 0); | |
| 697 int len; | |
| 698 GLfloat* list = GetArgsAsFloatList(arguments, 1, &len); | |
| 699 if (list != NULL) { | |
| 700 glUniform3fv(location, len / 3, list); | |
| 701 delete [] list; | |
| 702 CheckGLError("glUniform3fv"); | |
| 703 } | |
| 704 Dart_ExitScope(); | |
| 705 } | |
| 706 | |
| 707 void GLUniform4fv(Dart_NativeArguments arguments) { | |
| 708 LOGI("In GLUniform4fv"); | |
| 709 Dart_EnterScope(); | |
| 710 int64_t location = GetArgAsInt(arguments, 0); | |
| 711 int len; | |
| 712 GLfloat* list = GetArgsAsFloatList(arguments, 1, &len); | |
| 713 if (list != NULL) { | |
| 714 glUniform4fv(location, len / 4, list); | |
| 715 delete [] list; | |
| 716 CheckGLError("glUniform4fv"); | |
| 717 } | |
| 718 Dart_ExitScope(); | |
| 719 } | |
| 720 | |
| 721 void GLViewport(Dart_NativeArguments arguments) { | |
| 722 LOGI("GLViewport"); | |
| 723 Dart_EnterScope(); | |
| 724 int64_t x = GetArgAsInt(arguments, 0); | |
| 725 int64_t y = GetArgAsInt(arguments, 1); | |
| 726 int64_t width = GetArgAsInt(arguments, 2); | |
| 727 int64_t height = GetArgAsInt(arguments, 3); | |
| 728 glViewport(x, y, width, height); | |
| 729 CheckGLError("glViewPort"); | |
| 730 Dart_ExitScope(); | |
| 731 } | |
| 732 | |
| 733 void GLVertexAttribPointer(Dart_NativeArguments arguments) { | |
| 734 LOGI("GLVertexAttribPointer"); | |
| 735 Dart_EnterScope(); | |
| 736 int64_t index = GetArgAsInt(arguments, 0); | |
| 737 int64_t size = GetArgAsInt(arguments, 1); | |
| 738 int64_t type = GetArgAsInt(arguments, 2); | |
| 739 bool normalized = GetArgAsBool(arguments, 3); | |
| 740 int64_t stride = GetArgAsInt(arguments, 4); | |
| 741 | |
| 742 Dart_Handle pointerHandle = HandleError(Dart_GetNativeArgument(arguments, 5)); | |
| 743 int64_t pointerValue; | |
| 744 HandleError(Dart_IntegerToInt64(pointerHandle, &pointerValue)); | |
| 745 const void* pointer; | |
| 746 pointer = const_cast<const void*>(reinterpret_cast<void*>(pointerValue)); | |
| 747 | |
| 748 glVertexAttribPointer(index, size, type, normalized, stride, pointer); | |
| 749 CheckGLError("glVertexAttribPointer"); | |
| 750 Dart_ExitScope(); | |
| 751 } | |
| 752 | |
| 753 void GLClearColor(Dart_NativeArguments arguments) { | |
| 754 LOGI("GLClearColor"); | |
| 755 Dart_EnterScope(); | |
| 756 double red = GetArgAsDouble(arguments, 0); | |
| 757 double green = GetArgAsDouble(arguments, 1); | |
| 758 double blue = GetArgAsDouble(arguments, 2); | |
| 759 double alpha = GetArgAsDouble(arguments, 3); | |
| 760 glClearColor(red, green, blue, alpha); | |
| 761 CheckGLError("glClearColor"); | |
| 762 Dart_ExitScope(); | |
| 763 } | |
| 764 | |
| 765 void GLClearDepth(Dart_NativeArguments arguments) { | |
| 766 LOGI("GLClearDepth"); | |
| 767 Dart_EnterScope(); | |
| 768 double depth = GetArgAsDouble(arguments, 0); | |
| 769 #if defined(__ANDROID__) | |
| 770 glClearDepthf(depth); | |
| 771 #else | |
| 772 glClearDepth(depth); | |
| 773 #endif | |
| 774 CheckGLError("glClearDepth"); | |
| 775 Dart_ExitScope(); | |
| 776 } | |
| 777 | |
| 778 void GLClear(Dart_NativeArguments arguments) { | |
| 779 LOGI("GLClear"); | |
| 780 Dart_EnterScope(); | |
| 781 Dart_Handle maskHandle = HandleError(Dart_GetNativeArgument(arguments, 0)); | |
| 782 int64_t mask; | |
| 783 HandleError(Dart_IntegerToInt64(maskHandle, &mask)); | |
| 784 glClear(mask); | |
| 785 CheckGLError("glClear"); | |
| 786 Dart_ExitScope(); | |
| 787 } | |
| 788 | |
| 789 void ReturnGLIntConstant(Dart_NativeArguments arguments, int c) { | |
| 790 Dart_EnterScope(); | |
| 791 SetIntReturnValue(arguments, c); | |
| 792 Dart_ExitScope(); | |
| 793 } | |
| 794 | |
| 795 void GLArrayBuffer(Dart_NativeArguments arguments) { | |
| 796 ReturnGLIntConstant(arguments, GL_ARRAY_BUFFER); | |
| 797 } | |
| 798 | |
| 799 void GLColorBufferBit(Dart_NativeArguments arguments) { | |
| 800 ReturnGLIntConstant(arguments, GL_COLOR_BUFFER_BIT); | |
| 801 } | |
| 802 | |
| 803 void GLCompileStatus(Dart_NativeArguments arguments) { | |
| 804 ReturnGLIntConstant(arguments, GL_COMPILE_STATUS); | |
| 805 } | |
| 806 | |
| 807 void GLDeleteStatus(Dart_NativeArguments arguments) { | |
| 808 ReturnGLIntConstant(arguments, GL_DELETE_STATUS); | |
| 809 } | |
| 810 | |
| 811 void GLDepthBufferBit(Dart_NativeArguments arguments) { | |
| 812 ReturnGLIntConstant(arguments, GL_DEPTH_BUFFER_BIT); | |
| 813 } | |
| 814 | |
| 815 void GLFloat(Dart_NativeArguments arguments) { | |
| 816 ReturnGLIntConstant(arguments, GL_FLOAT); | |
| 817 } | |
| 818 | |
| 819 void GLFragmentShader(Dart_NativeArguments arguments) { | |
| 820 ReturnGLIntConstant(arguments, GL_FRAGMENT_SHADER); | |
| 821 } | |
| 822 | |
| 823 void GLLinkStatus(Dart_NativeArguments arguments) { | |
| 824 ReturnGLIntConstant(arguments, GL_LINK_STATUS); | |
| 825 } | |
| 826 | |
| 827 void GLStaticDraw(Dart_NativeArguments arguments) { | |
| 828 ReturnGLIntConstant(arguments, GL_STATIC_DRAW); | |
| 829 } | |
| 830 | |
| 831 void GLTriangleStrip(Dart_NativeArguments arguments) { | |
| 832 ReturnGLIntConstant(arguments, GL_TRIANGLE_STRIP); | |
| 833 } | |
| 834 | |
| 835 void GLTriangles(Dart_NativeArguments arguments) { | |
| 836 ReturnGLIntConstant(arguments, GL_TRIANGLES); | |
| 837 } | |
| 838 | |
| 839 void GLTrue(Dart_NativeArguments arguments) { | |
| 840 ReturnGLIntConstant(arguments, GL_TRUE); | |
| 841 } | |
| 842 | |
| 843 void GLValidateStatus(Dart_NativeArguments arguments) { | |
| 844 ReturnGLIntConstant(arguments, GL_VALIDATE_STATUS); | |
| 845 } | |
| 846 | |
| 847 void GLVertexShader(Dart_NativeArguments arguments) { | |
| 848 ReturnGLIntConstant(arguments, GL_VERTEX_SHADER); | |
| 849 } | |
| 850 | |
| 851 uint8_t* RandomArray(int seed, int length) { | |
| 852 if (length <= 0 || length > 10000000) return NULL; | |
| 853 uint8_t* values = reinterpret_cast<uint8_t*>(malloc(length)); | |
| 854 if (NULL == values) return NULL; | |
| 855 srand(seed); | |
| 856 for (int i = 0; i < length; ++i) { | |
| 857 values[i] = rand() % 256; | |
| 858 } | |
| 859 return values; | |
| 860 } | |
| 861 | |
| 862 void WrappedRandomArray(Dart_Port dest_port_id, | |
| 863 Dart_Port reply_port_id, | |
| 864 Dart_CObject* message) { | |
| 865 if (message->type == Dart_CObject_kArray && | |
| 866 2 == message->value.as_array.length) { | |
| 867 // Use .as_array and .as_int32 to access the data in the Dart_CObject. | |
| 868 Dart_CObject* param0 = message->value.as_array.values[0]; | |
| 869 Dart_CObject* param1 = message->value.as_array.values[1]; | |
| 870 if (param0->type == Dart_CObject_kInt32 && | |
| 871 param1->type == Dart_CObject_kInt32) { | |
| 872 int length = param0->value.as_int32; | |
| 873 int seed = param1->value.as_int32; | |
| 874 | |
| 875 uint8_t* values = RandomArray(seed, length); | |
| 876 | |
| 877 if (values != NULL) { | |
| 878 Dart_CObject result; | |
| 879 result.type = Dart_CObject_kTypedData; | |
| 880 result.value.as_typed_data.type = Dart_TypedData_kUint8; | |
| 881 result.value.as_typed_data.values = values; | |
| 882 result.value.as_typed_data.length = length; | |
| 883 Dart_PostCObject(reply_port_id, &result); | |
| 884 free(values); | |
| 885 // It is OK that result is destroyed when function exits. | |
| 886 // Dart_PostCObject has copied its data. | |
| 887 return; | |
| 888 } | |
| 889 } | |
| 890 } | |
| 891 Dart_CObject result; | |
| 892 result.type = Dart_CObject_kNull; | |
| 893 Dart_PostCObject(reply_port_id, &result); | |
| 894 } | |
| 895 | |
| 896 void RandomArrayServicePort(Dart_NativeArguments arguments) { | |
| 897 Dart_EnterScope(); | |
| 898 Dart_SetReturnValue(arguments, Dart_Null()); | |
| 899 Dart_Port service_port = | |
| 900 Dart_NewNativePort("RandomArrayService", WrappedRandomArray, true); | |
| 901 if (service_port != ((Dart_Port)0)) { | |
| 902 Dart_Handle send_port = HandleError(Dart_NewSendPort(service_port)); | |
| 903 Dart_SetReturnValue(arguments, send_port); | |
| 904 } | |
| 905 Dart_ExitScope(); | |
| 906 } | |
| 907 | |
| 908 void PlayBackground(Dart_NativeArguments arguments) { | |
| 909 LOGI("PlayBackground"); | |
| 910 Dart_EnterScope(); | |
| 911 const char* what = GetArgAsString(arguments, 0); | |
| 912 int rtn = PlayBackgroundSound(what); | |
| 913 SetIntReturnValue(arguments, rtn); | |
| 914 Dart_ExitScope(); | |
| 915 } | |
| 916 | |
| 917 void StopBackground(Dart_NativeArguments arguments) { | |
| 918 LOGI("StopBackground"); | |
| 919 Dart_EnterScope(); | |
| 920 StopBackgroundSound(); | |
| 921 Dart_ExitScope(); | |
| 922 } | |
| 923 | |
| 924 void LoadSample(Dart_NativeArguments arguments) { | |
| 925 LOGI("LoadSample"); | |
| 926 Dart_EnterScope(); | |
| 927 const char* what = GetArgAsString(arguments, 0); | |
| 928 int rtn = LoadSoundSample(what); | |
| 929 SetIntReturnValue(arguments, rtn); | |
| 930 Dart_ExitScope(); | |
| 931 } | |
| 932 | |
| 933 void PlaySample(Dart_NativeArguments arguments) { | |
| 934 LOGI("PlaySample"); | |
| 935 Dart_EnterScope(); | |
| 936 const char* what = GetArgAsString(arguments, 0); | |
| 937 int rtn = PlaySoundSample(what); | |
| 938 SetIntReturnValue(arguments, rtn); | |
| 939 Dart_ExitScope(); | |
| 940 } | |
| 941 | |
| 942 // 2D Canvas. | |
| 943 | |
| 944 CanvasContext* display_context = NULL; | |
| 945 | |
| 946 void C2DCreateNativeContext(Dart_NativeArguments arguments) { | |
| 947 LOGI("In C2DCreateNativeContext"); | |
| 948 Dart_EnterScope(); | |
| 949 | |
| 950 int handle = GetArgAsInt(arguments, 0); | |
| 951 int width = GetArgAsInt(arguments, 1); | |
| 952 int height = GetArgAsInt(arguments, 2); | |
| 953 | |
| 954 CanvasContext* rtn = new CanvasContext(handle, width, height); | |
| 955 if (display_context == NULL) { | |
| 956 LOGI("Created display context"); | |
| 957 display_context = rtn; | |
| 958 } | |
| 959 Dart_ExitScope(); | |
| 960 LOGI("Out C2DCreateNativeContext"); | |
| 961 } | |
| 962 | |
| 963 void C2DSetWidth(Dart_NativeArguments arguments) { | |
| 964 LOGI("In C2DSetWidth"); | |
| 965 Dart_EnterScope(); | |
| 966 int handle = GetArgAsInt(arguments, 0); | |
| 967 int width = GetArgAsInt(arguments, 1); | |
| 968 SetIntReturnValue(arguments, Context2D(handle)->setWidth(width)); | |
| 969 Dart_ExitScope(); | |
| 970 LOGI("Out C2DSetWidth"); | |
| 971 } | |
| 972 | |
| 973 void C2DSetHeight(Dart_NativeArguments arguments) { | |
| 974 LOGI("In C2DSetHeight"); | |
| 975 Dart_EnterScope(); | |
| 976 int handle = GetArgAsInt(arguments, 0); | |
| 977 int height = GetArgAsInt(arguments, 1); | |
| 978 SetIntReturnValue(arguments, Context2D(handle)->setHeight(height)); | |
| 979 Dart_ExitScope(); | |
| 980 LOGI("Out C2DSetHeight"); | |
| 981 } | |
| 982 | |
| 983 void C2DSetGlobalAlpha(Dart_NativeArguments arguments) { | |
| 984 LOGI("In C2DSetGlobalAlpha"); | |
| 985 Dart_EnterScope(); | |
| 986 int handle = GetArgAsInt(arguments, 0); | |
| 987 double alpha = GetArgAsDouble(arguments, 1); | |
| 988 alpha = MIN(1.0, MAX(alpha, 0.0)); | |
| 989 Context2D(handle)->setGlobalAlpha(alpha); | |
| 990 SetDoubleReturnValue(arguments, alpha); | |
| 991 Dart_ExitScope(); | |
| 992 LOGI("Out C2DSetGlobalAlpha"); | |
| 993 } | |
| 994 | |
| 995 void C2DSetFillStyle(Dart_NativeArguments arguments) { | |
| 996 LOGI("In C2DSetFillStyle"); | |
| 997 Dart_EnterScope(); | |
| 998 int handle = GetArgAsInt(arguments, 0); | |
| 999 const char* color = GetArgAsString(arguments, 1); | |
| 1000 Context2D(handle)->setFillColor(color); | |
| 1001 Dart_ExitScope(); | |
| 1002 LOGI("Out C2DSetFillStyle"); | |
| 1003 } | |
| 1004 | |
| 1005 void C2DSetFont(Dart_NativeArguments arguments) { | |
| 1006 LOGI("In C2DSetFont"); | |
| 1007 Dart_EnterScope(); | |
| 1008 int handle = GetArgAsInt(arguments, 0); | |
| 1009 const char* font = GetArgAsString(arguments, 1); | |
| 1010 SetStringReturnValue(arguments, Context2D(handle)->setFont(font)); | |
| 1011 Dart_ExitScope(); | |
| 1012 LOGI("Out C2DSetFont"); | |
| 1013 } | |
| 1014 | |
| 1015 void C2DSetGlobalCompositeOperation(Dart_NativeArguments arguments) { | |
| 1016 LOGI("In C2DSetGlobalCompositeOperation"); | |
| 1017 Dart_EnterScope(); | |
| 1018 int handle = GetArgAsInt(arguments, 0); | |
| 1019 const char* op = GetArgAsString(arguments, 1); | |
| 1020 Context2D(handle)->setGlobalCompositeOperation(op); | |
| 1021 Dart_ExitScope(); | |
| 1022 LOGI("Out C2DSetGlobalCompositeOperation"); | |
| 1023 } | |
| 1024 | |
| 1025 void C2DSetLineCap(Dart_NativeArguments arguments) { | |
| 1026 LOGI("In C2DSetLineCap"); | |
| 1027 Dart_EnterScope(); | |
| 1028 int handle = GetArgAsInt(arguments, 0); | |
| 1029 const char* lc = GetArgAsString(arguments, 1); | |
| 1030 Context2D(handle)->setLineCap(lc); | |
| 1031 Dart_ExitScope(); | |
| 1032 LOGI("Out C2DSetLineCap"); | |
| 1033 } | |
| 1034 | |
| 1035 void C2DSetLineJoin(Dart_NativeArguments arguments) { | |
| 1036 LOGI("In C2DSetLineJoin"); | |
| 1037 Dart_EnterScope(); | |
| 1038 int handle = GetArgAsInt(arguments, 0); | |
| 1039 const char* lj = GetArgAsString(arguments, 1); | |
| 1040 Context2D(handle)->setLineJoin(lj); | |
| 1041 Dart_ExitScope(); | |
| 1042 LOGI("Out C2DSetLineJoin"); | |
| 1043 } | |
| 1044 | |
| 1045 void C2DSetLineWidth(Dart_NativeArguments arguments) { | |
| 1046 LOGI("In C2DSetLineWidth"); | |
| 1047 Dart_EnterScope(); | |
| 1048 int handle = GetArgAsInt(arguments, 0); | |
| 1049 double w = GetArgAsDouble(arguments, 1); | |
| 1050 Context2D(handle)->setLineWidth(w); | |
| 1051 Dart_ExitScope(); | |
| 1052 LOGI("Out C2DSetLineWidth"); | |
| 1053 } | |
| 1054 | |
| 1055 void C2DSetMiterLimit(Dart_NativeArguments arguments) { | |
| 1056 LOGI("In C2DSetMiterLimit"); | |
| 1057 Dart_EnterScope(); | |
| 1058 int handle = GetArgAsInt(arguments, 0); | |
| 1059 double w = GetArgAsDouble(arguments, 1); | |
| 1060 Context2D(handle)->setMiterLimit(w); | |
| 1061 Dart_ExitScope(); | |
| 1062 LOGI("Out C2DSetMiterLimit"); | |
| 1063 } | |
| 1064 | |
| 1065 void C2DSetShadowBlur(Dart_NativeArguments arguments) { | |
| 1066 LOGI("In C2DSetShadowBlur"); | |
| 1067 Dart_EnterScope(); | |
| 1068 int handle = GetArgAsInt(arguments, 0); | |
| 1069 double blur = GetArgAsDouble(arguments, 1); | |
| 1070 Context2D(handle)->setShadowBlur(blur); | |
| 1071 Dart_ExitScope(); | |
| 1072 LOGI("Out C2DSetShadowBlur"); | |
| 1073 } | |
| 1074 | |
| 1075 void C2DSetShadowColor(Dart_NativeArguments arguments) { | |
| 1076 LOGI("In C2DSetShadowColor"); | |
| 1077 Dart_EnterScope(); | |
| 1078 int handle = GetArgAsInt(arguments, 0); | |
| 1079 const char* color = GetArgAsString(arguments, 1); | |
| 1080 Context2D(handle)->setShadowColor(color); | |
| 1081 Dart_ExitScope(); | |
| 1082 LOGI("Out C2DSetShadowColor"); | |
| 1083 } | |
| 1084 | |
| 1085 void C2DSetShadowOffsetX(Dart_NativeArguments arguments) { | |
| 1086 LOGI("In C2DSetShadowOffsetX"); | |
| 1087 Dart_EnterScope(); | |
| 1088 int handle = GetArgAsInt(arguments, 0); | |
| 1089 double offset = GetArgAsDouble(arguments, 1); | |
| 1090 Context2D(handle)->setShadowOffsetX(offset); | |
| 1091 Dart_ExitScope(); | |
| 1092 LOGI("Out C2DSetShadowOffsetX"); | |
| 1093 } | |
| 1094 | |
| 1095 void C2DSetShadowOffsetY(Dart_NativeArguments arguments) { | |
| 1096 LOGI("In C2DSetShadowOffsetY"); | |
| 1097 Dart_EnterScope(); | |
| 1098 int handle = GetArgAsInt(arguments, 0); | |
| 1099 double offset = GetArgAsDouble(arguments, 1); | |
| 1100 Context2D(handle)->setShadowOffsetY(offset); | |
| 1101 Dart_ExitScope(); | |
| 1102 LOGI("Out C2DSetShadowOffsetY"); | |
| 1103 } | |
| 1104 | |
| 1105 void C2DSetStrokeStyle(Dart_NativeArguments arguments) { | |
| 1106 LOGI("In C2DSetStrokeStyle"); | |
| 1107 Dart_EnterScope(); | |
| 1108 int handle = GetArgAsInt(arguments, 0); | |
| 1109 const char* color = GetArgAsString(arguments, 1); | |
| 1110 Context2D(handle)->setStrokeColor(color); | |
| 1111 Dart_ExitScope(); | |
| 1112 LOGI("Out C2DSetStrokeStyle"); | |
| 1113 } | |
| 1114 | |
| 1115 void C2DSetTextAlign(Dart_NativeArguments arguments) { | |
| 1116 LOGI("In C2DSetTextAlign"); | |
| 1117 Dart_EnterScope(); | |
| 1118 int handle = GetArgAsInt(arguments, 0); | |
| 1119 const char* align = GetArgAsString(arguments, 1); | |
| 1120 SetStringReturnValue(arguments, Context2D(handle)->setTextAlign(align)); | |
| 1121 Dart_ExitScope(); | |
| 1122 LOGI("Out C2DSetTextAlign"); | |
| 1123 } | |
| 1124 | |
| 1125 void C2DSetTextBaseline(Dart_NativeArguments arguments) { | |
| 1126 LOGI("In C2DSetTextBaseline"); | |
| 1127 Dart_EnterScope(); | |
| 1128 int handle = GetArgAsInt(arguments, 0); | |
| 1129 const char* baseline = GetArgAsString(arguments, 1); | |
| 1130 SetStringReturnValue(arguments, Context2D(handle)->setTextBaseline(baseline)); | |
| 1131 Dart_ExitScope(); | |
| 1132 LOGI("Out C2DSetTextBaseline"); | |
| 1133 } | |
| 1134 | |
| 1135 void C2DGetImageSmoothingEnabled(Dart_NativeArguments arguments) { | |
| 1136 LOGI("In C2DGetImageSmoothingEnabled"); | |
| 1137 Dart_EnterScope(); | |
| 1138 int handle = GetArgAsInt(arguments, 0); | |
| 1139 SetDoubleReturnValue(arguments, Context2D(handle)->imageSmoothingEnabled()); | |
| 1140 Dart_ExitScope(); | |
| 1141 LOGI("Out C2DGetImageSmoothingEnabled"); | |
| 1142 } | |
| 1143 | |
| 1144 void C2DArc(Dart_NativeArguments arguments) { | |
| 1145 LOGI("In C2DArc"); | |
| 1146 Dart_EnterScope(); | |
| 1147 int handle = GetArgAsInt(arguments, 0); | |
| 1148 double x = GetArgAsDouble(arguments, 1); | |
| 1149 double y = GetArgAsDouble(arguments, 2); | |
| 1150 double r = GetArgAsDouble(arguments, 3); | |
| 1151 double a1 = GetArgAsDouble(arguments, 4); | |
| 1152 double a2 = GetArgAsDouble(arguments, 5); | |
| 1153 bool anticlockwise = GetArgAsBool(arguments, 6); | |
| 1154 Context2D(handle)->Arc(x, y, r, a1, a2, anticlockwise); | |
| 1155 Dart_ExitScope(); | |
| 1156 LOGI("Out C2DArc"); | |
| 1157 } | |
| 1158 | |
| 1159 void C2DArcTo(Dart_NativeArguments arguments) { | |
| 1160 LOGI("In C2DArcTo"); | |
| 1161 Dart_EnterScope(); | |
| 1162 int handle = GetArgAsInt(arguments, 0); | |
| 1163 double x1 = GetArgAsDouble(arguments, 1); | |
| 1164 double y1 = GetArgAsDouble(arguments, 2); | |
| 1165 double x2 = GetArgAsDouble(arguments, 3); | |
| 1166 double y2 = GetArgAsDouble(arguments, 4); | |
| 1167 double radius = GetArgAsDouble(arguments, 5); | |
| 1168 Context2D(handle)->ArcTo(x1, y1, x2, y2, radius); | |
| 1169 Dart_ExitScope(); | |
| 1170 LOGI("Out C2DArcTo"); | |
| 1171 } | |
| 1172 | |
| 1173 void C2DBeginPath(Dart_NativeArguments arguments) { | |
| 1174 LOGI("In C2DBeginPath"); | |
| 1175 Dart_EnterScope(); | |
| 1176 int handle = GetArgAsInt(arguments, 0); | |
| 1177 Context2D(handle)->BeginPath(); | |
| 1178 Dart_ExitScope(); | |
| 1179 LOGI("Out C2DBeginPath"); | |
| 1180 } | |
| 1181 | |
| 1182 void C2DBezierCurveTo(Dart_NativeArguments arguments) { | |
| 1183 LOGI("In C2DBezierCurveTo"); | |
| 1184 Dart_EnterScope(); | |
| 1185 int handle = GetArgAsInt(arguments, 0); | |
| 1186 double cp1x = GetArgAsDouble(arguments, 1); | |
| 1187 double cp1y = GetArgAsDouble(arguments, 2); | |
| 1188 double cp2x = GetArgAsDouble(arguments, 3); | |
| 1189 double cp2y = GetArgAsDouble(arguments, 4); | |
| 1190 double x = GetArgAsDouble(arguments, 5); | |
| 1191 double y = GetArgAsDouble(arguments, 6); | |
| 1192 Context2D(handle)->BezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y); | |
| 1193 Dart_ExitScope(); | |
| 1194 LOGI("Out C2DBezierCurveTo"); | |
| 1195 } | |
| 1196 | |
| 1197 void C2DClearRect(Dart_NativeArguments arguments) { | |
| 1198 LOGI("In C2DClearRect"); | |
| 1199 Dart_EnterScope(); | |
| 1200 int handle = GetArgAsInt(arguments, 0); | |
| 1201 double left = GetArgAsDouble(arguments, 1); | |
| 1202 double top = GetArgAsDouble(arguments, 2); | |
| 1203 double width = GetArgAsDouble(arguments, 3); | |
| 1204 double height = GetArgAsDouble(arguments, 4); | |
| 1205 Context2D(handle)->ClearRect(left, top, width, height); | |
| 1206 Dart_ExitScope(); | |
| 1207 LOGI("Out C2DClearRect"); | |
| 1208 } | |
| 1209 | |
| 1210 void C2DClip(Dart_NativeArguments arguments) { | |
| 1211 LOGI("In C2DClip"); | |
| 1212 Dart_EnterScope(); | |
| 1213 int handle = GetArgAsInt(arguments, 0); | |
| 1214 Context2D(handle)->Clip(); | |
| 1215 Dart_ExitScope(); | |
| 1216 LOGI("Out C2DClip"); | |
| 1217 } | |
| 1218 | |
| 1219 void C2DClosePath(Dart_NativeArguments arguments) { | |
| 1220 LOGI("In C2DClosePath"); | |
| 1221 Dart_EnterScope(); | |
| 1222 int handle = GetArgAsInt(arguments, 0); | |
| 1223 Context2D(handle)->ClosePath(); | |
| 1224 Dart_ExitScope(); | |
| 1225 LOGI("Out C2DClosePath"); | |
| 1226 } | |
| 1227 | |
| 1228 void C2DCreateImageDataFromDimensions(Dart_NativeArguments arguments) { | |
| 1229 LOGI("In C2DCreateImageDataFromDimensions"); | |
| 1230 Dart_EnterScope(); | |
| 1231 // int handle = GetArgAsInt(arguments, 0); | |
| 1232 // double sw = GetArgAsDouble(arguments, 1); | |
| 1233 // double sh = GetArgAsDouble(arguments, 2); | |
| 1234 // GLubyte* pixels = (GLubyte*)calloc(sw * sh * 4, sizeof(GLubyte)); | |
| 1235 // ImageData* imageData = new ImageData(sw, sh, pixels); | |
| 1236 // TODO(gram): How do we create a Dart ImageData object from this? | |
| 1237 Dart_ExitScope(); | |
| 1238 LOGI("Out C2DCreateImageDataFromDimensions"); | |
| 1239 } | |
| 1240 | |
| 1241 void C2DDrawImage(Dart_NativeArguments arguments) { | |
| 1242 LOGI("In C2DDrawImage"); | |
| 1243 Dart_EnterScope(); | |
| 1244 int handle = GetArgAsInt(arguments, 0); | |
| 1245 const char* src_url = GetArgAsString(arguments, 1); | |
| 1246 int sx = GetArgAsInt(arguments, 2); | |
| 1247 int sy = GetArgAsInt(arguments, 3); | |
| 1248 bool has_src_dimensions = GetArgAsBool(arguments, 4); | |
| 1249 int sw = GetArgAsInt(arguments, 5); | |
| 1250 int sh = GetArgAsInt(arguments, 6); | |
| 1251 int dx = GetArgAsInt(arguments, 7); | |
| 1252 int dy = GetArgAsInt(arguments, 8); | |
| 1253 bool has_dst_dimensions = GetArgAsBool(arguments, 9); | |
| 1254 int dw = GetArgAsInt(arguments, 10); | |
| 1255 int dh = GetArgAsInt(arguments, 11); | |
| 1256 Context2D(handle)->DrawImage(src_url, | |
| 1257 sx, sy, has_src_dimensions, sw, sh, | |
| 1258 dx, dy, has_dst_dimensions, dw, dh); | |
| 1259 Dart_ExitScope(); | |
| 1260 LOGI("Out C2DDrawImage"); | |
| 1261 } | |
| 1262 | |
| 1263 void C2DFill(Dart_NativeArguments arguments) { | |
| 1264 LOGI("In C2DFill"); | |
| 1265 Dart_EnterScope(); | |
| 1266 int handle = GetArgAsInt(arguments, 0); | |
| 1267 Context2D(handle)->Fill(); | |
| 1268 Dart_ExitScope(); | |
| 1269 LOGI("Out C2DFill"); | |
| 1270 } | |
| 1271 | |
| 1272 void C2DFillRect(Dart_NativeArguments arguments) { | |
| 1273 LOGI("In C2DFillRect"); | |
| 1274 Dart_EnterScope(); | |
| 1275 int handle = GetArgAsInt(arguments, 0); | |
| 1276 double left = GetArgAsDouble(arguments, 1); | |
| 1277 double top = GetArgAsDouble(arguments, 2); | |
| 1278 double width = GetArgAsDouble(arguments, 3); | |
| 1279 double height = GetArgAsDouble(arguments, 4); | |
| 1280 Context2D(handle)->FillRect(left, top, width, height); | |
| 1281 Dart_ExitScope(); | |
| 1282 LOGI("Out C2DFillRect"); | |
| 1283 } | |
| 1284 | |
| 1285 void C2DFillText(Dart_NativeArguments arguments) { | |
| 1286 LOGI("In C2DFillText"); | |
| 1287 Dart_EnterScope(); | |
| 1288 int handle = GetArgAsInt(arguments, 0); | |
| 1289 const char* text = GetArgAsString(arguments, 1); | |
| 1290 double x = GetArgAsDouble(arguments, 2); | |
| 1291 double y = GetArgAsDouble(arguments, 3); | |
| 1292 double maxWidth = GetArgAsDouble(arguments, 4); | |
| 1293 Context2D(handle)->FillText(text, x, y, maxWidth); | |
| 1294 Dart_ExitScope(); | |
| 1295 LOGI("Out C2DFillText"); | |
| 1296 } | |
| 1297 | |
| 1298 void C2DGetImageData(Dart_NativeArguments arguments) { | |
| 1299 LOGI("In C2DGetImageData"); | |
| 1300 Dart_EnterScope(); | |
| 1301 // TODO(gram): Complete this. | |
| 1302 // int handle = GetArgAsInt(arguments, 0); | |
| 1303 // double sx = GetArgAsDouble(arguments, 1); | |
| 1304 // double sy = GetArgAsDouble(arguments, 2); | |
| 1305 // double sw = GetArgAsDouble(arguments, 3); | |
| 1306 // double sh = GetArgAsDouble(arguments, 4); | |
| 1307 // ... = Context2D(handle)->GetImageData(text, x, y, maxWidth); | |
| 1308 Dart_ExitScope(); | |
| 1309 LOGI("Out C2DGetImageData"); | |
| 1310 } | |
| 1311 | |
| 1312 void C2DLineTo(Dart_NativeArguments arguments) { | |
| 1313 LOGI("In C2DLineTo"); | |
| 1314 Dart_EnterScope(); | |
| 1315 int handle = GetArgAsInt(arguments, 0); | |
| 1316 double x = GetArgAsDouble(arguments, 1); | |
| 1317 double y = GetArgAsDouble(arguments, 2); | |
| 1318 Context2D(handle)->LineTo(x, y); | |
| 1319 Dart_ExitScope(); | |
| 1320 LOGI("Out C2DLineTo"); | |
| 1321 } | |
| 1322 | |
| 1323 void C2DMeasureText(Dart_NativeArguments arguments) { | |
| 1324 LOGI("In C2DMeasureText"); | |
| 1325 Dart_EnterScope(); | |
| 1326 int handle = GetArgAsInt(arguments, 0); | |
| 1327 const char* text = GetArgAsString(arguments, 1); | |
| 1328 float width = Context2D(handle)->MeasureText(text); | |
| 1329 SetDoubleReturnValue(arguments, width); | |
| 1330 Dart_ExitScope(); | |
| 1331 LOGI("Out C2DMeasureText"); | |
| 1332 } | |
| 1333 | |
| 1334 void C2DMoveTo(Dart_NativeArguments arguments) { | |
| 1335 LOGI("IN C2DMoveTo"); | |
| 1336 Dart_EnterScope(); | |
| 1337 int handle = GetArgAsInt(arguments, 0); | |
| 1338 double x = GetArgAsDouble(arguments, 1); | |
| 1339 double y = GetArgAsDouble(arguments, 2); | |
| 1340 Context2D(handle)->MoveTo(x, y); | |
| 1341 Dart_ExitScope(); | |
| 1342 LOGI("Out C2DMoveTo"); | |
| 1343 } | |
| 1344 | |
| 1345 void C2DPutImageData(Dart_NativeArguments arguments) { | |
| 1346 LOGI("IN C2DPutImageData"); | |
| 1347 Dart_EnterScope(); | |
| 1348 int handle = GetArgAsInt(arguments, 0); | |
| 1349 // Get object arguments 2 | |
| 1350 // BindingImageData* imageData = GetArgAsObject(arguments, 1); | |
| 1351 double dx = GetArgAsDouble(arguments, 2); | |
| 1352 double dy = GetArgAsDouble(arguments, 3); | |
| 1353 Context2D(handle)->PutImageData(NULL, dx, dy); | |
| 1354 Dart_ExitScope(); | |
| 1355 LOGI("Out C2DPutImageData"); | |
| 1356 } | |
| 1357 | |
| 1358 void C2DQuadraticCurveTo(Dart_NativeArguments arguments) { | |
| 1359 LOGI("In C2DQuadraticCurveTo"); | |
| 1360 Dart_EnterScope(); | |
| 1361 int handle = GetArgAsInt(arguments, 0); | |
| 1362 double cpx = GetArgAsDouble(arguments, 1); | |
| 1363 double cpy = GetArgAsDouble(arguments, 2); | |
| 1364 double x = GetArgAsDouble(arguments, 3); | |
| 1365 double y = GetArgAsDouble(arguments, 4); | |
| 1366 Context2D(handle)->QuadraticCurveTo(cpx, cpy, x, y); | |
| 1367 Dart_ExitScope(); | |
| 1368 LOGI("Out C2DQuadraticCurveTo"); | |
| 1369 } | |
| 1370 | |
| 1371 void C2DRect(Dart_NativeArguments arguments) { | |
| 1372 LOGI("In C2DRect"); | |
| 1373 Dart_EnterScope(); | |
| 1374 int handle = GetArgAsInt(arguments, 0); | |
| 1375 double x = GetArgAsDouble(arguments, 1); | |
| 1376 double y = GetArgAsDouble(arguments, 2); | |
| 1377 double w = GetArgAsDouble(arguments, 3); | |
| 1378 double h = GetArgAsDouble(arguments, 4); | |
| 1379 Context2D(handle)->Rect(x, y, w, h); | |
| 1380 Dart_ExitScope(); | |
| 1381 LOGI("Out C2DRect"); | |
| 1382 } | |
| 1383 | |
| 1384 void C2DRestore(Dart_NativeArguments arguments) { | |
| 1385 LOGI("In C2DRestore"); | |
| 1386 Dart_EnterScope(); | |
| 1387 int handle = GetArgAsInt(arguments, 0); | |
| 1388 CanvasContext* context = Context2D(handle); | |
| 1389 context->Restore(); | |
| 1390 Dart_ExitScope(); | |
| 1391 LOGI("Out C2DRestore"); | |
| 1392 } | |
| 1393 | |
| 1394 void C2DRotate(Dart_NativeArguments arguments) { | |
| 1395 LOGI("In C2DRotate"); | |
| 1396 Dart_EnterScope(); | |
| 1397 int handle = GetArgAsInt(arguments, 0); | |
| 1398 double a = GetArgAsDouble(arguments, 1); | |
| 1399 Context2D(handle)->Rotate(a); | |
| 1400 Dart_ExitScope(); | |
| 1401 LOGI("Out C2DRotate"); | |
| 1402 } | |
| 1403 | |
| 1404 void C2DSave(Dart_NativeArguments arguments) { | |
| 1405 LOGI("In C2DSave"); | |
| 1406 Dart_EnterScope(); | |
| 1407 int handle = GetArgAsInt(arguments, 0); | |
| 1408 Context2D(handle)->Save(); | |
| 1409 Dart_ExitScope(); | |
| 1410 LOGI("Out C2DSave"); | |
| 1411 } | |
| 1412 | |
| 1413 void C2DScale(Dart_NativeArguments arguments) { | |
| 1414 LOGI("In C2DScale"); | |
| 1415 Dart_EnterScope(); | |
| 1416 int handle = GetArgAsInt(arguments, 0); | |
| 1417 double sx = GetArgAsDouble(arguments, 1); | |
| 1418 double sy = GetArgAsDouble(arguments, 2); | |
| 1419 Context2D(handle)->Scale(sx, sy); | |
| 1420 Dart_ExitScope(); | |
| 1421 LOGI("Out C2DScale"); | |
| 1422 } | |
| 1423 | |
| 1424 void C2DSetLineDash(Dart_NativeArguments arguments) { | |
| 1425 LOGI("In C2DSetLineDash"); | |
| 1426 Dart_EnterScope(); | |
| 1427 int handle = GetArgAsInt(arguments, 0); | |
| 1428 int len; | |
| 1429 float* dash = static_cast<float*>(GetArgsAsFloatList(arguments, 1, &len)); | |
| 1430 if (dash != NULL) { | |
| 1431 Context2D(handle)->setLineDash(dash, len); | |
| 1432 delete[] dash; | |
| 1433 } | |
| 1434 Dart_ExitScope(); | |
| 1435 LOGI("Out C2DSetLineDash"); | |
| 1436 } | |
| 1437 | |
| 1438 void C2DSetLineDashOffset(Dart_NativeArguments arguments) { | |
| 1439 LOGI("In C2DSetLineDashOffset"); | |
| 1440 Dart_EnterScope(); | |
| 1441 int handle = GetArgAsInt(arguments, 0); | |
| 1442 double offset = GetArgAsDouble(arguments, 1); | |
| 1443 Context2D(handle)->setLineDashOffset(offset); | |
| 1444 Dart_ExitScope(); | |
| 1445 LOGI("Out C2DSetLineDashOffset"); | |
| 1446 } | |
| 1447 | |
| 1448 void C2DSetTransform(Dart_NativeArguments arguments) { | |
| 1449 LOGI("In C2DSetTransform"); | |
| 1450 Dart_EnterScope(); | |
| 1451 int handle = GetArgAsInt(arguments, 0); | |
| 1452 double m11 = GetArgAsDouble(arguments, 1); | |
| 1453 double m12 = GetArgAsDouble(arguments, 2); | |
| 1454 double m21 = GetArgAsDouble(arguments, 3); | |
| 1455 double m22 = GetArgAsDouble(arguments, 4); | |
| 1456 double dx = GetArgAsDouble(arguments, 5); | |
| 1457 double dy = GetArgAsDouble(arguments, 6); | |
| 1458 Context2D(handle)->setTransform(m11, m12, m21, m22, dx, dy); | |
| 1459 Dart_ExitScope(); | |
| 1460 LOGI("Out C2DSetTransform"); | |
| 1461 } | |
| 1462 | |
| 1463 void C2DStroke(Dart_NativeArguments arguments) { | |
| 1464 LOGI("In C2DStroke"); | |
| 1465 Dart_EnterScope(); | |
| 1466 int handle = GetArgAsInt(arguments, 0); | |
| 1467 Context2D(handle)->Stroke(); | |
| 1468 Dart_ExitScope(); | |
| 1469 LOGI("Out C2DStroke"); | |
| 1470 } | |
| 1471 | |
| 1472 void C2DStrokeRect(Dart_NativeArguments arguments) { | |
| 1473 LOGI("In C2DStrokeRect"); | |
| 1474 Dart_EnterScope(); | |
| 1475 int handle = GetArgAsInt(arguments, 0); | |
| 1476 double left = GetArgAsDouble(arguments, 1); | |
| 1477 double top = GetArgAsDouble(arguments, 2); | |
| 1478 double width = GetArgAsDouble(arguments, 3); | |
| 1479 double height = GetArgAsDouble(arguments, 4); | |
| 1480 Context2D(handle)->StrokeRect(left, top, width, height); | |
| 1481 Dart_ExitScope(); | |
| 1482 LOGI("Out C2DStrokeRect"); | |
| 1483 } | |
| 1484 | |
| 1485 void C2DStrokeText(Dart_NativeArguments arguments) { | |
| 1486 LOGI("In C2DStrokeText"); | |
| 1487 Dart_EnterScope(); | |
| 1488 int handle = GetArgAsInt(arguments, 0); | |
| 1489 const char* text = GetArgAsString(arguments, 1); | |
| 1490 double x = GetArgAsDouble(arguments, 2); | |
| 1491 double y = GetArgAsDouble(arguments, 3); | |
| 1492 double maxWidth = GetArgAsDouble(arguments, 4); | |
| 1493 Context2D(handle)->StrokeText(text, x, y, maxWidth); | |
| 1494 Dart_ExitScope(); | |
| 1495 LOGI("Out C2DStrokeText"); | |
| 1496 } | |
| 1497 | |
| 1498 void C2DTransform(Dart_NativeArguments arguments) { | |
| 1499 LOGI("In C2DTransform"); | |
| 1500 Dart_EnterScope(); | |
| 1501 int handle = GetArgAsInt(arguments, 0); | |
| 1502 double m11 = GetArgAsDouble(arguments, 1); | |
| 1503 double m12 = GetArgAsDouble(arguments, 2); | |
| 1504 double m21 = GetArgAsDouble(arguments, 3); | |
| 1505 double m22 = GetArgAsDouble(arguments, 4); | |
| 1506 double dx = GetArgAsDouble(arguments, 5); | |
| 1507 double dy = GetArgAsDouble(arguments, 6); | |
| 1508 Context2D(handle)->Transform(m11, m12, m21, m22, dx, dy); | |
| 1509 Dart_ExitScope(); | |
| 1510 LOGI("Out C2DTransform"); | |
| 1511 } | |
| 1512 | |
| 1513 void C2DTranslate(Dart_NativeArguments arguments) { | |
| 1514 LOGI("In C2DTranslate"); | |
| 1515 Dart_EnterScope(); | |
| 1516 int handle = GetArgAsInt(arguments, 0); | |
| 1517 double x = GetArgAsDouble(arguments, 1); | |
| 1518 double y = GetArgAsDouble(arguments, 2); | |
| 1519 Context2D(handle)->Translate(x, y); | |
| 1520 Dart_ExitScope(); | |
| 1521 LOGI("Out C2DTranslate"); | |
| 1522 } | |
| 1523 | |
| 1524 void C2DSetFillGradient(Dart_NativeArguments arguments) { | |
| 1525 LOGI("In C2DSetFillGradient"); | |
| 1526 Dart_EnterScope(); | |
| 1527 int handle = GetArgAsInt(arguments, 0); | |
| 1528 bool is_radial = GetArgAsBool(arguments, 1); | |
| 1529 double x0 = GetArgAsDouble(arguments, 2); | |
| 1530 double y0 = GetArgAsDouble(arguments, 3); | |
| 1531 double r0 = GetArgAsDouble(arguments, 4); | |
| 1532 double x1 = GetArgAsDouble(arguments, 5); | |
| 1533 double y1 = GetArgAsDouble(arguments, 6); | |
| 1534 double r1 = GetArgAsDouble(arguments, 7); | |
| 1535 int num_positions, num_colors; | |
| 1536 float* positions = GetArgsAsFloatList(arguments, 8, &num_positions); | |
| 1537 char** colors = GetArgsAsStringList(arguments, 9, &num_colors); | |
| 1538 Context2D(handle)->SetFillGradient(is_radial, x0, y0, r0, x1, y1, r1, | |
| 1539 num_positions, positions, colors); | |
| 1540 Dart_ExitScope(); | |
| 1541 LOGI("Out C2DSetFillGradient"); | |
| 1542 } | |
| 1543 | |
| 1544 void C2DSetStrokeGradient(Dart_NativeArguments arguments) { | |
| 1545 LOGI("In C2DSetStrokeGradient"); | |
| 1546 Dart_EnterScope(); | |
| 1547 int handle = GetArgAsInt(arguments, 0); | |
| 1548 bool is_radial = GetArgAsBool(arguments, 1); | |
| 1549 double x0 = GetArgAsDouble(arguments, 2); | |
| 1550 double y0 = GetArgAsDouble(arguments, 3); | |
| 1551 double r0 = GetArgAsDouble(arguments, 4); | |
| 1552 double x1 = GetArgAsDouble(arguments, 5); | |
| 1553 double y1 = GetArgAsDouble(arguments, 6); | |
| 1554 double r1 = GetArgAsDouble(arguments, 7); | |
| 1555 int num_positions, num_colors; | |
| 1556 float* positions = GetArgsAsFloatList(arguments, 8, &num_positions); | |
| 1557 char** colors = GetArgsAsStringList(arguments, 9, &num_colors); | |
| 1558 Context2D(handle)->SetStrokeGradient(is_radial, x0, y0, r0, x1, y1, r1, | |
| 1559 num_positions, positions, colors); | |
| 1560 Dart_ExitScope(); | |
| 1561 LOGI("Out C2DSetStrokeGradient"); | |
| 1562 } | |
| 1563 | |
| 1564 void C2DGetImageWidth(Dart_NativeArguments arguments) { | |
| 1565 LOGI("In C2DGetImageWidth"); | |
| 1566 Dart_EnterScope(); | |
| 1567 const char* src_url = GetArgAsString(arguments, 0); | |
| 1568 int w = ImageCache::GetWidth(src_url); | |
| 1569 SetIntReturnValue(arguments, w); | |
| 1570 Dart_ExitScope(); | |
| 1571 LOGI("Out C2DGetImageWidth"); | |
| 1572 } | |
| 1573 | |
| 1574 void C2DGetImageHeight(Dart_NativeArguments arguments) { | |
| 1575 LOGI("In C2DGetImageHeight"); | |
| 1576 Dart_EnterScope(); | |
| 1577 const char* src_url = GetArgAsString(arguments, 0); | |
| 1578 int h = ImageCache::GetHeight(src_url); | |
| 1579 SetIntReturnValue(arguments, h); | |
| 1580 Dart_ExitScope(); | |
| 1581 LOGI("Out C2DGetImageHeight"); | |
| 1582 } | |
| 1583 | |
| 1584 struct FunctionLookup { | |
| 1585 const char* name; | |
| 1586 Dart_NativeFunction function; | |
| 1587 }; | |
| 1588 | |
| 1589 FunctionLookup function_list[] = { | |
| 1590 {"Log", Log}, | |
| 1591 {"LogError", LogError}, | |
| 1592 {"SystemRand", SystemRand}, | |
| 1593 {"SystemSrand", SystemSrand}, | |
| 1594 {"SwapBuffers", SwapBuffers}, | |
| 1595 {"GetDeviceScreenWidth", GetDeviceScreenWidth}, | |
| 1596 {"GetDeviceScreenHeight", GetDeviceScreenHeight}, | |
| 1597 {"GLAttachShader", GLAttachShader}, | |
| 1598 {"GLBindBuffer", GLBindBuffer}, | |
| 1599 {"GLBufferData", GLBufferData}, | |
| 1600 {"GLClear", GLClear}, | |
| 1601 {"GLClearColor", GLClearColor}, | |
| 1602 {"GLClearDepth", GLClearDepth}, | |
| 1603 {"GLCompileShader", GLCompileShader}, | |
| 1604 {"GLCreateBuffer", GLCreateBuffer}, | |
| 1605 {"GLCreateProgram", GLCreateProgram}, | |
| 1606 {"GLCreateShader", GLCreateShader}, | |
| 1607 {"GLDrawArrays", GLDrawArrays}, | |
| 1608 {"GLEnableVertexAttribArray", GLEnableVertexAttribArray}, | |
| 1609 {"GLGetAttribLocation", GLGetAttribLocation}, | |
| 1610 {"GLGetError", GLGetError}, | |
| 1611 {"GLGetProgramParameter", GLGetProgramParameter}, | |
| 1612 {"GLGetShaderParameter", GLGetShaderParameter}, | |
| 1613 {"GLGetUniformLocation", GLGetUniformLocation}, | |
| 1614 {"GLLinkProgram", GLLinkProgram}, | |
| 1615 {"GLShaderSource", GLShaderSource}, | |
| 1616 {"GLUniform1f", GLUniform1f}, | |
| 1617 {"GLUniform2f", GLUniform2f}, | |
| 1618 {"GLUniform3f", GLUniform3f}, | |
| 1619 {"GLUniform4f", GLUniform4f}, | |
| 1620 {"GLUniform1i", GLUniform1i}, | |
| 1621 {"GLUniform2i", GLUniform2i}, | |
| 1622 {"GLUniform3i", GLUniform3i}, | |
| 1623 {"GLUniform4i", GLUniform4i}, | |
| 1624 {"GLUniform1fv", GLUniform1fv}, | |
| 1625 {"GLUniform2fv", GLUniform2fv}, | |
| 1626 {"GLUniform3fv", GLUniform3fv}, | |
| 1627 {"GLUniform4fv", GLUniform4fv}, | |
| 1628 {"GLUniform1iv", GLUniform1iv}, | |
| 1629 {"GLUniform2iv", GLUniform2iv}, | |
| 1630 {"GLUniform3iv", GLUniform3iv}, | |
| 1631 {"GLUniform4iv", GLUniform4iv}, | |
| 1632 {"GLUseProgram", GLUseProgram}, | |
| 1633 {"GLVertexAttribPointer", GLVertexAttribPointer}, | |
| 1634 {"GLViewport", GLViewport}, | |
| 1635 {"GLArrayBuffer", GLArrayBuffer}, | |
| 1636 {"GLColorBufferBit", GLColorBufferBit}, | |
| 1637 {"GLCompileStatus", GLCompileStatus}, | |
| 1638 {"GLDeleteStatus", GLDeleteStatus}, | |
| 1639 {"GLDepthBufferBit", GLDepthBufferBit}, | |
| 1640 {"GLFloat", GLFloat}, | |
| 1641 {"GLFragmentShader", GLFragmentShader}, | |
| 1642 {"GLLinkStatus", GLLinkStatus}, | |
| 1643 {"GLTriangleStrip", GLTriangleStrip}, | |
| 1644 {"GLTriangles", GLTriangles}, | |
| 1645 {"GLTrue", GLTrue}, | |
| 1646 {"GLStaticDraw", GLStaticDraw}, | |
| 1647 {"GLValidateStatus", GLValidateStatus}, | |
| 1648 {"GLVertexShader", GLVertexShader}, | |
| 1649 {"GLGetShaderInfoLog", GLGetShaderInfoLog}, | |
| 1650 {"GLGetProgramInfoLog", GLGetProgramInfoLog}, | |
| 1651 {"RandomArray_ServicePort", RandomArrayServicePort}, | |
| 1652 | |
| 1653 // Audio support. | |
| 1654 {"PlayBackground", PlayBackground}, | |
| 1655 {"StopBackground", StopBackground}, | |
| 1656 {"LoadSample", LoadSample}, | |
| 1657 {"PlaySample", PlaySample}, | |
| 1658 | |
| 1659 // 2D Support | |
| 1660 | |
| 1661 { "C2DCreateNativeContext", C2DCreateNativeContext}, | |
| 1662 | |
| 1663 // Property getters/setters. | |
| 1664 | |
| 1665 { "C2DSetWidth", C2DSetWidth}, | |
| 1666 { "C2DSetHeight", C2DSetHeight}, | |
| 1667 { "C2DSetGlobalAlpha", C2DSetGlobalAlpha}, | |
| 1668 { "C2DSetFillStyle", C2DSetFillStyle}, | |
| 1669 { "C2DSetFont", C2DSetFont}, | |
| 1670 { "C2DSetGlobalCompositeOperation", C2DSetGlobalCompositeOperation}, | |
| 1671 { "C2DSetLineCap", C2DSetLineCap}, | |
| 1672 { "C2DSetLineJoin", C2DSetLineJoin}, | |
| 1673 { "C2DSetLineWidth", C2DSetLineWidth}, | |
| 1674 { "C2DSetMiterLimit", C2DSetMiterLimit}, | |
| 1675 { "C2DSetShadowBlur", C2DSetShadowBlur}, | |
| 1676 { "C2DSetShadowColor", C2DSetShadowColor}, | |
| 1677 { "C2DSetShadowOffsetX", C2DSetShadowOffsetX}, | |
| 1678 { "C2DSetShadowOffsetY", C2DSetShadowOffsetY}, | |
| 1679 { "C2DSetStrokeStyle", C2DSetStrokeStyle}, | |
| 1680 { "C2DSetTextAlign", C2DSetTextAlign}, | |
| 1681 { "C2DSetTextBaseline", C2DSetTextBaseline}, | |
| 1682 { "C2DGetImageSmoothingEnabled", C2DGetImageSmoothingEnabled}, | |
| 1683 | |
| 1684 // Methods. | |
| 1685 { "C2DArc", C2DArc}, | |
| 1686 { "C2DArcTo", C2DArcTo}, | |
| 1687 { "C2DBeginPath", C2DBeginPath}, | |
| 1688 { "C2DBezierCurveTo", C2DBezierCurveTo}, | |
| 1689 { "C2DClearRect", C2DClearRect}, | |
| 1690 { "C2DClip", C2DClip}, | |
| 1691 { "C2DClosePath", C2DClosePath}, | |
| 1692 { "C2DCreateImageDataFromDimensions", C2DCreateImageDataFromDimensions}, | |
| 1693 { "C2DDrawImage", C2DDrawImage}, | |
| 1694 { "C2DFill", C2DFill}, | |
| 1695 { "C2DFillRect", C2DFillRect}, | |
| 1696 { "C2DFillText", C2DFillText}, | |
| 1697 { "C2DGetImageData", C2DGetImageData}, | |
| 1698 { "C2DLineTo", C2DLineTo}, | |
| 1699 { "C2DMeasureText", C2DMeasureText}, | |
| 1700 { "C2DMoveTo", C2DMoveTo}, | |
| 1701 { "C2DPutImageData", C2DPutImageData}, | |
| 1702 { "C2DQuadraticCurveTo", C2DQuadraticCurveTo}, | |
| 1703 { "C2DRect", C2DRect}, | |
| 1704 { "C2DRestore", C2DRestore}, | |
| 1705 { "C2DRotate", C2DRotate}, | |
| 1706 { "C2DSave", C2DSave}, | |
| 1707 { "C2DScale", C2DScale}, | |
| 1708 { "C2DSetLineDash", C2DSetLineDash}, | |
| 1709 { "C2DSetLineDashOffset", C2DSetLineDashOffset}, | |
| 1710 { "C2DSetTransform", C2DSetTransform}, | |
| 1711 { "C2DStroke", C2DStroke}, | |
| 1712 { "C2DStrokeRect", C2DStrokeRect}, | |
| 1713 { "C2DStrokeText", C2DStrokeText}, | |
| 1714 { "C2DTransform", C2DTransform}, | |
| 1715 { "C2DTranslate", C2DTranslate}, | |
| 1716 { "C2DSetFillGradient", C2DSetFillGradient}, | |
| 1717 { "C2DSetStrokeGradient", C2DSetStrokeGradient}, | |
| 1718 { "C2DGetImageWidth", C2DGetImageWidth}, | |
| 1719 { "C2DGetImageHeight", C2DGetImageHeight}, | |
| 1720 | |
| 1721 {NULL, NULL}}; | |
| 1722 | |
| 1723 Dart_NativeFunction ResolveName(Dart_Handle name, int argc) { | |
| 1724 if (!Dart_IsString(name)) return NULL; | |
| 1725 Dart_NativeFunction result = NULL; | |
| 1726 Dart_EnterScope(); | |
| 1727 const char* cname; | |
| 1728 HandleError(Dart_StringToCString(name, &cname)); | |
| 1729 for (int i = 0; function_list[i].name != NULL; ++i) { | |
| 1730 if (strcmp(function_list[i].name, cname) == 0) { | |
| 1731 result = function_list[i].function; | |
| 1732 break; | |
| 1733 } | |
| 1734 } | |
| 1735 Dart_ExitScope(); | |
| 1736 return result; | |
| 1737 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 25081002:
Remove openglui embedder code (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart