| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011, 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 // WARNING: Do not edit - generated code. | |
| 6 | |
| 7 class WebGLRenderingContextWrappingImplementation extends CanvasRenderingContext
WrappingImplementation implements WebGLRenderingContext { | |
| 8 WebGLRenderingContextWrappingImplementation._wrap(ptr) : super._wrap(ptr) {} | |
| 9 | |
| 10 int get drawingBufferHeight() { return _ptr.drawingBufferHeight; } | |
| 11 | |
| 12 int get drawingBufferWidth() { return _ptr.drawingBufferWidth; } | |
| 13 | |
| 14 void activeTexture(int texture) { | |
| 15 _ptr.activeTexture(texture); | |
| 16 return; | |
| 17 } | |
| 18 | |
| 19 void attachShader(WebGLProgram program, WebGLShader shader) { | |
| 20 _ptr.attachShader(LevelDom.unwrap(program), LevelDom.unwrap(shader)); | |
| 21 return; | |
| 22 } | |
| 23 | |
| 24 void bindAttribLocation(WebGLProgram program, int index, String name) { | |
| 25 _ptr.bindAttribLocation(LevelDom.unwrap(program), index, name); | |
| 26 return; | |
| 27 } | |
| 28 | |
| 29 void bindBuffer(int target, WebGLBuffer buffer) { | |
| 30 _ptr.bindBuffer(target, LevelDom.unwrap(buffer)); | |
| 31 return; | |
| 32 } | |
| 33 | |
| 34 void bindFramebuffer(int target, WebGLFramebuffer framebuffer) { | |
| 35 _ptr.bindFramebuffer(target, LevelDom.unwrap(framebuffer)); | |
| 36 return; | |
| 37 } | |
| 38 | |
| 39 void bindRenderbuffer(int target, WebGLRenderbuffer renderbuffer) { | |
| 40 _ptr.bindRenderbuffer(target, LevelDom.unwrap(renderbuffer)); | |
| 41 return; | |
| 42 } | |
| 43 | |
| 44 void bindTexture(int target, WebGLTexture texture) { | |
| 45 _ptr.bindTexture(target, LevelDom.unwrap(texture)); | |
| 46 return; | |
| 47 } | |
| 48 | |
| 49 void blendColor(num red, num green, num blue, num alpha) { | |
| 50 _ptr.blendColor(red, green, blue, alpha); | |
| 51 return; | |
| 52 } | |
| 53 | |
| 54 void blendEquation(int mode) { | |
| 55 _ptr.blendEquation(mode); | |
| 56 return; | |
| 57 } | |
| 58 | |
| 59 void blendEquationSeparate(int modeRGB, int modeAlpha) { | |
| 60 _ptr.blendEquationSeparate(modeRGB, modeAlpha); | |
| 61 return; | |
| 62 } | |
| 63 | |
| 64 void blendFunc(int sfactor, int dfactor) { | |
| 65 _ptr.blendFunc(sfactor, dfactor); | |
| 66 return; | |
| 67 } | |
| 68 | |
| 69 void blendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) { | |
| 70 _ptr.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); | |
| 71 return; | |
| 72 } | |
| 73 | |
| 74 void bufferData(int target, var data_OR_size, int usage) { | |
| 75 if (data_OR_size is ArrayBuffer) { | |
| 76 _ptr.bufferData(target, LevelDom.unwrapMaybePrimitive(data_OR_size), usage
); | |
| 77 return; | |
| 78 } else { | |
| 79 if (data_OR_size is ArrayBufferView) { | |
| 80 _ptr.bufferData(target, LevelDom.unwrapMaybePrimitive(data_OR_size), usa
ge); | |
| 81 return; | |
| 82 } else { | |
| 83 if (data_OR_size is int) { | |
| 84 _ptr.bufferData(target, LevelDom.unwrapMaybePrimitive(data_OR_size), u
sage); | |
| 85 return; | |
| 86 } | |
| 87 } | |
| 88 } | |
| 89 throw "Incorrect number or type of arguments"; | |
| 90 } | |
| 91 | |
| 92 void bufferSubData(int target, int offset, var data) { | |
| 93 if (data is ArrayBuffer) { | |
| 94 _ptr.bufferSubData(target, offset, LevelDom.unwrapMaybePrimitive(data)); | |
| 95 return; | |
| 96 } else { | |
| 97 if (data is ArrayBufferView) { | |
| 98 _ptr.bufferSubData(target, offset, LevelDom.unwrapMaybePrimitive(data)); | |
| 99 return; | |
| 100 } | |
| 101 } | |
| 102 throw "Incorrect number or type of arguments"; | |
| 103 } | |
| 104 | |
| 105 int checkFramebufferStatus(int target) { | |
| 106 return _ptr.checkFramebufferStatus(target); | |
| 107 } | |
| 108 | |
| 109 void clear(int mask) { | |
| 110 _ptr.clear(mask); | |
| 111 return; | |
| 112 } | |
| 113 | |
| 114 void clearColor(num red, num green, num blue, num alpha) { | |
| 115 _ptr.clearColor(red, green, blue, alpha); | |
| 116 return; | |
| 117 } | |
| 118 | |
| 119 void clearDepth(num depth) { | |
| 120 _ptr.clearDepth(depth); | |
| 121 return; | |
| 122 } | |
| 123 | |
| 124 void clearStencil(int s) { | |
| 125 _ptr.clearStencil(s); | |
| 126 return; | |
| 127 } | |
| 128 | |
| 129 void colorMask(bool red, bool green, bool blue, bool alpha) { | |
| 130 _ptr.colorMask(red, green, blue, alpha); | |
| 131 return; | |
| 132 } | |
| 133 | |
| 134 void compileShader(WebGLShader shader) { | |
| 135 _ptr.compileShader(LevelDom.unwrap(shader)); | |
| 136 return; | |
| 137 } | |
| 138 | |
| 139 void copyTexImage2D(int target, int level, int internalformat, int x, int y, i
nt width, int height, int border) { | |
| 140 _ptr.copyTexImage2D(target, level, internalformat, x, y, width, height, bord
er); | |
| 141 return; | |
| 142 } | |
| 143 | |
| 144 void copyTexSubImage2D(int target, int level, int xoffset, int yoffset, int x,
int y, int width, int height) { | |
| 145 _ptr.copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height)
; | |
| 146 return; | |
| 147 } | |
| 148 | |
| 149 WebGLBuffer createBuffer() { | |
| 150 return LevelDom.wrapWebGLBuffer(_ptr.createBuffer()); | |
| 151 } | |
| 152 | |
| 153 WebGLFramebuffer createFramebuffer() { | |
| 154 return LevelDom.wrapWebGLFramebuffer(_ptr.createFramebuffer()); | |
| 155 } | |
| 156 | |
| 157 WebGLProgram createProgram() { | |
| 158 return LevelDom.wrapWebGLProgram(_ptr.createProgram()); | |
| 159 } | |
| 160 | |
| 161 WebGLRenderbuffer createRenderbuffer() { | |
| 162 return LevelDom.wrapWebGLRenderbuffer(_ptr.createRenderbuffer()); | |
| 163 } | |
| 164 | |
| 165 WebGLShader createShader(int type) { | |
| 166 return LevelDom.wrapWebGLShader(_ptr.createShader(type)); | |
| 167 } | |
| 168 | |
| 169 WebGLTexture createTexture() { | |
| 170 return LevelDom.wrapWebGLTexture(_ptr.createTexture()); | |
| 171 } | |
| 172 | |
| 173 void cullFace(int mode) { | |
| 174 _ptr.cullFace(mode); | |
| 175 return; | |
| 176 } | |
| 177 | |
| 178 void deleteBuffer(WebGLBuffer buffer) { | |
| 179 _ptr.deleteBuffer(LevelDom.unwrap(buffer)); | |
| 180 return; | |
| 181 } | |
| 182 | |
| 183 void deleteFramebuffer(WebGLFramebuffer framebuffer) { | |
| 184 _ptr.deleteFramebuffer(LevelDom.unwrap(framebuffer)); | |
| 185 return; | |
| 186 } | |
| 187 | |
| 188 void deleteProgram(WebGLProgram program) { | |
| 189 _ptr.deleteProgram(LevelDom.unwrap(program)); | |
| 190 return; | |
| 191 } | |
| 192 | |
| 193 void deleteRenderbuffer(WebGLRenderbuffer renderbuffer) { | |
| 194 _ptr.deleteRenderbuffer(LevelDom.unwrap(renderbuffer)); | |
| 195 return; | |
| 196 } | |
| 197 | |
| 198 void deleteShader(WebGLShader shader) { | |
| 199 _ptr.deleteShader(LevelDom.unwrap(shader)); | |
| 200 return; | |
| 201 } | |
| 202 | |
| 203 void deleteTexture(WebGLTexture texture) { | |
| 204 _ptr.deleteTexture(LevelDom.unwrap(texture)); | |
| 205 return; | |
| 206 } | |
| 207 | |
| 208 void depthFunc(int func) { | |
| 209 _ptr.depthFunc(func); | |
| 210 return; | |
| 211 } | |
| 212 | |
| 213 void depthMask(bool flag) { | |
| 214 _ptr.depthMask(flag); | |
| 215 return; | |
| 216 } | |
| 217 | |
| 218 void depthRange(num zNear, num zFar) { | |
| 219 _ptr.depthRange(zNear, zFar); | |
| 220 return; | |
| 221 } | |
| 222 | |
| 223 void detachShader(WebGLProgram program, WebGLShader shader) { | |
| 224 _ptr.detachShader(LevelDom.unwrap(program), LevelDom.unwrap(shader)); | |
| 225 return; | |
| 226 } | |
| 227 | |
| 228 void disable(int cap) { | |
| 229 _ptr.disable(cap); | |
| 230 return; | |
| 231 } | |
| 232 | |
| 233 void disableVertexAttribArray(int index) { | |
| 234 _ptr.disableVertexAttribArray(index); | |
| 235 return; | |
| 236 } | |
| 237 | |
| 238 void drawArrays(int mode, int first, int count) { | |
| 239 _ptr.drawArrays(mode, first, count); | |
| 240 return; | |
| 241 } | |
| 242 | |
| 243 void drawElements(int mode, int count, int type, int offset) { | |
| 244 _ptr.drawElements(mode, count, type, offset); | |
| 245 return; | |
| 246 } | |
| 247 | |
| 248 void enable(int cap) { | |
| 249 _ptr.enable(cap); | |
| 250 return; | |
| 251 } | |
| 252 | |
| 253 void enableVertexAttribArray(int index) { | |
| 254 _ptr.enableVertexAttribArray(index); | |
| 255 return; | |
| 256 } | |
| 257 | |
| 258 void finish() { | |
| 259 _ptr.finish(); | |
| 260 return; | |
| 261 } | |
| 262 | |
| 263 void flush() { | |
| 264 _ptr.flush(); | |
| 265 return; | |
| 266 } | |
| 267 | |
| 268 void framebufferRenderbuffer(int target, int attachment, int renderbuffertarge
t, WebGLRenderbuffer renderbuffer) { | |
| 269 _ptr.framebufferRenderbuffer(target, attachment, renderbuffertarget, LevelDo
m.unwrap(renderbuffer)); | |
| 270 return; | |
| 271 } | |
| 272 | |
| 273 void framebufferTexture2D(int target, int attachment, int textarget, WebGLText
ure texture, int level) { | |
| 274 _ptr.framebufferTexture2D(target, attachment, textarget, LevelDom.unwrap(tex
ture), level); | |
| 275 return; | |
| 276 } | |
| 277 | |
| 278 void frontFace(int mode) { | |
| 279 _ptr.frontFace(mode); | |
| 280 return; | |
| 281 } | |
| 282 | |
| 283 void generateMipmap(int target) { | |
| 284 _ptr.generateMipmap(target); | |
| 285 return; | |
| 286 } | |
| 287 | |
| 288 WebGLActiveInfo getActiveAttrib(WebGLProgram program, int index) { | |
| 289 return LevelDom.wrapWebGLActiveInfo(_ptr.getActiveAttrib(LevelDom.unwrap(pro
gram), index)); | |
| 290 } | |
| 291 | |
| 292 WebGLActiveInfo getActiveUniform(WebGLProgram program, int index) { | |
| 293 return LevelDom.wrapWebGLActiveInfo(_ptr.getActiveUniform(LevelDom.unwrap(pr
ogram), index)); | |
| 294 } | |
| 295 | |
| 296 void getAttachedShaders(WebGLProgram program) { | |
| 297 _ptr.getAttachedShaders(LevelDom.unwrap(program)); | |
| 298 return; | |
| 299 } | |
| 300 | |
| 301 int getAttribLocation(WebGLProgram program, String name) { | |
| 302 return _ptr.getAttribLocation(LevelDom.unwrap(program), name); | |
| 303 } | |
| 304 | |
| 305 Object getBufferParameter(int target, int pname) { | |
| 306 return LevelDom.wrapObject(_ptr.getBufferParameter(target, pname)); | |
| 307 } | |
| 308 | |
| 309 WebGLContextAttributes getContextAttributes() { | |
| 310 return LevelDom.wrapWebGLContextAttributes(_ptr.getContextAttributes()); | |
| 311 } | |
| 312 | |
| 313 int getError() { | |
| 314 return _ptr.getError(); | |
| 315 } | |
| 316 | |
| 317 Object getExtension(String name) { | |
| 318 return LevelDom.wrapObject(_ptr.getExtension(name)); | |
| 319 } | |
| 320 | |
| 321 Object getFramebufferAttachmentParameter(int target, int attachment, int pname
) { | |
| 322 return LevelDom.wrapObject(_ptr.getFramebufferAttachmentParameter(target, at
tachment, pname)); | |
| 323 } | |
| 324 | |
| 325 Object getParameter(int pname) { | |
| 326 return LevelDom.wrapObject(_ptr.getParameter(pname)); | |
| 327 } | |
| 328 | |
| 329 String getProgramInfoLog(WebGLProgram program) { | |
| 330 return _ptr.getProgramInfoLog(LevelDom.unwrap(program)); | |
| 331 } | |
| 332 | |
| 333 Object getProgramParameter(WebGLProgram program, int pname) { | |
| 334 return LevelDom.wrapObject(_ptr.getProgramParameter(LevelDom.unwrap(program)
, pname)); | |
| 335 } | |
| 336 | |
| 337 Object getRenderbufferParameter(int target, int pname) { | |
| 338 return LevelDom.wrapObject(_ptr.getRenderbufferParameter(target, pname)); | |
| 339 } | |
| 340 | |
| 341 String getShaderInfoLog(WebGLShader shader) { | |
| 342 return _ptr.getShaderInfoLog(LevelDom.unwrap(shader)); | |
| 343 } | |
| 344 | |
| 345 Object getShaderParameter(WebGLShader shader, int pname) { | |
| 346 return LevelDom.wrapObject(_ptr.getShaderParameter(LevelDom.unwrap(shader),
pname)); | |
| 347 } | |
| 348 | |
| 349 String getShaderSource(WebGLShader shader) { | |
| 350 return _ptr.getShaderSource(LevelDom.unwrap(shader)); | |
| 351 } | |
| 352 | |
| 353 Object getTexParameter(int target, int pname) { | |
| 354 return LevelDom.wrapObject(_ptr.getTexParameter(target, pname)); | |
| 355 } | |
| 356 | |
| 357 Object getUniform(WebGLProgram program, WebGLUniformLocation location) { | |
| 358 return LevelDom.wrapObject(_ptr.getUniform(LevelDom.unwrap(program), LevelDo
m.unwrap(location))); | |
| 359 } | |
| 360 | |
| 361 WebGLUniformLocation getUniformLocation(WebGLProgram program, String name) { | |
| 362 return LevelDom.wrapWebGLUniformLocation(_ptr.getUniformLocation(LevelDom.un
wrap(program), name)); | |
| 363 } | |
| 364 | |
| 365 Object getVertexAttrib(int index, int pname) { | |
| 366 return LevelDom.wrapObject(_ptr.getVertexAttrib(index, pname)); | |
| 367 } | |
| 368 | |
| 369 int getVertexAttribOffset(int index, int pname) { | |
| 370 return _ptr.getVertexAttribOffset(index, pname); | |
| 371 } | |
| 372 | |
| 373 void hint(int target, int mode) { | |
| 374 _ptr.hint(target, mode); | |
| 375 return; | |
| 376 } | |
| 377 | |
| 378 bool isBuffer(WebGLBuffer buffer) { | |
| 379 return _ptr.isBuffer(LevelDom.unwrap(buffer)); | |
| 380 } | |
| 381 | |
| 382 bool isContextLost() { | |
| 383 return _ptr.isContextLost(); | |
| 384 } | |
| 385 | |
| 386 bool isEnabled(int cap) { | |
| 387 return _ptr.isEnabled(cap); | |
| 388 } | |
| 389 | |
| 390 bool isFramebuffer(WebGLFramebuffer framebuffer) { | |
| 391 return _ptr.isFramebuffer(LevelDom.unwrap(framebuffer)); | |
| 392 } | |
| 393 | |
| 394 bool isProgram(WebGLProgram program) { | |
| 395 return _ptr.isProgram(LevelDom.unwrap(program)); | |
| 396 } | |
| 397 | |
| 398 bool isRenderbuffer(WebGLRenderbuffer renderbuffer) { | |
| 399 return _ptr.isRenderbuffer(LevelDom.unwrap(renderbuffer)); | |
| 400 } | |
| 401 | |
| 402 bool isShader(WebGLShader shader) { | |
| 403 return _ptr.isShader(LevelDom.unwrap(shader)); | |
| 404 } | |
| 405 | |
| 406 bool isTexture(WebGLTexture texture) { | |
| 407 return _ptr.isTexture(LevelDom.unwrap(texture)); | |
| 408 } | |
| 409 | |
| 410 void lineWidth(num width) { | |
| 411 _ptr.lineWidth(width); | |
| 412 return; | |
| 413 } | |
| 414 | |
| 415 void linkProgram(WebGLProgram program) { | |
| 416 _ptr.linkProgram(LevelDom.unwrap(program)); | |
| 417 return; | |
| 418 } | |
| 419 | |
| 420 void pixelStorei(int pname, int param) { | |
| 421 _ptr.pixelStorei(pname, param); | |
| 422 return; | |
| 423 } | |
| 424 | |
| 425 void polygonOffset(num factor, num units) { | |
| 426 _ptr.polygonOffset(factor, units); | |
| 427 return; | |
| 428 } | |
| 429 | |
| 430 void readPixels(int x, int y, int width, int height, int format, int type, Arr
ayBufferView pixels) { | |
| 431 _ptr.readPixels(x, y, width, height, format, type, LevelDom.unwrap(pixels)); | |
| 432 return; | |
| 433 } | |
| 434 | |
| 435 void releaseShaderCompiler() { | |
| 436 _ptr.releaseShaderCompiler(); | |
| 437 return; | |
| 438 } | |
| 439 | |
| 440 void renderbufferStorage(int target, int internalformat, int width, int height
) { | |
| 441 _ptr.renderbufferStorage(target, internalformat, width, height); | |
| 442 return; | |
| 443 } | |
| 444 | |
| 445 void sampleCoverage(num value, bool invert) { | |
| 446 _ptr.sampleCoverage(value, invert); | |
| 447 return; | |
| 448 } | |
| 449 | |
| 450 void scissor(int x, int y, int width, int height) { | |
| 451 _ptr.scissor(x, y, width, height); | |
| 452 return; | |
| 453 } | |
| 454 | |
| 455 void shaderSource(WebGLShader shader, String string) { | |
| 456 _ptr.shaderSource(LevelDom.unwrap(shader), string); | |
| 457 return; | |
| 458 } | |
| 459 | |
| 460 void stencilFunc(int func, int ref, int mask) { | |
| 461 _ptr.stencilFunc(func, ref, mask); | |
| 462 return; | |
| 463 } | |
| 464 | |
| 465 void stencilFuncSeparate(int face, int func, int ref, int mask) { | |
| 466 _ptr.stencilFuncSeparate(face, func, ref, mask); | |
| 467 return; | |
| 468 } | |
| 469 | |
| 470 void stencilMask(int mask) { | |
| 471 _ptr.stencilMask(mask); | |
| 472 return; | |
| 473 } | |
| 474 | |
| 475 void stencilMaskSeparate(int face, int mask) { | |
| 476 _ptr.stencilMaskSeparate(face, mask); | |
| 477 return; | |
| 478 } | |
| 479 | |
| 480 void stencilOp(int fail, int zfail, int zpass) { | |
| 481 _ptr.stencilOp(fail, zfail, zpass); | |
| 482 return; | |
| 483 } | |
| 484 | |
| 485 void stencilOpSeparate(int face, int fail, int zfail, int zpass) { | |
| 486 _ptr.stencilOpSeparate(face, fail, zfail, zpass); | |
| 487 return; | |
| 488 } | |
| 489 | |
| 490 void texImage2D(int target, int level, int internalformat, int format_OR_width
, int height_OR_type, var border_OR_canvas_OR_image_OR_pixels, [int format, int
type, ArrayBufferView pixels]) { | |
| 491 if (border_OR_canvas_OR_image_OR_pixels is ImageData) { | |
| 492 if (format === null) { | |
| 493 if (type === null) { | |
| 494 if (pixels === null) { | |
| 495 _ptr.texImage2D(target, level, internalformat, format_OR_width, heig
ht_OR_type, LevelDom.unwrapMaybePrimitive(border_OR_canvas_OR_image_OR_pixels)); | |
| 496 return; | |
| 497 } | |
| 498 } | |
| 499 } | |
| 500 } else { | |
| 501 if (border_OR_canvas_OR_image_OR_pixels is ImageElement) { | |
| 502 if (format === null) { | |
| 503 if (type === null) { | |
| 504 if (pixels === null) { | |
| 505 _ptr.texImage2D(target, level, internalformat, format_OR_width, he
ight_OR_type, LevelDom.unwrapMaybePrimitive(border_OR_canvas_OR_image_OR_pixels)
); | |
| 506 return; | |
| 507 } | |
| 508 } | |
| 509 } | |
| 510 } else { | |
| 511 if (border_OR_canvas_OR_image_OR_pixels is CanvasElement) { | |
| 512 if (format === null) { | |
| 513 if (type === null) { | |
| 514 if (pixels === null) { | |
| 515 _ptr.texImage2D(target, level, internalformat, format_OR_width,
height_OR_type, LevelDom.unwrapMaybePrimitive(border_OR_canvas_OR_image_OR_pixel
s)); | |
| 516 return; | |
| 517 } | |
| 518 } | |
| 519 } | |
| 520 } else { | |
| 521 if (border_OR_canvas_OR_image_OR_pixels is int) { | |
| 522 _ptr.texImage2D(target, level, internalformat, format_OR_width, heig
ht_OR_type, LevelDom.unwrapMaybePrimitive(border_OR_canvas_OR_image_OR_pixels),
format, type, LevelDom.unwrap(pixels)); | |
| 523 return; | |
| 524 } | |
| 525 } | |
| 526 } | |
| 527 } | |
| 528 throw "Incorrect number or type of arguments"; | |
| 529 } | |
| 530 | |
| 531 void texParameterf(int target, int pname, num param) { | |
| 532 _ptr.texParameterf(target, pname, param); | |
| 533 return; | |
| 534 } | |
| 535 | |
| 536 void texParameteri(int target, int pname, int param) { | |
| 537 _ptr.texParameteri(target, pname, param); | |
| 538 return; | |
| 539 } | |
| 540 | |
| 541 void texSubImage2D(int target, int level, int xoffset, int yoffset, int format
_OR_width, int height_OR_type, var canvas_OR_format_OR_image_OR_pixels, [int typ
e, ArrayBufferView pixels]) { | |
| 542 if (canvas_OR_format_OR_image_OR_pixels is ImageData) { | |
| 543 if (type === null) { | |
| 544 if (pixels === null) { | |
| 545 _ptr.texSubImage2D(target, level, xoffset, yoffset, format_OR_width, h
eight_OR_type, LevelDom.unwrapMaybePrimitive(canvas_OR_format_OR_image_OR_pixels
)); | |
| 546 return; | |
| 547 } | |
| 548 } | |
| 549 } else { | |
| 550 if (canvas_OR_format_OR_image_OR_pixels is ImageElement) { | |
| 551 if (type === null) { | |
| 552 if (pixels === null) { | |
| 553 _ptr.texSubImage2D(target, level, xoffset, yoffset, format_OR_width,
height_OR_type, LevelDom.unwrapMaybePrimitive(canvas_OR_format_OR_image_OR_pixe
ls)); | |
| 554 return; | |
| 555 } | |
| 556 } | |
| 557 } else { | |
| 558 if (canvas_OR_format_OR_image_OR_pixels is CanvasElement) { | |
| 559 if (type === null) { | |
| 560 if (pixels === null) { | |
| 561 _ptr.texSubImage2D(target, level, xoffset, yoffset, format_OR_widt
h, height_OR_type, LevelDom.unwrapMaybePrimitive(canvas_OR_format_OR_image_OR_pi
xels)); | |
| 562 return; | |
| 563 } | |
| 564 } | |
| 565 } else { | |
| 566 if (canvas_OR_format_OR_image_OR_pixels is int) { | |
| 567 _ptr.texSubImage2D(target, level, xoffset, yoffset, format_OR_width,
height_OR_type, LevelDom.unwrapMaybePrimitive(canvas_OR_format_OR_image_OR_pixe
ls), type, LevelDom.unwrap(pixels)); | |
| 568 return; | |
| 569 } | |
| 570 } | |
| 571 } | |
| 572 } | |
| 573 throw "Incorrect number or type of arguments"; | |
| 574 } | |
| 575 | |
| 576 void uniform1f(WebGLUniformLocation location, num x) { | |
| 577 _ptr.uniform1f(LevelDom.unwrap(location), x); | |
| 578 return; | |
| 579 } | |
| 580 | |
| 581 void uniform1fv(WebGLUniformLocation location, Float32Array v) { | |
| 582 _ptr.uniform1fv(LevelDom.unwrap(location), LevelDom.unwrap(v)); | |
| 583 return; | |
| 584 } | |
| 585 | |
| 586 void uniform1i(WebGLUniformLocation location, int x) { | |
| 587 _ptr.uniform1i(LevelDom.unwrap(location), x); | |
| 588 return; | |
| 589 } | |
| 590 | |
| 591 void uniform1iv(WebGLUniformLocation location, Int32Array v) { | |
| 592 _ptr.uniform1iv(LevelDom.unwrap(location), LevelDom.unwrap(v)); | |
| 593 return; | |
| 594 } | |
| 595 | |
| 596 void uniform2f(WebGLUniformLocation location, num x, num y) { | |
| 597 _ptr.uniform2f(LevelDom.unwrap(location), x, y); | |
| 598 return; | |
| 599 } | |
| 600 | |
| 601 void uniform2fv(WebGLUniformLocation location, Float32Array v) { | |
| 602 _ptr.uniform2fv(LevelDom.unwrap(location), LevelDom.unwrap(v)); | |
| 603 return; | |
| 604 } | |
| 605 | |
| 606 void uniform2i(WebGLUniformLocation location, int x, int y) { | |
| 607 _ptr.uniform2i(LevelDom.unwrap(location), x, y); | |
| 608 return; | |
| 609 } | |
| 610 | |
| 611 void uniform2iv(WebGLUniformLocation location, Int32Array v) { | |
| 612 _ptr.uniform2iv(LevelDom.unwrap(location), LevelDom.unwrap(v)); | |
| 613 return; | |
| 614 } | |
| 615 | |
| 616 void uniform3f(WebGLUniformLocation location, num x, num y, num z) { | |
| 617 _ptr.uniform3f(LevelDom.unwrap(location), x, y, z); | |
| 618 return; | |
| 619 } | |
| 620 | |
| 621 void uniform3fv(WebGLUniformLocation location, Float32Array v) { | |
| 622 _ptr.uniform3fv(LevelDom.unwrap(location), LevelDom.unwrap(v)); | |
| 623 return; | |
| 624 } | |
| 625 | |
| 626 void uniform3i(WebGLUniformLocation location, int x, int y, int z) { | |
| 627 _ptr.uniform3i(LevelDom.unwrap(location), x, y, z); | |
| 628 return; | |
| 629 } | |
| 630 | |
| 631 void uniform3iv(WebGLUniformLocation location, Int32Array v) { | |
| 632 _ptr.uniform3iv(LevelDom.unwrap(location), LevelDom.unwrap(v)); | |
| 633 return; | |
| 634 } | |
| 635 | |
| 636 void uniform4f(WebGLUniformLocation location, num x, num y, num z, num w) { | |
| 637 _ptr.uniform4f(LevelDom.unwrap(location), x, y, z, w); | |
| 638 return; | |
| 639 } | |
| 640 | |
| 641 void uniform4fv(WebGLUniformLocation location, Float32Array v) { | |
| 642 _ptr.uniform4fv(LevelDom.unwrap(location), LevelDom.unwrap(v)); | |
| 643 return; | |
| 644 } | |
| 645 | |
| 646 void uniform4i(WebGLUniformLocation location, int x, int y, int z, int w) { | |
| 647 _ptr.uniform4i(LevelDom.unwrap(location), x, y, z, w); | |
| 648 return; | |
| 649 } | |
| 650 | |
| 651 void uniform4iv(WebGLUniformLocation location, Int32Array v) { | |
| 652 _ptr.uniform4iv(LevelDom.unwrap(location), LevelDom.unwrap(v)); | |
| 653 return; | |
| 654 } | |
| 655 | |
| 656 void uniformMatrix2fv(WebGLUniformLocation location, bool transpose, Float32Ar
ray array) { | |
| 657 _ptr.uniformMatrix2fv(LevelDom.unwrap(location), transpose, LevelDom.unwrap(
array)); | |
| 658 return; | |
| 659 } | |
| 660 | |
| 661 void uniformMatrix3fv(WebGLUniformLocation location, bool transpose, Float32Ar
ray array) { | |
| 662 _ptr.uniformMatrix3fv(LevelDom.unwrap(location), transpose, LevelDom.unwrap(
array)); | |
| 663 return; | |
| 664 } | |
| 665 | |
| 666 void uniformMatrix4fv(WebGLUniformLocation location, bool transpose, Float32Ar
ray array) { | |
| 667 _ptr.uniformMatrix4fv(LevelDom.unwrap(location), transpose, LevelDom.unwrap(
array)); | |
| 668 return; | |
| 669 } | |
| 670 | |
| 671 void useProgram(WebGLProgram program) { | |
| 672 _ptr.useProgram(LevelDom.unwrap(program)); | |
| 673 return; | |
| 674 } | |
| 675 | |
| 676 void validateProgram(WebGLProgram program) { | |
| 677 _ptr.validateProgram(LevelDom.unwrap(program)); | |
| 678 return; | |
| 679 } | |
| 680 | |
| 681 void vertexAttrib1f(int indx, num x) { | |
| 682 _ptr.vertexAttrib1f(indx, x); | |
| 683 return; | |
| 684 } | |
| 685 | |
| 686 void vertexAttrib1fv(int indx, Float32Array values) { | |
| 687 _ptr.vertexAttrib1fv(indx, LevelDom.unwrap(values)); | |
| 688 return; | |
| 689 } | |
| 690 | |
| 691 void vertexAttrib2f(int indx, num x, num y) { | |
| 692 _ptr.vertexAttrib2f(indx, x, y); | |
| 693 return; | |
| 694 } | |
| 695 | |
| 696 void vertexAttrib2fv(int indx, Float32Array values) { | |
| 697 _ptr.vertexAttrib2fv(indx, LevelDom.unwrap(values)); | |
| 698 return; | |
| 699 } | |
| 700 | |
| 701 void vertexAttrib3f(int indx, num x, num y, num z) { | |
| 702 _ptr.vertexAttrib3f(indx, x, y, z); | |
| 703 return; | |
| 704 } | |
| 705 | |
| 706 void vertexAttrib3fv(int indx, Float32Array values) { | |
| 707 _ptr.vertexAttrib3fv(indx, LevelDom.unwrap(values)); | |
| 708 return; | |
| 709 } | |
| 710 | |
| 711 void vertexAttrib4f(int indx, num x, num y, num z, num w) { | |
| 712 _ptr.vertexAttrib4f(indx, x, y, z, w); | |
| 713 return; | |
| 714 } | |
| 715 | |
| 716 void vertexAttrib4fv(int indx, Float32Array values) { | |
| 717 _ptr.vertexAttrib4fv(indx, LevelDom.unwrap(values)); | |
| 718 return; | |
| 719 } | |
| 720 | |
| 721 void vertexAttribPointer(int indx, int size, int type, bool normalized, int st
ride, int offset) { | |
| 722 _ptr.vertexAttribPointer(indx, size, type, normalized, stride, offset); | |
| 723 return; | |
| 724 } | |
| 725 | |
| 726 void viewport(int x, int y, int width, int height) { | |
| 727 _ptr.viewport(x, y, width, height); | |
| 728 return; | |
| 729 } | |
| 730 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 9537001:
Generate dart:html bindings for Dartium as well as Frog. All unittests now pass (or are disabled fo… (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart