1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.opengl; 18 19 import java.io.IOException; 20 import java.io.Writer; 21 import java.nio.Buffer; 22 import java.nio.ByteBuffer; 23 import java.nio.ByteOrder; 24 import java.nio.CharBuffer; 25 import java.nio.DoubleBuffer; 26 import java.nio.FloatBuffer; 27 import java.nio.IntBuffer; 28 import java.nio.LongBuffer; 29 import java.nio.ShortBuffer; 30 import java.util.Arrays; 31 32 import javax.microedition.khronos.opengles.GL; 33 34 /** 35 * A wrapper that logs all GL calls (and results) in human-readable form. 36 * 37 */ 38 class GLLogWrapper extends GLWrapperBase { 39 private static final int FORMAT_INT = 0; 40 private static final int FORMAT_FLOAT = 1; 41 private static final int FORMAT_FIXED = 2; 42 43 public GLLogWrapper(GL gl, Writer log, boolean logArgumentNames) { 44 super(gl); 45 mLog = log; 46 mLogArgumentNames = logArgumentNames; 47 } 48 49 private void checkError() { 50 int glError; 51 if ((glError = mgl.glGetError()) != 0) { 52 String errorMessage = "glError: " + Integer.toString(glError); 53 logLine(errorMessage); 54 } 55 } 56 57 private void logLine(String message) { 58 log(message + '\n'); 59 } 60 61 private void log(String message) { 62 try { 63 mLog.write(message); 64 } catch (IOException e) { 65 // Ignore exception, keep on trying 66 } 67 } 68 69 private void begin(String name) { 70 log(name + '('); 71 mArgCount = 0; 72 } 73 74 private void arg(String name, String value) { 75 if (mArgCount++ > 0) { 76 log(", "); 77 } 78 if (mLogArgumentNames) { 79 log(name + "="); 80 } 81 log(value); 82 } 83 84 private void end() { 85 log(");\n"); 86 flush(); 87 } 88 89 private void flush() { 90 try { 91 mLog.flush(); 92 } catch (IOException e) { 93 mLog = null; 94 } 95 } 96 97 private void arg(String name, boolean value) { 98 arg(name, Boolean.toString(value)); 99 } 100 101 private void arg(String name, int value) { 102 arg(name, Integer.toString(value)); 103 } 104 105 private void arg(String name, float value) { 106 arg(name, Float.toString(value)); 107 } 108 109 private void returns(String result) { 110 log(") returns " + result + ";\n"); 111 flush(); 112 } 113 114 private void returns(int result) { 115 returns(Integer.toString(result)); 116 } 117 118 private void arg(String name, int n, int[] arr, int offset) { 119 arg(name, toString(n, FORMAT_INT, arr, offset)); 120 } 121 122 private void arg(String name, int n, short[] arr, int offset) { 123 arg(name, toString(n, arr, offset)); 124 } 125 126 private void arg(String name, int n, float[] arr, int offset) { 127 arg(name, toString(n, arr, offset)); 128 } 129 130 private void formattedAppend(StringBuilder buf, int value, int format) { 131 switch (format) { 132 case FORMAT_INT: 133 buf.append(value); 134 break; 135 case FORMAT_FLOAT: 136 buf.append(Float.intBitsToFloat(value)); 137 break; 138 case FORMAT_FIXED: 139 buf.append(value / 65536.0f); 140 break; 141 } 142 } 143 144 private String toString(int n, int format, int[] arr, int offset) { 145 StringBuilder buf = new StringBuilder(); 146 buf.append("{\n"); 147 int arrLen = arr.length; 148 for (int i = 0; i < n; i++) { 149 int index = offset + i; 150 buf.append(" [" + index + "] = "); 151 if (index < 0 || index >= arrLen) { 152 buf.append("out of bounds"); 153 } else { 154 formattedAppend(buf, arr[index], format); 155 } 156 buf.append('\n'); 157 } 158 buf.append("}"); 159 return buf.toString(); 160 } 161 162 private String toString(int n, short[] arr, int offset) { 163 StringBuilder buf = new StringBuilder(); 164 buf.append("{\n"); 165 int arrLen = arr.length; 166 for (int i = 0; i < n; i++) { 167 int index = offset + i; 168 buf.append(" [" + index + "] = "); 169 if (index < 0 || index >= arrLen) { 170 buf.append("out of bounds"); 171 } else { 172 buf.append(arr[index]); 173 } 174 buf.append('\n'); 175 } 176 buf.append("}"); 177 return buf.toString(); 178 } 179 180 private String toString(int n, float[] arr, int offset) { 181 StringBuilder buf = new StringBuilder(); 182 buf.append("{\n"); 183 int arrLen = arr.length; 184 for (int i = 0; i < n; i++) { 185 int index = offset + i; 186 buf.append("[" + index + "] = "); 187 if (index < 0 || index >= arrLen) { 188 buf.append("out of bounds"); 189 } else { 190 buf.append(arr[index]); 191 } 192 buf.append('\n'); 193 } 194 buf.append("}"); 195 return buf.toString(); 196 } 197 198 private String toString(int n, FloatBuffer buf) { 199 StringBuilder builder = new StringBuilder(); 200 builder.append("{\n"); 201 for (int i = 0; i < n; i++) { 202 builder.append(" [" + i + "] = " + buf.get(i) + '\n'); 203 } 204 builder.append("}"); 205 return builder.toString(); 206 } 207 208 private String toString(int n, int format, IntBuffer buf) { 209 StringBuilder builder = new StringBuilder(); 210 builder.append("{\n"); 211 for (int i = 0; i < n; i++) { 212 builder.append(" [" + i + "] = "); 213 formattedAppend(builder, buf.get(i), format); 214 builder.append('\n'); 215 } 216 builder.append("}"); 217 return builder.toString(); 218 } 219 220 private String toString(int n, ShortBuffer buf) { 221 StringBuilder builder = new StringBuilder(); 222 builder.append("{\n"); 223 for (int i = 0; i < n; i++) { 224 builder.append(" [" + i + "] = " + buf.get(i) + '\n'); 225 } 226 builder.append("}"); 227 return builder.toString(); 228 } 229 230 private void arg(String name, int n, FloatBuffer buf) { 231 arg(name, toString(n, buf)); 232 } 233 234 private void arg(String name, int n, IntBuffer buf) { 235 arg(name, toString(n, FORMAT_INT, buf)); 236 } 237 238 private void arg(String name, int n, ShortBuffer buf) { 239 arg(name, toString(n, buf)); 240 } 241 242 private void argPointer(int size, int type, int stride, Buffer pointer) { 243 arg("size", size); 244 arg("type", getPointerTypeName(type)); 245 arg("stride", stride); 246 arg("pointer", pointer.toString()); 247 } 248 249 private static String getHex(int value) { 250 return "0x" + Integer.toHexString(value); 251 } 252 253 public static String getErrorString(int error) { 254 switch (error) { 255 case GL_NO_ERROR: 256 return "GL_NO_ERROR"; 257 case GL_INVALID_ENUM: 258 return "GL_INVALID_ENUM"; 259 case GL_INVALID_VALUE: 260 return "GL_INVALID_VALUE"; 261 case GL_INVALID_OPERATION: 262 return "GL_INVALID_OPERATION"; 263 case GL_STACK_OVERFLOW: 264 return "GL_STACK_OVERFLOW"; 265 case GL_STACK_UNDERFLOW: 266 return "GL_STACK_UNDERFLOW"; 267 case GL_OUT_OF_MEMORY: 268 return "GL_OUT_OF_MEMORY"; 269 default: 270 return getHex(error); 271 } 272 } 273 274 private String getClearBufferMask(int mask) { 275 StringBuilder b = new StringBuilder(); 276 if ((mask & GL_DEPTH_BUFFER_BIT) != 0) { 277 b.append("GL_DEPTH_BUFFER_BIT"); 278 mask &= ~GL_DEPTH_BUFFER_BIT; 279 } 280 if ((mask & GL_STENCIL_BUFFER_BIT) != 0) { 281 if (b.length() > 0) { 282 b.append(" | "); 283 } 284 b.append("GL_STENCIL_BUFFER_BIT"); 285 mask &= ~GL_STENCIL_BUFFER_BIT; 286 } 287 if ((mask & GL_COLOR_BUFFER_BIT) != 0) { 288 if (b.length() > 0) { 289 b.append(" | "); 290 } 291 b.append("GL_COLOR_BUFFER_BIT"); 292 mask &= ~GL_COLOR_BUFFER_BIT; 293 } 294 if (mask != 0) { 295 if (b.length() > 0) { 296 b.append(" | "); 297 } 298 b.append(getHex(mask)); 299 } 300 return b.toString(); 301 } 302 303 private String getFactor(int factor) { 304 switch(factor) { 305 case GL_ZERO: 306 return "GL_ZERO"; 307 case GL_ONE: 308 return "GL_ONE"; 309 case GL_SRC_COLOR: 310 return "GL_SRC_COLOR"; 311 case GL_ONE_MINUS_SRC_COLOR: 312 return "GL_ONE_MINUS_SRC_COLOR"; 313 case GL_DST_COLOR: 314 return "GL_DST_COLOR"; 315 case GL_ONE_MINUS_DST_COLOR: 316 return "GL_ONE_MINUS_DST_COLOR"; 317 case GL_SRC_ALPHA: 318 return "GL_SRC_ALPHA"; 319 case GL_ONE_MINUS_SRC_ALPHA: 320 return "GL_ONE_MINUS_SRC_ALPHA"; 321 case GL_DST_ALPHA: 322 return "GL_DST_ALPHA"; 323 case GL_ONE_MINUS_DST_ALPHA: 324 return "GL_ONE_MINUS_DST_ALPHA"; 325 case GL_SRC_ALPHA_SATURATE: 326 return "GL_SRC_ALPHA_SATURATE"; 327 328 default: 329 return getHex(factor); 330 } 331 } 332 333 private String getShadeModel(int model) { 334 switch(model) { 335 case GL_FLAT: 336 return "GL_FLAT"; 337 case GL_SMOOTH: 338 return "GL_SMOOTH"; 339 default: 340 return getHex(model); 341 } 342 } 343 344 private String getTextureTarget(int target) { 345 switch (target) { 346 case GL_TEXTURE_2D: 347 return "GL_TEXTURE_2D"; 348 default: 349 return getHex(target); 350 } 351 } 352 353 private String getTextureEnvTarget(int target) { 354 switch (target) { 355 case GL_TEXTURE_ENV: 356 return "GL_TEXTURE_ENV"; 357 default: 358 return getHex(target); 359 } 360 } 361 362 private String getTextureEnvPName(int pname) { 363 switch (pname) { 364 case GL_TEXTURE_ENV_MODE: 365 return "GL_TEXTURE_ENV_MODE"; 366 case GL_TEXTURE_ENV_COLOR: 367 return "GL_TEXTURE_ENV_COLOR"; 368 default: 369 return getHex(pname); 370 } 371 } 372 373 private int getTextureEnvParamCount(int pname) { 374 switch (pname) { 375 case GL_TEXTURE_ENV_MODE: 376 return 1; 377 case GL_TEXTURE_ENV_COLOR: 378 return 4; 379 default: 380 return 0; 381 } 382 } 383 384 private String getTextureEnvParamName(float param) { 385 int iparam = (int) param; 386 if (param == (float) iparam) { 387 switch (iparam) { 388 case GL_REPLACE: 389 return "GL_REPLACE"; 390 case GL_MODULATE: 391 return "GL_MODULATE"; 392 case GL_DECAL: 393 return "GL_DECAL"; 394 case GL_BLEND: 395 return "GL_BLEND"; 396 case GL_ADD: 397 return "GL_ADD"; 398 case GL_COMBINE: 399 return "GL_COMBINE"; 400 default: 401 return getHex(iparam); 402 } 403 } 404 return Float.toString(param); 405 } 406 407 private String getMatrixMode(int matrixMode) { 408 switch (matrixMode) { 409 case GL_MODELVIEW: 410 return "GL_MODELVIEW"; 411 case GL_PROJECTION: 412 return "GL_PROJECTION"; 413 case GL_TEXTURE: 414 return "GL_TEXTURE"; 415 default: 416 return getHex(matrixMode); 417 } 418 } 419 420 private String getClientState(int clientState) { 421 switch (clientState) { 422 case GL_COLOR_ARRAY: 423 return "GL_COLOR_ARRAY"; 424 case GL_VERTEX_ARRAY: 425 return "GL_VERTEX_ARRAY"; 426 case GL_NORMAL_ARRAY: 427 return "GL_NORMAL_ARRAY"; 428 case GL_TEXTURE_COORD_ARRAY: 429 return "GL_TEXTURE_COORD_ARRAY"; 430 default: 431 return getHex(clientState); 432 } 433 } 434 435 private String getCap(int cap) { 436 switch (cap) { 437 case GL_FOG: 438 return "GL_FOG"; 439 case GL_LIGHTING: 440 return "GL_LIGHTING"; 441 case GL_TEXTURE_2D: 442 return "GL_TEXTURE_2D"; 443 case GL_CULL_FACE: 444 return "GL_CULL_FACE"; 445 case GL_ALPHA_TEST: 446 return "GL_ALPHA_TEST"; 447 case GL_BLEND: 448 return "GL_BLEND"; 449 case GL_COLOR_LOGIC_OP: 450 return "GL_COLOR_LOGIC_OP"; 451 case GL_DITHER: 452 return "GL_DITHER"; 453 case GL_STENCIL_TEST: 454 return "GL_STENCIL_TEST"; 455 case GL_DEPTH_TEST: 456 return "GL_DEPTH_TEST"; 457 case GL_LIGHT0: 458 return "GL_LIGHT0"; 459 case GL_LIGHT1: 460 return "GL_LIGHT1"; 461 case GL_LIGHT2: 462 return "GL_LIGHT2"; 463 case GL_LIGHT3: 464 return "GL_LIGHT3"; 465 case GL_LIGHT4: 466 return "GL_LIGHT4"; 467 case GL_LIGHT5: 468 return "GL_LIGHT5"; 469 case GL_LIGHT6: 470 return "GL_LIGHT6"; 471 case GL_LIGHT7: 472 return "GL_LIGHT7"; 473 case GL_POINT_SMOOTH: 474 return "GL_POINT_SMOOTH"; 475 case GL_LINE_SMOOTH: 476 return "GL_LINE_SMOOTH"; 477 case GL_COLOR_MATERIAL: 478 return "GL_COLOR_MATERIAL"; 479 case GL_NORMALIZE: 480 return "GL_NORMALIZE"; 481 case GL_RESCALE_NORMAL: 482 return "GL_RESCALE_NORMAL"; 483 case GL_VERTEX_ARRAY: 484 return "GL_VERTEX_ARRAY"; 485 case GL_NORMAL_ARRAY: 486 return "GL_NORMAL_ARRAY"; 487 case GL_COLOR_ARRAY: 488 return "GL_COLOR_ARRAY"; 489 case GL_TEXTURE_COORD_ARRAY: 490 return "GL_TEXTURE_COORD_ARRAY"; 491 case GL_MULTISAMPLE: 492 return "GL_MULTISAMPLE"; 493 case GL_SAMPLE_ALPHA_TO_COVERAGE: 494 return "GL_SAMPLE_ALPHA_TO_COVERAGE"; 495 case GL_SAMPLE_ALPHA_TO_ONE: 496 return "GL_SAMPLE_ALPHA_TO_ONE"; 497 case GL_SAMPLE_COVERAGE: 498 return "GL_SAMPLE_COVERAGE"; 499 case GL_SCISSOR_TEST: 500 return "GL_SCISSOR_TEST"; 501 default: 502 return getHex(cap); 503 } 504 } 505 506 private String getTexturePName(int pname) { 507 switch (pname) { 508 case GL_TEXTURE_MAG_FILTER: 509 return "GL_TEXTURE_MAG_FILTER"; 510 case GL_TEXTURE_MIN_FILTER: 511 return "GL_TEXTURE_MIN_FILTER"; 512 case GL_TEXTURE_WRAP_S: 513 return "GL_TEXTURE_WRAP_S"; 514 case GL_TEXTURE_WRAP_T: 515 return "GL_TEXTURE_WRAP_T"; 516 case GL_GENERATE_MIPMAP: 517 return "GL_GENERATE_MIPMAP"; 518 case GL_TEXTURE_CROP_RECT_OES: 519 return "GL_TEXTURE_CROP_RECT_OES"; 520 default: 521 return getHex(pname); 522 } 523 } 524 525 private String getTextureParamName(float param) { 526 int iparam = (int) param; 527 if (param == (float) iparam) { 528 switch (iparam) { 529 case GL_CLAMP_TO_EDGE: 530 return "GL_CLAMP_TO_EDGE"; 531 case GL_REPEAT: 532 return "GL_REPEAT"; 533 case GL_NEAREST: 534 return "GL_NEAREST"; 535 case GL_LINEAR: 536 return "GL_LINEAR"; 537 case GL_NEAREST_MIPMAP_NEAREST: 538 return "GL_NEAREST_MIPMAP_NEAREST"; 539 case GL_LINEAR_MIPMAP_NEAREST: 540 return "GL_LINEAR_MIPMAP_NEAREST"; 541 case GL_NEAREST_MIPMAP_LINEAR: 542 return "GL_NEAREST_MIPMAP_LINEAR"; 543 case GL_LINEAR_MIPMAP_LINEAR: 544 return "GL_LINEAR_MIPMAP_LINEAR"; 545 default: 546 return getHex(iparam); 547 } 548 } 549 return Float.toString(param); 550 } 551 552 private String getFogPName(int pname) { 553 switch (pname) { 554 case GL_FOG_DENSITY: 555 return "GL_FOG_DENSITY"; 556 case GL_FOG_START: 557 return "GL_FOG_START"; 558 case GL_FOG_END: 559 return "GL_FOG_END"; 560 case GL_FOG_MODE: 561 return "GL_FOG_MODE"; 562 case GL_FOG_COLOR: 563 return "GL_FOG_COLOR"; 564 default: 565 return getHex(pname); 566 } 567 } 568 569 private int getFogParamCount(int pname) { 570 switch (pname) { 571 case GL_FOG_DENSITY: 572 return 1; 573 case GL_FOG_START: 574 return 1; 575 case GL_FOG_END: 576 return 1; 577 case GL_FOG_MODE: 578 return 1; 579 case GL_FOG_COLOR: 580 return 4; 581 default: 582 return 0; 583 } 584 } 585 586 private String getBeginMode(int mode) { 587 switch (mode) { 588 case GL_POINTS: 589 return "GL_POINTS"; 590 case GL_LINES: 591 return "GL_LINES"; 592 case GL_LINE_LOOP: 593 return "GL_LINE_LOOP"; 594 case GL_LINE_STRIP: 595 return "GL_LINE_STRIP"; 596 case GL_TRIANGLES: 597 return "GL_TRIANGLES"; 598 case GL_TRIANGLE_STRIP: 599 return "GL_TRIANGLE_STRIP"; 600 case GL_TRIANGLE_FAN: 601 return "GL_TRIANGLE_FAN"; 602 default: 603 return getHex(mode); 604 } 605 } 606 607 private String getIndexType(int type) { 608 switch (type) { 609 case GL_UNSIGNED_SHORT: 610 return "GL_UNSIGNED_SHORT"; 611 case GL_UNSIGNED_BYTE: 612 return "GL_UNSIGNED_BYTE"; 613 default: 614 return getHex(type); 615 } 616 } 617 618 private String getIntegerStateName(int pname) { 619 switch (pname) { 620 case GL_ALPHA_BITS: 621 return "GL_ALPHA_BITS"; 622 case GL_ALIASED_LINE_WIDTH_RANGE: 623 return "GL_ALIASED_LINE_WIDTH_RANGE"; 624 case GL_ALIASED_POINT_SIZE_RANGE: 625 return "GL_ALIASED_POINT_SIZE_RANGE"; 626 case GL_BLUE_BITS: 627 return "GL_BLUE_BITS"; 628 case GL_COMPRESSED_TEXTURE_FORMATS: 629 return "GL_COMPRESSED_TEXTURE_FORMATS"; 630 case GL_DEPTH_BITS: 631 return "GL_DEPTH_BITS"; 632 case GL_GREEN_BITS: 633 return "GL_GREEN_BITS"; 634 case GL_MAX_ELEMENTS_INDICES: 635 return "GL_MAX_ELEMENTS_INDICES"; 636 case GL_MAX_ELEMENTS_VERTICES: 637 return "GL_MAX_ELEMENTS_VERTICES"; 638 case GL_MAX_LIGHTS: 639 return "GL_MAX_LIGHTS"; 640 case GL_MAX_TEXTURE_SIZE: 641 return "GL_MAX_TEXTURE_SIZE"; 642 case GL_MAX_VIEWPORT_DIMS: 643 return "GL_MAX_VIEWPORT_DIMS"; 644 case GL_MAX_MODELVIEW_STACK_DEPTH: 645 return "GL_MAX_MODELVIEW_STACK_DEPTH"; 646 case GL_MAX_PROJECTION_STACK_DEPTH: 647 return "GL_MAX_PROJECTION_STACK_DEPTH"; 648 case GL_MAX_TEXTURE_STACK_DEPTH: 649 return "GL_MAX_TEXTURE_STACK_DEPTH"; 650 case GL_MAX_TEXTURE_UNITS: 651 return "GL_MAX_TEXTURE_UNITS"; 652 case GL_NUM_COMPRESSED_TEXTURE_FORMATS: 653 return "GL_NUM_COMPRESSED_TEXTURE_FORMATS"; 654 case GL_RED_BITS: 655 return "GL_RED_BITS"; 656 case GL_SMOOTH_LINE_WIDTH_RANGE: 657 return "GL_SMOOTH_LINE_WIDTH_RANGE"; 658 case GL_SMOOTH_POINT_SIZE_RANGE: 659 return "GL_SMOOTH_POINT_SIZE_RANGE"; 660 case GL_STENCIL_BITS: 661 return "GL_STENCIL_BITS"; 662 case GL_SUBPIXEL_BITS: 663 return "GL_SUBPIXEL_BITS"; 664 665 case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES: 666 return "GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES"; 667 case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES: 668 return "GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES"; 669 case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES: 670 return "GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES"; 671 672 default: 673 return getHex(pname); 674 } 675 } 676 677 private int getIntegerStateSize(int pname) { 678 switch (pname) { 679 case GL_ALPHA_BITS: 680 return 1; 681 case GL_ALIASED_LINE_WIDTH_RANGE: 682 return 2; 683 case GL_ALIASED_POINT_SIZE_RANGE: 684 return 2; 685 case GL_BLUE_BITS: 686 return 1; 687 case GL_COMPRESSED_TEXTURE_FORMATS: 688 // Have to ask the implementation for the size 689 { 690 int[] buffer = new int[1]; 691 mgl.glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, buffer, 0); 692 return buffer[0]; 693 } 694 case GL_DEPTH_BITS: 695 return 1; 696 case GL_GREEN_BITS: 697 return 1; 698 case GL_MAX_ELEMENTS_INDICES: 699 return 1; 700 case GL_MAX_ELEMENTS_VERTICES: 701 return 1; 702 case GL_MAX_LIGHTS: 703 return 1; 704 case GL_MAX_TEXTURE_SIZE: 705 return 1; 706 case GL_MAX_VIEWPORT_DIMS: 707 return 2; 708 case GL_MAX_MODELVIEW_STACK_DEPTH: 709 return 1; 710 case GL_MAX_PROJECTION_STACK_DEPTH: 711 return 1; 712 case GL_MAX_TEXTURE_STACK_DEPTH: 713 return 1; 714 case GL_MAX_TEXTURE_UNITS: 715 return 1; 716 case GL_NUM_COMPRESSED_TEXTURE_FORMATS: 717 return 1; 718 case GL_RED_BITS: 719 return 1; 720 case GL_SMOOTH_LINE_WIDTH_RANGE: 721 return 2; 722 case GL_SMOOTH_POINT_SIZE_RANGE: 723 return 2; 724 case GL_STENCIL_BITS: 725 return 1; 726 case GL_SUBPIXEL_BITS: 727 return 1; 728 729 case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES: 730 case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES: 731 case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES: 732 return 16; 733 734 default: 735 return 0; 736 } 737 } 738 739 private int getIntegerStateFormat(int pname) { 740 switch (pname) { 741 case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES: 742 case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES: 743 case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES: 744 return FORMAT_FLOAT; 745 746 default: 747 return FORMAT_INT; 748 } 749 } 750 751 private String getHintTarget(int target) { 752 switch (target) { 753 case GL_FOG_HINT: 754 return "GL_FOG_HINT"; 755 case GL_LINE_SMOOTH_HINT: 756 return "GL_LINE_SMOOTH_HINT"; 757 case GL_PERSPECTIVE_CORRECTION_HINT: 758 return "GL_PERSPECTIVE_CORRECTION_HINT"; 759 case GL_POINT_SMOOTH_HINT: 760 return "GL_POINT_SMOOTH_HINT"; 761 case GL_POLYGON_SMOOTH_HINT: 762 return "GL_POLYGON_SMOOTH_HINT"; 763 case GL_GENERATE_MIPMAP_HINT: 764 return "GL_GENERATE_MIPMAP_HINT"; 765 default: 766 return getHex(target); 767 } 768 } 769 770 private String getHintMode(int mode) { 771 switch (mode) { 772 case GL_FASTEST: 773 return "GL_FASTEST"; 774 case GL_NICEST: 775 return "GL_NICEST"; 776 case GL_DONT_CARE: 777 return "GL_DONT_CARE"; 778 default: 779 return getHex(mode); 780 } 781 } 782 783 private String getFaceName(int face) { 784 switch (face) { 785 case GL_FRONT_AND_BACK: 786 return "GL_FRONT_AND_BACK"; 787 default: 788 return getHex(face); 789 } 790 } 791 792 private String getMaterialPName(int pname) { 793 switch (pname) { 794 case GL_AMBIENT: 795 return "GL_AMBIENT"; 796 case GL_DIFFUSE: 797 return "GL_DIFFUSE"; 798 case GL_SPECULAR: 799 return "GL_SPECULAR"; 800 case GL_EMISSION: 801 return "GL_EMISSION"; 802 case GL_SHININESS: 803 return "GL_SHININESS"; 804 case GL_AMBIENT_AND_DIFFUSE: 805 return "GL_AMBIENT_AND_DIFFUSE"; 806 default: 807 return getHex(pname); 808 } 809 } 810 811 private int getMaterialParamCount(int pname) { 812 switch (pname) { 813 case GL_AMBIENT: 814 return 4; 815 case GL_DIFFUSE: 816 return 4; 817 case GL_SPECULAR: 818 return 4; 819 case GL_EMISSION: 820 return 4; 821 case GL_SHININESS: 822 return 1; 823 case GL_AMBIENT_AND_DIFFUSE: 824 return 4; 825 default: 826 return 0; 827 } 828 } 829 830 private String getLightName(int light) { 831 if (light >= GL_LIGHT0 && light <= GL_LIGHT7) { 832 return "GL_LIGHT" + Integer.toString(light); 833 } 834 return getHex(light); 835 } 836 837 private String getLightPName(int pname) { 838 switch (pname) { 839 case GL_AMBIENT: 840 return "GL_AMBIENT"; 841 case GL_DIFFUSE: 842 return "GL_DIFFUSE"; 843 case GL_SPECULAR: 844 return "GL_SPECULAR"; 845 case GL_POSITION: 846 return "GL_POSITION"; 847 case GL_SPOT_DIRECTION: 848 return "GL_SPOT_DIRECTION"; 849 case GL_SPOT_EXPONENT: 850 return "GL_SPOT_EXPONENT"; 851 case GL_SPOT_CUTOFF: 852 return "GL_SPOT_CUTOFF"; 853 case GL_CONSTANT_ATTENUATION: 854 return "GL_CONSTANT_ATTENUATION"; 855 case GL_LINEAR_ATTENUATION: 856 return "GL_LINEAR_ATTENUATION"; 857 case GL_QUADRATIC_ATTENUATION: 858 return "GL_QUADRATIC_ATTENUATION"; 859 default: 860 return getHex(pname); 861 } 862 } 863 864 private int getLightParamCount(int pname) { 865 switch (pname) { 866 case GL_AMBIENT: 867 return 4; 868 case GL_DIFFUSE: 869 return 4; 870 case GL_SPECULAR: 871 return 4; 872 case GL_POSITION: 873 return 4; 874 case GL_SPOT_DIRECTION: 875 return 3; 876 case GL_SPOT_EXPONENT: 877 return 1; 878 case GL_SPOT_CUTOFF: 879 return 1; 880 case GL_CONSTANT_ATTENUATION: 881 return 1; 882 case GL_LINEAR_ATTENUATION: 883 return 1; 884 case GL_QUADRATIC_ATTENUATION: 885 return 1; 886 default: 887 return 0; 888 } 889 } 890 891 private String getLightModelPName(int pname) { 892 switch (pname) { 893 case GL_LIGHT_MODEL_AMBIENT: 894 return "GL_LIGHT_MODEL_AMBIENT"; 895 case GL_LIGHT_MODEL_TWO_SIDE: 896 return "GL_LIGHT_MODEL_TWO_SIDE"; 897 default: 898 return getHex(pname); 899 } 900 } 901 902 private int getLightModelParamCount(int pname) { 903 switch (pname) { 904 case GL_LIGHT_MODEL_AMBIENT: 905 return 4; 906 case GL_LIGHT_MODEL_TWO_SIDE: 907 return 1; 908 default: 909 return 0; 910 } 911 } 912 913 private String getPointerTypeName(int type) { 914 switch (type) { 915 case GL_BYTE: 916 return "GL_BYTE"; 917 case GL_UNSIGNED_BYTE: 918 return "GL_UNSIGNED_BYTE"; 919 case GL_SHORT: 920 return "GL_SHORT"; 921 case GL_FIXED: 922 return "GL_FIXED"; 923 case GL_FLOAT: 924 return "GL_FLOAT"; 925 default: 926 return getHex(type); 927 } 928 } 929 930 private ByteBuffer toByteBuffer(int byteCount, Buffer input) { 931 ByteBuffer result = null; 932 boolean convertWholeBuffer = (byteCount < 0); 933 if (input instanceof ByteBuffer) { 934 ByteBuffer input2 = (ByteBuffer) input; 935 int position = input2.position(); 936 if (convertWholeBuffer) { 937 byteCount = input2.limit() - position; 938 } 939 result = ByteBuffer.allocate(byteCount).order(input2.order()); 940 for (int i = 0; i < byteCount; i++) { 941 result.put(input2.get()); 942 } 943 input2.position(position); 944 } else if (input instanceof CharBuffer) { 945 CharBuffer input2 = (CharBuffer) input; 946 int position = input2.position(); 947 if (convertWholeBuffer) { 948 byteCount = (input2.limit() - position) * 2; 949 } 950 result = ByteBuffer.allocate(byteCount).order(input2.order()); 951 CharBuffer result2 = result.asCharBuffer(); 952 for (int i = 0; i < byteCount / 2; i++) { 953 result2.put(input2.get()); 954 } 955 input2.position(position); 956 } else if (input instanceof ShortBuffer) { 957 ShortBuffer input2 = (ShortBuffer) input; 958 int position = input2.position(); 959 if (convertWholeBuffer) { 960 byteCount = (input2.limit() - position)* 2; 961 } 962 result = ByteBuffer.allocate(byteCount).order(input2.order()); 963 ShortBuffer result2 = result.asShortBuffer(); 964 for (int i = 0; i < byteCount / 2; i++) { 965 result2.put(input2.get()); 966 } 967 input2.position(position); 968 } else if (input instanceof IntBuffer) { 969 IntBuffer input2 = (IntBuffer) input; 970 int position = input2.position(); 971 if (convertWholeBuffer) { 972 byteCount = (input2.limit() - position) * 4; 973 } 974 result = ByteBuffer.allocate(byteCount).order(input2.order()); 975 IntBuffer result2 = result.asIntBuffer(); 976 for (int i = 0; i < byteCount / 4; i++) { 977 result2.put(input2.get()); 978 } 979 input2.position(position); 980 } else if (input instanceof FloatBuffer) { 981 FloatBuffer input2 = (FloatBuffer) input; 982 int position = input2.position(); 983 if (convertWholeBuffer) { 984 byteCount = (input2.limit() - position) * 4; 985 } 986 result = ByteBuffer.allocate(byteCount).order(input2.order()); 987 FloatBuffer result2 = result.asFloatBuffer(); 988 for (int i = 0; i < byteCount / 4; i++) { 989 result2.put(input2.get()); 990 } 991 input2.position(position); 992 } else if (input instanceof DoubleBuffer) { 993 DoubleBuffer input2 = (DoubleBuffer) input; 994 int position = input2.position(); 995 if (convertWholeBuffer) { 996 byteCount = (input2.limit() - position) * 8; 997 } 998 result = ByteBuffer.allocate(byteCount).order(input2.order()); 999 DoubleBuffer result2 = result.asDoubleBuffer(); 1000 for (int i = 0; i < byteCount / 8; i++) { 1001 result2.put(input2.get()); 1002 } 1003 input2.position(position); 1004 } else if (input instanceof LongBuffer) { 1005 LongBuffer input2 = (LongBuffer) input; 1006 int position = input2.position(); 1007 if (convertWholeBuffer) { 1008 byteCount = (input2.limit() - position) * 8; 1009 } 1010 result = ByteBuffer.allocate(byteCount).order(input2.order()); 1011 LongBuffer result2 = result.asLongBuffer(); 1012 for (int i = 0; i < byteCount / 8; i++) { 1013 result2.put(input2.get()); 1014 } 1015 input2.position(position); 1016 } else { 1017 throw new RuntimeException("Unimplemented Buffer subclass."); 1018 } 1019 result.rewind(); 1020 // The OpenGL API will interpret the result in hardware byte order, 1021 // so we better do that as well: 1022 result.order(ByteOrder.nativeOrder()); 1023 return result; 1024 } 1025 1026 private char[] toCharIndices(int count, int type, Buffer indices) { 1027 char[] result = new char[count]; 1028 switch (type) { 1029 case GL_UNSIGNED_BYTE: { 1030 ByteBuffer byteBuffer = toByteBuffer(count, indices); 1031 byte[] array = byteBuffer.array(); 1032 int offset = byteBuffer.arrayOffset(); 1033 for (int i = 0; i < count; i++) { 1034 result[i] = (char) (0xff & array[offset + i]); 1035 } 1036 } 1037 break; 1038 case GL_UNSIGNED_SHORT: { 1039 CharBuffer charBuffer; 1040 if (indices instanceof CharBuffer) { 1041 charBuffer = (CharBuffer) indices; 1042 } else { 1043 ByteBuffer byteBuffer = toByteBuffer(count * 2, indices); 1044 charBuffer = byteBuffer.asCharBuffer(); 1045 } 1046 int oldPosition = charBuffer.position(); 1047 charBuffer.position(0); 1048 charBuffer.get(result); 1049 charBuffer.position(oldPosition); 1050 } 1051 break; 1052 default: 1053 // Don't throw an exception, because we don't want logging to 1054 // change the behavior. 1055 break; 1056 } 1057 return result; 1058 } 1059 1060 private void doArrayElement(StringBuilder builder, boolean enabled, 1061 String name, PointerInfo pointer, int index) { 1062 if (!enabled) { 1063 return; 1064 } 1065 builder.append(" "); 1066 builder.append(name + ":{"); 1067 if (pointer == null || pointer.mTempByteBuffer == null ) { 1068 builder.append("undefined }"); 1069 return; 1070 } 1071 if (pointer.mStride < 0) { 1072 builder.append("invalid stride"); 1073 return; 1074 } 1075 1076 int stride = pointer.getStride(); 1077 ByteBuffer byteBuffer = pointer.mTempByteBuffer; 1078 int size = pointer.mSize; 1079 int type = pointer.mType; 1080 int sizeofType = pointer.sizeof(type); 1081 int byteOffset = stride * index; 1082 for (int i = 0; i < size; i++) { 1083 if (i > 0) { 1084 builder.append(", "); 1085 } 1086 switch (type) { 1087 case GL_BYTE: { 1088 byte d = byteBuffer.get(byteOffset); 1089 builder.append(Integer.toString(d)); 1090 } 1091 break; 1092 case GL_UNSIGNED_BYTE: { 1093 byte d = byteBuffer.get(byteOffset); 1094 builder.append(Integer.toString(0xff & d)); 1095 } 1096 break; 1097 case GL_SHORT: { 1098 ShortBuffer shortBuffer = byteBuffer.asShortBuffer(); 1099 short d = shortBuffer.get(byteOffset / 2); 1100 builder.append(Integer.toString(d)); 1101 } 1102 break; 1103 case GL_FIXED: { 1104 IntBuffer intBuffer = byteBuffer.asIntBuffer(); 1105 int d = intBuffer.get(byteOffset / 4); 1106 builder.append(Integer.toString(d)); 1107 } 1108 break; 1109 case GL_FLOAT: { 1110 FloatBuffer intBuffer = byteBuffer.asFloatBuffer(); 1111 float d = intBuffer.get(byteOffset / 4); 1112 builder.append(Float.toString(d)); 1113 } 1114 break; 1115 default: 1116 builder.append("?"); 1117 break; 1118 } 1119 byteOffset += sizeofType; 1120 } 1121 builder.append("}"); 1122 } 1123 1124 private void doElement(StringBuilder builder, int ordinal, int vertexIndex) { 1125 builder.append(" [" + ordinal + " : " + vertexIndex + "] ="); 1126 doArrayElement(builder, mVertexArrayEnabled, "v", mVertexPointer, 1127 vertexIndex); 1128 doArrayElement(builder, mNormalArrayEnabled, "n", mNormalPointer, 1129 vertexIndex); 1130 doArrayElement(builder, mColorArrayEnabled, "c", mColorPointer, 1131 vertexIndex); 1132 doArrayElement(builder, mTextureCoordArrayEnabled, "t", 1133 mTexCoordPointer, vertexIndex); 1134 builder.append("\n"); 1135 // Vertex 1136 // Normal 1137 // Color 1138 // TexCoord 1139 } 1140 1141 private void bindArrays() { 1142 if (mColorArrayEnabled) 1143 mColorPointer.bindByteBuffer(); 1144 if (mNormalArrayEnabled) 1145 mNormalPointer.bindByteBuffer(); 1146 if (mTextureCoordArrayEnabled) 1147 mTexCoordPointer.bindByteBuffer(); 1148 if (mVertexArrayEnabled) 1149 mVertexPointer.bindByteBuffer(); 1150 } 1151 1152 private void unbindArrays() { 1153 if (mColorArrayEnabled) 1154 mColorPointer.unbindByteBuffer(); 1155 if (mNormalArrayEnabled) 1156 mNormalPointer.unbindByteBuffer(); 1157 if (mTextureCoordArrayEnabled) 1158 mTexCoordPointer.unbindByteBuffer(); 1159 if (mVertexArrayEnabled) 1160 mVertexPointer.unbindByteBuffer(); 1161 } 1162 1163 private void startLogIndices() { 1164 mStringBuilder = new StringBuilder(); 1165 mStringBuilder.append("\n"); 1166 bindArrays(); 1167 } 1168 1169 private void endLogIndices() { 1170 log(mStringBuilder.toString()); 1171 unbindArrays(); 1172 } 1173 1174 // --------------------------------------------------------------------- 1175 // GL10 methods: 1176 1177 public void glActiveTexture(int texture) { 1178 begin("glActiveTexture"); 1179 arg("texture", texture); 1180 end(); 1181 mgl.glActiveTexture(texture); 1182 checkError(); 1183 } 1184 1185 public void glAlphaFunc(int func, float ref) { 1186 begin("glAlphaFunc"); 1187 arg("func", func); 1188 arg("ref", ref); 1189 end(); 1190 mgl.glAlphaFunc(func, ref); 1191 checkError(); 1192 } 1193 1194 public void glAlphaFuncx(int func, int ref) { 1195 begin("glAlphaFuncx"); 1196 arg("func", func); 1197 arg("ref", ref); 1198 end(); 1199 mgl.glAlphaFuncx(func, ref); 1200 checkError(); 1201 } 1202 1203 public void glBindTexture(int target, int texture) { 1204 begin("glBindTexture"); 1205 arg("target", getTextureTarget(target)); 1206 arg("texture", texture); 1207 end(); 1208 mgl.glBindTexture(target, texture); 1209 checkError(); 1210 } 1211 1212 public void glBlendFunc(int sfactor, int dfactor) { 1213 begin("glBlendFunc"); 1214 arg("sfactor", getFactor(sfactor)); 1215 arg("dfactor", getFactor(dfactor)); 1216 end(); 1217 1218 mgl.glBlendFunc(sfactor, dfactor); 1219 checkError(); 1220 } 1221 1222 public void glClear(int mask) { 1223 begin("glClear"); 1224 arg("mask", getClearBufferMask(mask)); 1225 end(); 1226 1227 mgl.glClear(mask); 1228 checkError(); 1229 } 1230 1231 public void glClearColor(float red, float green, float blue, float alpha) { 1232 begin("glClearColor"); 1233 arg("red", red); 1234 arg("green", green); 1235 arg("blue", blue); 1236 arg("alpha", alpha); 1237 end(); 1238 1239 mgl.glClearColor(red, green, blue, alpha); 1240 checkError(); 1241 } 1242 1243 public void glClearColorx(int red, int green, int blue, int alpha) { 1244 begin("glClearColor"); 1245 arg("red", red); 1246 arg("green", green); 1247 arg("blue", blue); 1248 arg("alpha", alpha); 1249 end(); 1250 1251 mgl.glClearColorx(red, green, blue, alpha); 1252 checkError(); 1253 } 1254 1255 public void glClearDepthf(float depth) { 1256 begin("glClearDepthf"); 1257 arg("depth", depth); 1258 end(); 1259 1260 mgl.glClearDepthf(depth); 1261 checkError(); 1262 } 1263 1264 public void glClearDepthx(int depth) { 1265 begin("glClearDepthx"); 1266 arg("depth", depth); 1267 end(); 1268 1269 mgl.glClearDepthx(depth); 1270 checkError(); 1271 } 1272 1273 public void glClearStencil(int s) { 1274 begin("glClearStencil"); 1275 arg("s", s); 1276 end(); 1277 1278 mgl.glClearStencil(s); 1279 checkError(); 1280 } 1281 1282 public void glClientActiveTexture(int texture) { 1283 begin("glClientActiveTexture"); 1284 arg("texture", texture); 1285 end(); 1286 1287 mgl.glClientActiveTexture(texture); 1288 checkError(); 1289 } 1290 1291 public void glColor4f(float red, float green, float blue, float alpha) { 1292 begin("glColor4f"); 1293 arg("red", red); 1294 arg("green", green); 1295 arg("blue", blue); 1296 arg("alpha", alpha); 1297 end(); 1298 1299 mgl.glColor4f(red, green, blue, alpha); 1300 checkError(); 1301 } 1302 1303 public void glColor4x(int red, int green, int blue, int alpha) { 1304 begin("glColor4x"); 1305 arg("red", red); 1306 arg("green", green); 1307 arg("blue", blue); 1308 arg("alpha", alpha); 1309 end(); 1310 1311 mgl.glColor4x(red, green, blue, alpha); 1312 checkError(); 1313 } 1314 1315 public void glColorMask(boolean red, boolean green, boolean blue, 1316 boolean alpha) { 1317 begin("glColorMask"); 1318 arg("red", red); 1319 arg("green", green); 1320 arg("blue", blue); 1321 arg("alpha", alpha); 1322 end(); 1323 1324 mgl.glColorMask(red, green, blue, alpha); 1325 checkError(); 1326 } 1327 1328 public void glColorPointer(int size, int type, int stride, Buffer pointer) { 1329 begin("glColorPointer"); 1330 argPointer(size, type, stride, pointer); 1331 end(); 1332 mColorPointer = new PointerInfo(size, type, stride, pointer); 1333 1334 mgl.glColorPointer(size, type, stride, pointer); 1335 checkError(); 1336 } 1337 1338 public void glCompressedTexImage2D(int target, int level, 1339 int internalformat, int width, int height, int border, 1340 int imageSize, Buffer data) { 1341 begin("glCompressedTexImage2D"); 1342 arg("target", getTextureTarget(target)); 1343 arg("level", level); 1344 arg("internalformat", internalformat); 1345 arg("width", width); 1346 arg("height", height); 1347 arg("border", border); 1348 arg("imageSize", imageSize); 1349 arg("data", data.toString()); 1350 end(); 1351 1352 mgl.glCompressedTexImage2D(target, level, internalformat, width, 1353 height, border, imageSize, data); 1354 checkError(); 1355 } 1356 1357 public void glCompressedTexSubImage2D(int target, int level, int xoffset, 1358 int yoffset, int width, int height, int format, int imageSize, 1359 Buffer data) { 1360 begin("glCompressedTexSubImage2D"); 1361 arg("target", getTextureTarget(target)); 1362 arg("level", level); 1363 arg("xoffset", xoffset); 1364 arg("yoffset", yoffset); 1365 arg("width", width); 1366 arg("height", height); 1367 arg("format", format); 1368 arg("imageSize", imageSize); 1369 arg("data", data.toString()); 1370 end(); 1371 1372 mgl.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, 1373 height, format, imageSize, data); 1374 checkError(); 1375 } 1376 1377 public void glCopyTexImage2D(int target, int level, int internalformat, 1378 int x, int y, int width, int height, int border) { 1379 begin("glCopyTexImage2D"); 1380 arg("target", getTextureTarget(target)); 1381 arg("level", level); 1382 arg("internalformat", internalformat); 1383 arg("x", x); 1384 arg("y", y); 1385 arg("width", width); 1386 arg("height", height); 1387 arg("border", border); 1388 end(); 1389 1390 mgl.glCopyTexImage2D(target, level, internalformat, x, y, width, 1391 height, border); 1392 checkError(); 1393 } 1394 1395 public void glCopyTexSubImage2D(int target, int level, int xoffset, 1396 int yoffset, int x, int y, int width, int height) { 1397 begin("glCopyTexSubImage2D"); 1398 arg("target", getTextureTarget(target)); 1399 arg("level", level); 1400 arg("xoffset", xoffset); 1401 arg("yoffset", yoffset); 1402 arg("x", x); 1403 arg("y", y); 1404 arg("width", width); 1405 arg("height", height); 1406 end(); 1407 1408 mgl.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, 1409 height); 1410 checkError(); 1411 } 1412 1413 public void glCullFace(int mode) { 1414 begin("glCullFace"); 1415 arg("mode", mode); 1416 end(); 1417 1418 mgl.glCullFace(mode); 1419 checkError(); 1420 } 1421 1422 public void glDeleteTextures(int n, int[] textures, int offset) { 1423 begin("glDeleteTextures"); 1424 arg("n", n); 1425 arg("textures", n, textures, offset); 1426 arg("offset", offset); 1427 end(); 1428 1429 mgl.glDeleteTextures(n, textures, offset); 1430 checkError(); 1431 } 1432 1433 public void glDeleteTextures(int n, IntBuffer textures) { 1434 begin("glDeleteTextures"); 1435 arg("n", n); 1436 arg("textures", n, textures); 1437 end(); 1438 1439 mgl.glDeleteTextures(n, textures); 1440 checkError(); 1441 } 1442 1443 public void glDepthFunc(int func) { 1444 begin("glDepthFunc"); 1445 arg("func", func); 1446 end(); 1447 1448 mgl.glDepthFunc(func); 1449 checkError(); 1450 } 1451 1452 public void glDepthMask(boolean flag) { 1453 begin("glDepthMask"); 1454 arg("flag", flag); 1455 end(); 1456 1457 mgl.glDepthMask(flag); 1458 checkError(); 1459 } 1460 1461 public void glDepthRangef(float near, float far) { 1462 begin("glDepthRangef"); 1463 arg("near", near); 1464 arg("far", far); 1465 end(); 1466 1467 mgl.glDepthRangef(near, far); 1468 checkError(); 1469 } 1470 1471 public void glDepthRangex(int near, int far) { 1472 begin("glDepthRangex"); 1473 arg("near", near); 1474 arg("far", far); 1475 end(); 1476 1477 mgl.glDepthRangex(near, far); 1478 checkError(); 1479 } 1480 1481 public void glDisable(int cap) { 1482 begin("glDisable"); 1483 arg("cap", getCap(cap)); 1484 end(); 1485 1486 mgl.glDisable(cap); 1487 checkError(); 1488 } 1489 1490 public void glDisableClientState(int array) { 1491 begin("glDisableClientState"); 1492 arg("array", getClientState(array)); 1493 end(); 1494 1495 switch (array) { 1496 case GL_COLOR_ARRAY: 1497 mColorArrayEnabled = false; 1498 break; 1499 case GL_NORMAL_ARRAY: 1500 mNormalArrayEnabled = false; 1501 break; 1502 case GL_TEXTURE_COORD_ARRAY: 1503 mTextureCoordArrayEnabled = false; 1504 break; 1505 case GL_VERTEX_ARRAY: 1506 mVertexArrayEnabled = false; 1507 break; 1508 } 1509 mgl.glDisableClientState(array); 1510 checkError(); 1511 } 1512 1513 public void glDrawArrays(int mode, int first, int count) { 1514 begin("glDrawArrays"); 1515 arg("mode", mode); 1516 arg("first", first); 1517 arg("count", count); 1518 startLogIndices(); 1519 for (int i = 0; i < count; i++) { 1520 doElement(mStringBuilder, i, first + i); 1521 } 1522 endLogIndices(); 1523 end(); 1524 1525 mgl.glDrawArrays(mode, first, count); 1526 checkError(); 1527 } 1528 1529 public void glDrawElements(int mode, int count, int type, Buffer indices) { 1530 begin("glDrawElements"); 1531 arg("mode", getBeginMode(mode)); 1532 arg("count", count); 1533 arg("type", getIndexType(type)); 1534 char[] indexArray = toCharIndices(count, type, indices); 1535 int indexArrayLength = indexArray.length; 1536 startLogIndices(); 1537 for (int i = 0; i < indexArrayLength; i++) { 1538 doElement(mStringBuilder, i, indexArray[i]); 1539 } 1540 endLogIndices(); 1541 end(); 1542 1543 mgl.glDrawElements(mode, count, type, indices); 1544 checkError(); 1545 } 1546 1547 public void glEnable(int cap) { 1548 begin("glEnable"); 1549 arg("cap", getCap(cap)); 1550 end(); 1551 1552 mgl.glEnable(cap); 1553 checkError(); 1554 } 1555 1556 public void glEnableClientState(int array) { 1557 begin("glEnableClientState"); 1558 arg("array", getClientState(array)); 1559 end(); 1560 1561 switch (array) { 1562 case GL_COLOR_ARRAY: 1563 mColorArrayEnabled = true; 1564 break; 1565 case GL_NORMAL_ARRAY: 1566 mNormalArrayEnabled = true; 1567 break; 1568 case GL_TEXTURE_COORD_ARRAY: 1569 mTextureCoordArrayEnabled = true; 1570 break; 1571 case GL_VERTEX_ARRAY: 1572 mVertexArrayEnabled = true; 1573 break; 1574 } 1575 mgl.glEnableClientState(array); 1576 checkError(); 1577 } 1578 1579 public void glFinish() { 1580 begin("glFinish"); 1581 end(); 1582 1583 mgl.glFinish(); 1584 checkError(); 1585 } 1586 1587 public void glFlush() { 1588 begin("glFlush"); 1589 end(); 1590 1591 mgl.glFlush(); 1592 checkError(); 1593 } 1594 1595 public void glFogf(int pname, float param) { 1596 begin("glFogf"); 1597 arg("pname", pname); 1598 arg("param", param); 1599 end(); 1600 1601 mgl.glFogf(pname, param); 1602 checkError(); 1603 } 1604 1605 public void glFogfv(int pname, float[] params, int offset) { 1606 begin("glFogfv"); 1607 arg("pname", getFogPName(pname)); 1608 arg("params", getFogParamCount(pname), params, offset); 1609 arg("offset", offset); 1610 end(); 1611 1612 mgl.glFogfv(pname, params, offset); 1613 checkError(); 1614 } 1615 1616 public void glFogfv(int pname, FloatBuffer params) { 1617 begin("glFogfv"); 1618 arg("pname", getFogPName(pname)); 1619 arg("params", getFogParamCount(pname), params); 1620 end(); 1621 1622 mgl.glFogfv(pname, params); 1623 checkError(); 1624 } 1625 1626 public void glFogx(int pname, int param) { 1627 begin("glFogx"); 1628 arg("pname", getFogPName(pname)); 1629 arg("param", param); 1630 end(); 1631 1632 mgl.glFogx(pname, param); 1633 checkError(); 1634 } 1635 1636 public void glFogxv(int pname, int[] params, int offset) { 1637 begin("glFogxv"); 1638 arg("pname", getFogPName(pname)); 1639 arg("params", getFogParamCount(pname), params, offset); 1640 arg("offset", offset); 1641 end(); 1642 1643 mgl.glFogxv(pname, params, offset); 1644 checkError(); 1645 } 1646 1647 public void glFogxv(int pname, IntBuffer params) { 1648 begin("glFogxv"); 1649 arg("pname", getFogPName(pname)); 1650 arg("params", getFogParamCount(pname), params); 1651 end(); 1652 1653 mgl.glFogxv(pname, params); 1654 checkError(); 1655 } 1656 1657 public void glFrontFace(int mode) { 1658 begin("glFrontFace"); 1659 arg("mode", mode); 1660 end(); 1661 1662 mgl.glFrontFace(mode); 1663 checkError(); 1664 } 1665 1666 public void glFrustumf(float left, float right, float bottom, float top, 1667 float near, float far) { 1668 begin("glFrustumf"); 1669 arg("left", left); 1670 arg("right", right); 1671 arg("bottom", bottom); 1672 arg("top", top); 1673 arg("near", near); 1674 arg("far", far); 1675 end(); 1676 1677 mgl.glFrustumf(left, right, bottom, top, near, far); 1678 checkError(); 1679 } 1680 1681 public void glFrustumx(int left, int right, int bottom, int top, int near, 1682 int far) { 1683 begin("glFrustumx"); 1684 arg("left", left); 1685 arg("right", right); 1686 arg("bottom", bottom); 1687 arg("top", top); 1688 arg("near", near); 1689 arg("far", far); 1690 end(); 1691 1692 mgl.glFrustumx(left, right, bottom, top, near, far); 1693 checkError(); 1694 } 1695 1696 public void glGenTextures(int n, int[] textures, int offset) { 1697 begin("glGenTextures"); 1698 arg("n", n); 1699 arg("textures", Arrays.toString(textures)); 1700 arg("offset", offset); 1701 1702 mgl.glGenTextures(n, textures, offset); 1703 1704 returns(toString(n, FORMAT_INT, textures, offset)); 1705 1706 checkError(); 1707 } 1708 1709 public void glGenTextures(int n, IntBuffer textures) { 1710 begin("glGenTextures"); 1711 arg("n", n); 1712 arg("textures", textures.toString()); 1713 1714 mgl.glGenTextures(n, textures); 1715 1716 returns(toString(n, FORMAT_INT, textures)); 1717 1718 checkError(); 1719 } 1720 1721 public int glGetError() { 1722 begin("glGetError"); 1723 1724 int result = mgl.glGetError(); 1725 1726 returns(result); 1727 1728 return result; 1729 } 1730 1731 public void glGetIntegerv(int pname, int[] params, int offset) { 1732 begin("glGetIntegerv"); 1733 arg("pname", getIntegerStateName(pname)); 1734 arg("params", Arrays.toString(params)); 1735 arg("offset", offset); 1736 1737 mgl.glGetIntegerv(pname, params, offset); 1738 1739 returns(toString(getIntegerStateSize(pname), 1740 getIntegerStateFormat(pname), params, offset)); 1741 1742 checkError(); 1743 } 1744 1745 public void glGetIntegerv(int pname, IntBuffer params) { 1746 begin("glGetIntegerv"); 1747 arg("pname", getIntegerStateName(pname)); 1748 arg("params", params.toString()); 1749 1750 mgl.glGetIntegerv(pname, params); 1751 1752 returns(toString(getIntegerStateSize(pname), 1753 getIntegerStateFormat(pname), params)); 1754 1755 checkError(); 1756 } 1757 1758 public String glGetString(int name) { 1759 begin("glGetString"); 1760 arg("name", name); 1761 1762 String result = mgl.glGetString(name); 1763 1764 returns(result); 1765 1766 checkError(); 1767 return result; 1768 } 1769 1770 public void glHint(int target, int mode) { 1771 begin("glHint"); 1772 arg("target", getHintTarget(target)); 1773 arg("mode", getHintMode(mode)); 1774 end(); 1775 1776 mgl.glHint(target, mode); 1777 checkError(); 1778 } 1779 1780 public void glLightModelf(int pname, float param) { 1781 begin("glLightModelf"); 1782 arg("pname", getLightModelPName(pname)); 1783 arg("param", param); 1784 end(); 1785 1786 mgl.glLightModelf(pname, param); 1787 checkError(); 1788 } 1789 1790 public void glLightModelfv(int pname, float[] params, int offset) { 1791 begin("glLightModelfv"); 1792 arg("pname", getLightModelPName(pname)); 1793 arg("params", getLightModelParamCount(pname), params, offset); 1794 arg("offset", offset); 1795 end(); 1796 1797 mgl.glLightModelfv(pname, params, offset); 1798 checkError(); 1799 } 1800 1801 public void glLightModelfv(int pname, FloatBuffer params) { 1802 begin("glLightModelfv"); 1803 arg("pname", getLightModelPName(pname)); 1804 arg("params", getLightModelParamCount(pname), params); 1805 end(); 1806 1807 mgl.glLightModelfv(pname, params); 1808 checkError(); 1809 } 1810 1811 public void glLightModelx(int pname, int param) { 1812 begin("glLightModelx"); 1813 arg("pname", getLightModelPName(pname)); 1814 arg("param", param); 1815 end(); 1816 1817 mgl.glLightModelx(pname, param); 1818 checkError(); 1819 } 1820 1821 public void glLightModelxv(int pname, int[] params, int offset) { 1822 begin("glLightModelxv"); 1823 arg("pname", getLightModelPName(pname)); 1824 arg("params", getLightModelParamCount(pname), params, offset); 1825 arg("offset", offset); 1826 end(); 1827 1828 mgl.glLightModelxv(pname, params, offset); 1829 checkError(); 1830 } 1831 1832 public void glLightModelxv(int pname, IntBuffer params) { 1833 begin("glLightModelfv"); 1834 arg("pname", getLightModelPName(pname)); 1835 arg("params", getLightModelParamCount(pname), params); 1836 end(); 1837 1838 mgl.glLightModelxv(pname, params); 1839 checkError(); 1840 } 1841 1842 public void glLightf(int light, int pname, float param) { 1843 begin("glLightf"); 1844 arg("light", getLightName(light)); 1845 arg("pname", getLightPName(pname)); 1846 arg("param", param); 1847 end(); 1848 1849 mgl.glLightf(light, pname, param); 1850 checkError(); 1851 } 1852 1853 public void glLightfv(int light, int pname, float[] params, int offset) { 1854 begin("glLightfv"); 1855 arg("light", getLightName(light)); 1856 arg("pname", getLightPName(pname)); 1857 arg("params", getLightParamCount(pname), params, offset); 1858 arg("offset", offset); 1859 end(); 1860 1861 mgl.glLightfv(light, pname, params, offset); 1862 checkError(); 1863 } 1864 1865 public void glLightfv(int light, int pname, FloatBuffer params) { 1866 begin("glLightfv"); 1867 arg("light", getLightName(light)); 1868 arg("pname", getLightPName(pname)); 1869 arg("params", getLightParamCount(pname), params); 1870 end(); 1871 1872 mgl.glLightfv(light, pname, params); 1873 checkError(); 1874 } 1875 1876 public void glLightx(int light, int pname, int param) { 1877 begin("glLightx"); 1878 arg("light", getLightName(light)); 1879 arg("pname", getLightPName(pname)); 1880 arg("param", param); 1881 end(); 1882 1883 mgl.glLightx(light, pname, param); 1884 checkError(); 1885 } 1886 1887 public void glLightxv(int light, int pname, int[] params, int offset) { 1888 begin("glLightxv"); 1889 arg("light", getLightName(light)); 1890 arg("pname", getLightPName(pname)); 1891 arg("params", getLightParamCount(pname), params, offset); 1892 arg("offset", offset); 1893 end(); 1894 1895 mgl.glLightxv(light, pname, params, offset); 1896 checkError(); 1897 } 1898 1899 public void glLightxv(int light, int pname, IntBuffer params) { 1900 begin("glLightxv"); 1901 arg("light", getLightName(light)); 1902 arg("pname", getLightPName(pname)); 1903 arg("params", getLightParamCount(pname), params); 1904 end(); 1905 1906 mgl.glLightxv(light, pname, params); 1907 checkError(); 1908 } 1909 1910 public void glLineWidth(float width) { 1911 begin("glLineWidth"); 1912 arg("width", width); 1913 end(); 1914 1915 mgl.glLineWidth(width); 1916 checkError(); 1917 } 1918 1919 public void glLineWidthx(int width) { 1920 begin("glLineWidthx"); 1921 arg("width", width); 1922 end(); 1923 1924 mgl.glLineWidthx(width); 1925 checkError(); 1926 } 1927 1928 public void glLoadIdentity() { 1929 begin("glLoadIdentity"); 1930 end(); 1931 1932 mgl.glLoadIdentity(); 1933 checkError(); 1934 } 1935 1936 public void glLoadMatrixf(float[] m, int offset) { 1937 begin("glLoadMatrixf"); 1938 arg("m", 16, m, offset); 1939 arg("offset", offset); 1940 end(); 1941 1942 mgl.glLoadMatrixf(m, offset); 1943 checkError(); 1944 } 1945 1946 public void glLoadMatrixf(FloatBuffer m) { 1947 begin("glLoadMatrixf"); 1948 arg("m", 16, m); 1949 end(); 1950 1951 mgl.glLoadMatrixf(m); 1952 checkError(); 1953 } 1954 1955 public void glLoadMatrixx(int[] m, int offset) { 1956 begin("glLoadMatrixx"); 1957 arg("m", 16, m, offset); 1958 arg("offset", offset); 1959 end(); 1960 1961 mgl.glLoadMatrixx(m, offset); 1962 checkError(); 1963 } 1964 1965 public void glLoadMatrixx(IntBuffer m) { 1966 begin("glLoadMatrixx"); 1967 arg("m", 16, m); 1968 end(); 1969 1970 mgl.glLoadMatrixx(m); 1971 checkError(); 1972 } 1973 1974 public void glLogicOp(int opcode) { 1975 begin("glLogicOp"); 1976 arg("opcode", opcode); 1977 end(); 1978 1979 mgl.glLogicOp(opcode); 1980 checkError(); 1981 } 1982 1983 public void glMaterialf(int face, int pname, float param) { 1984 begin("glMaterialf"); 1985 arg("face", getFaceName(face)); 1986 arg("pname", getMaterialPName(pname)); 1987 arg("param", param); 1988 end(); 1989 1990 mgl.glMaterialf(face, pname, param); 1991 checkError(); 1992 } 1993 1994 public void glMaterialfv(int face, int pname, float[] params, int offset) { 1995 begin("glMaterialfv"); 1996 arg("face", getFaceName(face)); 1997 arg("pname", getMaterialPName(pname)); 1998 arg("params", getMaterialParamCount(pname), params, offset); 1999 arg("offset", offset); 2000 end(); 2001 2002 mgl.glMaterialfv(face, pname, params, offset); 2003 checkError(); 2004 } 2005 2006 public void glMaterialfv(int face, int pname, FloatBuffer params) { 2007 begin("glMaterialfv"); 2008 arg("face", getFaceName(face)); 2009 arg("pname", getMaterialPName(pname)); 2010 arg("params", getMaterialParamCount(pname), params); 2011 end(); 2012 2013 mgl.glMaterialfv(face, pname, params); 2014 checkError(); 2015 } 2016 2017 public void glMaterialx(int face, int pname, int param) { 2018 begin("glMaterialx"); 2019 arg("face", getFaceName(face)); 2020 arg("pname", getMaterialPName(pname)); 2021 arg("param", param); 2022 end(); 2023 2024 mgl.glMaterialx(face, pname, param); 2025 checkError(); 2026 } 2027 2028 public void glMaterialxv(int face, int pname, int[] params, int offset) { 2029 begin("glMaterialxv"); 2030 arg("face", getFaceName(face)); 2031 arg("pname", getMaterialPName(pname)); 2032 arg("params", getMaterialParamCount(pname), params, offset); 2033 arg("offset", offset); 2034 end(); 2035 2036 mgl.glMaterialxv(face, pname, params, offset); 2037 checkError(); 2038 } 2039 2040 public void glMaterialxv(int face, int pname, IntBuffer params) { 2041 begin("glMaterialxv"); 2042 arg("face", getFaceName(face)); 2043 arg("pname", getMaterialPName(pname)); 2044 arg("params", getMaterialParamCount(pname), params); 2045 end(); 2046 2047 mgl.glMaterialxv(face, pname, params); 2048 checkError(); 2049 } 2050 2051 public void glMatrixMode(int mode) { 2052 begin("glMatrixMode"); 2053 arg("mode", getMatrixMode(mode)); 2054 end(); 2055 2056 mgl.glMatrixMode(mode); 2057 checkError(); 2058 } 2059 2060 public void glMultMatrixf(float[] m, int offset) { 2061 begin("glMultMatrixf"); 2062 arg("m", 16, m, offset); 2063 arg("offset", offset); 2064 end(); 2065 2066 mgl.glMultMatrixf(m, offset); 2067 checkError(); 2068 } 2069 2070 public void glMultMatrixf(FloatBuffer m) { 2071 begin("glMultMatrixf"); 2072 arg("m", 16, m); 2073 end(); 2074 2075 mgl.glMultMatrixf(m); 2076 checkError(); 2077 } 2078 2079 public void glMultMatrixx(int[] m, int offset) { 2080 begin("glMultMatrixx"); 2081 arg("m", 16, m, offset); 2082 arg("offset", offset); 2083 end(); 2084 2085 mgl.glMultMatrixx(m, offset); 2086 checkError(); 2087 } 2088 2089 public void glMultMatrixx(IntBuffer m) { 2090 begin("glMultMatrixx"); 2091 arg("m", 16, m); 2092 end(); 2093 2094 mgl.glMultMatrixx(m); 2095 checkError(); 2096 } 2097 2098 public void glMultiTexCoord4f(int target, float s, float t, float r, float q) { 2099 begin("glMultiTexCoord4f"); 2100 arg("target", target); 2101 arg("s", s); 2102 arg("t", t); 2103 arg("r", r); 2104 arg("q", q); 2105 end(); 2106 2107 mgl.glMultiTexCoord4f(target, s, t, r, q); 2108 checkError(); 2109 } 2110 2111 public void glMultiTexCoord4x(int target, int s, int t, int r, int q) { 2112 begin("glMultiTexCoord4x"); 2113 arg("target", target); 2114 arg("s", s); 2115 arg("t", t); 2116 arg("r", r); 2117 arg("q", q); 2118 end(); 2119 2120 mgl.glMultiTexCoord4x(target, s, t, r, q); 2121 checkError(); 2122 } 2123 2124 public void glNormal3f(float nx, float ny, float nz) { 2125 begin("glNormal3f"); 2126 arg("nx", nx); 2127 arg("ny", ny); 2128 arg("nz", nz); 2129 end(); 2130 2131 mgl.glNormal3f(nx, ny, nz); 2132 checkError(); 2133 } 2134 2135 public void glNormal3x(int nx, int ny, int nz) { 2136 begin("glNormal3x"); 2137 arg("nx", nx); 2138 arg("ny", ny); 2139 arg("nz", nz); 2140 end(); 2141 2142 mgl.glNormal3x(nx, ny, nz); 2143 checkError(); 2144 } 2145 2146 public void glNormalPointer(int type, int stride, Buffer pointer) { 2147 begin("glNormalPointer"); 2148 arg("type", type); 2149 arg("stride", stride); 2150 arg("pointer", pointer.toString()); 2151 end(); 2152 mNormalPointer = new PointerInfo(3, type, stride, pointer); 2153 2154 mgl.glNormalPointer(type, stride, pointer); 2155 checkError(); 2156 } 2157 2158 public void glOrthof(float left, float right, float bottom, float top, 2159 float near, float far) { 2160 begin("glOrthof"); 2161 arg("left", left); 2162 arg("right", right); 2163 arg("bottom", bottom); 2164 arg("top", top); 2165 arg("near", near); 2166 arg("far", far); 2167 end(); 2168 2169 mgl.glOrthof(left, right, bottom, top, near, far); 2170 checkError(); 2171 } 2172 2173 public void glOrthox(int left, int right, int bottom, int top, int near, 2174 int far) { 2175 begin("glOrthox"); 2176 arg("left", left); 2177 arg("right", right); 2178 arg("bottom", bottom); 2179 arg("top", top); 2180 arg("near", near); 2181 arg("far", far); 2182 end(); 2183 2184 mgl.glOrthox(left, right, bottom, top, near, far); 2185 checkError(); 2186 } 2187 2188 public void glPixelStorei(int pname, int param) { 2189 begin("glPixelStorei"); 2190 arg("pname", pname); 2191 arg("param", param); 2192 end(); 2193 2194 mgl.glPixelStorei(pname, param); 2195 checkError(); 2196 } 2197 2198 public void glPointSize(float size) { 2199 begin("glPointSize"); 2200 arg("size", size); 2201 end(); 2202 2203 mgl.glPointSize(size); 2204 checkError(); 2205 } 2206 2207 public void glPointSizex(int size) { 2208 begin("glPointSizex"); 2209 arg("size", size); 2210 end(); 2211 2212 mgl.glPointSizex(size); 2213 checkError(); 2214 } 2215 2216 public void glPolygonOffset(float factor, float units) { 2217 begin("glPolygonOffset"); 2218 arg("factor", factor); 2219 arg("units", units); 2220 end(); 2221 mgl.glPolygonOffset(factor, units); 2222 checkError(); 2223 } 2224 2225 public void glPolygonOffsetx(int factor, int units) { 2226 begin("glPolygonOffsetx"); 2227 arg("factor", factor); 2228 arg("units", units); 2229 end(); 2230 2231 mgl.glPolygonOffsetx(factor, units); 2232 checkError(); 2233 } 2234 2235 public void glPopMatrix() { 2236 begin("glPopMatrix"); 2237 end(); 2238 2239 mgl.glPopMatrix(); 2240 checkError(); 2241 } 2242 2243 public void glPushMatrix() { 2244 begin("glPushMatrix"); 2245 end(); 2246 2247 mgl.glPushMatrix(); 2248 checkError(); 2249 } 2250 2251 public void glReadPixels(int x, int y, int width, int height, int format, 2252 int type, Buffer pixels) { 2253 begin("glReadPixels"); 2254 arg("x", x); 2255 arg("y", y); 2256 arg("width", width); 2257 arg("height", height); 2258 arg("format", format); 2259 arg("type", type); 2260 arg("pixels", pixels.toString()); 2261 end(); 2262 2263 mgl.glReadPixels(x, y, width, height, format, type, pixels); 2264 checkError(); 2265 } 2266 2267 public void glRotatef(float angle, float x, float y, float z) { 2268 begin("glRotatef"); 2269 arg("angle", angle); 2270 arg("x", x); 2271 arg("y", y); 2272 arg("z", z); 2273 end(); 2274 2275 mgl.glRotatef(angle, x, y, z); 2276 checkError(); 2277 } 2278 2279 public void glRotatex(int angle, int x, int y, int z) { 2280 begin("glRotatex"); 2281 arg("angle", angle); 2282 arg("x", x); 2283 arg("y", y); 2284 arg("z", z); 2285 end(); 2286 2287 mgl.glRotatex(angle, x, y, z); 2288 checkError(); 2289 } 2290 2291 public void glSampleCoverage(float value, boolean invert) { 2292 begin("glSampleCoveragex"); 2293 arg("value", value); 2294 arg("invert", invert); 2295 end(); 2296 2297 mgl.glSampleCoverage(value, invert); 2298 checkError(); 2299 } 2300 2301 public void glSampleCoveragex(int value, boolean invert) { 2302 begin("glSampleCoveragex"); 2303 arg("value", value); 2304 arg("invert", invert); 2305 end(); 2306 2307 mgl.glSampleCoveragex(value, invert); 2308 checkError(); 2309 } 2310 2311 public void glScalef(float x, float y, float z) { 2312 begin("glScalef"); 2313 arg("x", x); 2314 arg("y", y); 2315 arg("z", z); 2316 end(); 2317 2318 mgl.glScalef(x, y, z); 2319 checkError(); 2320 } 2321 2322 public void glScalex(int x, int y, int z) { 2323 begin("glScalex"); 2324 arg("x", x); 2325 arg("y", y); 2326 arg("z", z); 2327 end(); 2328 2329 mgl.glScalex(x, y, z); 2330 checkError(); 2331 } 2332 2333 public void glScissor(int x, int y, int width, int height) { 2334 begin("glScissor"); 2335 arg("x", x); 2336 arg("y", y); 2337 arg("width", width); 2338 arg("height", height); 2339 end(); 2340 2341 mgl.glScissor(x, y, width, height); 2342 checkError(); 2343 } 2344 2345 public void glShadeModel(int mode) { 2346 begin("glShadeModel"); 2347 arg("mode", getShadeModel(mode)); 2348 end(); 2349 2350 mgl.glShadeModel(mode); 2351 checkError(); 2352 } 2353 2354 public void glStencilFunc(int func, int ref, int mask) { 2355 begin("glStencilFunc"); 2356 arg("func", func); 2357 arg("ref", ref); 2358 arg("mask", mask); 2359 end(); 2360 2361 mgl.glStencilFunc(func, ref, mask); 2362 checkError(); 2363 } 2364 2365 public void glStencilMask(int mask) { 2366 begin("glStencilMask"); 2367 arg("mask", mask); 2368 end(); 2369 2370 mgl.glStencilMask(mask); 2371 checkError(); 2372 } 2373 2374 public void glStencilOp(int fail, int zfail, int zpass) { 2375 begin("glStencilOp"); 2376 arg("fail", fail); 2377 arg("zfail", zfail); 2378 arg("zpass", zpass); 2379 end(); 2380 2381 mgl.glStencilOp(fail, zfail, zpass); 2382 checkError(); 2383 } 2384 2385 public void glTexCoordPointer(int size, int type, int stride, Buffer pointer) { 2386 begin("glTexCoordPointer"); 2387 argPointer(size, type, stride, pointer); 2388 end(); 2389 mTexCoordPointer = new PointerInfo(size, type, stride, pointer); 2390 2391 mgl.glTexCoordPointer(size, type, stride, pointer); 2392 checkError(); 2393 } 2394 2395 public void glTexEnvf(int target, int pname, float param) { 2396 begin("glTexEnvf"); 2397 arg("target", getTextureEnvTarget(target)); 2398 arg("pname", getTextureEnvPName(pname)); 2399 arg("param", getTextureEnvParamName(param)); 2400 end(); 2401 2402 mgl.glTexEnvf(target, pname, param); 2403 checkError(); 2404 } 2405 2406 public void glTexEnvfv(int target, int pname, float[] params, int offset) { 2407 begin("glTexEnvfv"); 2408 arg("target", getTextureEnvTarget(target)); 2409 arg("pname", getTextureEnvPName(pname)); 2410 arg("params", getTextureEnvParamCount(pname), params, offset); 2411 arg("offset", offset); 2412 end(); 2413 2414 mgl.glTexEnvfv(target, pname, params, offset); 2415 checkError(); 2416 } 2417 2418 public void glTexEnvfv(int target, int pname, FloatBuffer params) { 2419 begin("glTexEnvfv"); 2420 arg("target", getTextureEnvTarget(target)); 2421 arg("pname", getTextureEnvPName(pname)); 2422 arg("params", getTextureEnvParamCount(pname), params); 2423 end(); 2424 2425 mgl.glTexEnvfv(target, pname, params); 2426 checkError(); 2427 } 2428 2429 public void glTexEnvx(int target, int pname, int param) { 2430 begin("glTexEnvx"); 2431 arg("target", getTextureEnvTarget(target)); 2432 arg("pname", getTextureEnvPName(pname)); 2433 arg("param", param); 2434 end(); 2435 2436 mgl.glTexEnvx(target, pname, param); 2437 checkError(); 2438 } 2439 2440 public void glTexEnvxv(int target, int pname, int[] params, int offset) { 2441 begin("glTexEnvxv"); 2442 arg("target", getTextureEnvTarget(target)); 2443 arg("pname", getTextureEnvPName(pname)); 2444 arg("params", getTextureEnvParamCount(pname), params, offset); 2445 arg("offset", offset); 2446 end(); 2447 2448 mgl.glTexEnvxv(target, pname, params, offset); 2449 checkError(); 2450 } 2451 2452 public void glTexEnvxv(int target, int pname, IntBuffer params) { 2453 begin("glTexEnvxv"); 2454 arg("target", getTextureEnvTarget(target)); 2455 arg("pname", getTextureEnvPName(pname)); 2456 arg("params", getTextureEnvParamCount(pname), params); 2457 end(); 2458 2459 mgl.glTexEnvxv(target, pname, params); 2460 checkError(); 2461 } 2462 2463 public void glTexImage2D(int target, int level, int internalformat, 2464 int width, int height, int border, int format, int type, 2465 Buffer pixels) { 2466 begin("glTexImage2D"); 2467 arg("target", target); 2468 arg("level", level); 2469 arg("internalformat", internalformat); 2470 arg("width", width); 2471 arg("height", height); 2472 arg("border", border); 2473 arg("format", format); 2474 arg("type", type); 2475 arg("pixels", pixels.toString()); 2476 end(); 2477 2478 mgl.glTexImage2D(target, level, internalformat, width, height, border, 2479 format, type, pixels); 2480 checkError(); 2481 } 2482 2483 public void glTexParameterf(int target, int pname, float param) { 2484 begin("glTexParameterf"); 2485 arg("target", getTextureTarget(target)); 2486 arg("pname", getTexturePName(pname)); 2487 arg("param", getTextureParamName(param)); 2488 end(); 2489 2490 mgl.glTexParameterf(target, pname, param); 2491 checkError(); 2492 } 2493 2494 public void glTexParameterx(int target, int pname, int param) { 2495 begin("glTexParameterx"); 2496 arg("target", getTextureTarget(target)); 2497 arg("pname", getTexturePName(pname)); 2498 arg("param", param); 2499 end(); 2500 2501 mgl.glTexParameterx(target, pname, param); 2502 checkError(); 2503 } 2504 2505 public void glTexParameteriv(int target, int pname, int[] params, int offset) { 2506 begin("glTexParameteriv"); 2507 arg("target", getTextureTarget(target)); 2508 arg("pname", getTexturePName(pname)); 2509 arg("params", 4, params, offset); 2510 end(); 2511 2512 mgl11.glTexParameteriv(target, pname, params, offset); 2513 checkError(); 2514 } 2515 2516 public void glTexParameteriv(int target, int pname, IntBuffer params) { 2517 begin("glTexParameteriv"); 2518 arg("target", getTextureTarget(target)); 2519 arg("pname", getTexturePName(pname)); 2520 arg("params", 4, params); 2521 end(); 2522 2523 mgl11.glTexParameteriv(target, pname, params); 2524 checkError(); 2525 } 2526 2527 public void glTexSubImage2D(int target, int level, int xoffset, 2528 int yoffset, int width, int height, int format, int type, 2529 Buffer pixels) { 2530 begin("glTexSubImage2D"); 2531 arg("target", getTextureTarget(target)); 2532 arg("level", level); 2533 arg("xoffset", xoffset); 2534 arg("yoffset", yoffset); 2535 arg("width", width); 2536 arg("height", height); 2537 arg("format", format); 2538 arg("type", type); 2539 arg("pixels", pixels.toString()); 2540 end(); 2541 mgl.glTexSubImage2D(target, level, xoffset, yoffset, width, height, 2542 format, type, pixels); 2543 checkError(); 2544 } 2545 2546 public void glTranslatef(float x, float y, float z) { 2547 begin("glTranslatef"); 2548 arg("x", x); 2549 arg("y", y); 2550 arg("z", z); 2551 end(); 2552 mgl.glTranslatef(x, y, z); 2553 checkError(); 2554 } 2555 2556 public void glTranslatex(int x, int y, int z) { 2557 begin("glTranslatex"); 2558 arg("x", x); 2559 arg("y", y); 2560 arg("z", z); 2561 end(); 2562 mgl.glTranslatex(x, y, z); 2563 checkError(); 2564 } 2565 2566 public void glVertexPointer(int size, int type, int stride, Buffer pointer) { 2567 begin("glVertexPointer"); 2568 argPointer(size, type, stride, pointer); 2569 end(); 2570 mVertexPointer = new PointerInfo(size, type, stride, pointer); 2571 mgl.glVertexPointer(size, type, stride, pointer); 2572 checkError(); 2573 } 2574 2575 public void glViewport(int x, int y, int width, int height) { 2576 begin("glViewport"); 2577 arg("x", x); 2578 arg("y", y); 2579 arg("width", width); 2580 arg("height", height); 2581 end(); 2582 mgl.glViewport(x, y, width, height); 2583 checkError(); 2584 } 2585 2586 public void glClipPlanef(int plane, float[] equation, int offset) { 2587 begin("glClipPlanef"); 2588 arg("plane", plane); 2589 arg("equation", 4, equation, offset); 2590 arg("offset", offset); 2591 end(); 2592 mgl11.glClipPlanef(plane, equation, offset); 2593 checkError(); 2594 } 2595 2596 public void glClipPlanef(int plane, FloatBuffer equation) { 2597 begin("glClipPlanef"); 2598 arg("plane", plane); 2599 arg("equation", 4, equation); 2600 end(); 2601 mgl11.glClipPlanef(plane, equation); 2602 checkError(); 2603 } 2604 2605 public void glClipPlanex(int plane, int[] equation, int offset) { 2606 begin("glClipPlanex"); 2607 arg("plane", plane); 2608 arg("equation", 4, equation, offset); 2609 arg("offset", offset); 2610 end(); 2611 mgl11.glClipPlanex(plane, equation, offset); 2612 checkError(); 2613 } 2614 2615 public void glClipPlanex(int plane, IntBuffer equation) { 2616 begin("glClipPlanef"); 2617 arg("plane", plane); 2618 arg("equation", 4, equation); 2619 end(); 2620 mgl11.glClipPlanex(plane, equation); 2621 checkError(); 2622 } 2623 2624 // Draw Texture Extension 2625 2626 public void glDrawTexfOES(float x, float y, float z, 2627 float width, float height) { 2628 begin("glDrawTexfOES"); 2629 arg("x", x); 2630 arg("y", y); 2631 arg("z", z); 2632 arg("width", width); 2633 arg("height", height); 2634 end(); 2635 mgl11Ext.glDrawTexfOES(x, y, z, width, height); 2636 checkError(); 2637 } 2638 2639 public void glDrawTexfvOES(float[] coords, int offset) { 2640 begin("glDrawTexfvOES"); 2641 arg("coords", 5, coords, offset); 2642 arg("offset", offset); 2643 end(); 2644 mgl11Ext.glDrawTexfvOES(coords, offset); 2645 checkError(); 2646 } 2647 2648 public void glDrawTexfvOES(FloatBuffer coords) { 2649 begin("glDrawTexfvOES"); 2650 arg("coords", 5, coords); 2651 end(); 2652 mgl11Ext.glDrawTexfvOES(coords); 2653 checkError(); 2654 } 2655 2656 public void glDrawTexiOES(int x, int y, int z, int width, int height) { 2657 begin("glDrawTexiOES"); 2658 arg("x", x); 2659 arg("y", y); 2660 arg("z", z); 2661 arg("width", width); 2662 arg("height", height); 2663 end(); 2664 mgl11Ext.glDrawTexiOES(x, y, z, width, height); 2665 checkError(); 2666 } 2667 2668 public void glDrawTexivOES(int[] coords, int offset) { 2669 begin("glDrawTexivOES"); 2670 arg("coords", 5, coords, offset); 2671 arg("offset", offset); 2672 end(); 2673 mgl11Ext.glDrawTexivOES(coords, offset); 2674 checkError(); 2675 } 2676 2677 public void glDrawTexivOES(IntBuffer coords) { 2678 begin("glDrawTexivOES"); 2679 arg("coords", 5, coords); 2680 end(); 2681 mgl11Ext.glDrawTexivOES(coords); 2682 checkError(); 2683 } 2684 2685 public void glDrawTexsOES(short x, short y, short z, 2686 short width, short height) { 2687 begin("glDrawTexsOES"); 2688 arg("x", x); 2689 arg("y", y); 2690 arg("z", z); 2691 arg("width", width); 2692 arg("height", height); 2693 end(); 2694 mgl11Ext.glDrawTexsOES(x, y, z, width, height); 2695 checkError(); 2696 } 2697 2698 public void glDrawTexsvOES(short[] coords, int offset) { 2699 begin("glDrawTexsvOES"); 2700 arg("coords", 5, coords, offset); 2701 arg("offset", offset); 2702 end(); 2703 mgl11Ext.glDrawTexsvOES(coords, offset); 2704 checkError(); 2705 } 2706 2707 public void glDrawTexsvOES(ShortBuffer coords) { 2708 begin("glDrawTexsvOES"); 2709 arg("coords", 5, coords); 2710 end(); 2711 mgl11Ext.glDrawTexsvOES(coords); 2712 checkError(); 2713 } 2714 2715 public void glDrawTexxOES(int x, int y, int z, int width, int height) { 2716 begin("glDrawTexxOES"); 2717 arg("x", x); 2718 arg("y", y); 2719 arg("z", z); 2720 arg("width", width); 2721 arg("height", height); 2722 end(); 2723 mgl11Ext.glDrawTexxOES(x, y, z, width, height); 2724 checkError(); 2725 } 2726 2727 public void glDrawTexxvOES(int[] coords, int offset) { 2728 begin("glDrawTexxvOES"); 2729 arg("coords", 5, coords, offset); 2730 arg("offset", offset); 2731 end(); 2732 mgl11Ext.glDrawTexxvOES(coords, offset); 2733 checkError(); 2734 } 2735 2736 public void glDrawTexxvOES(IntBuffer coords) { 2737 begin("glDrawTexxvOES"); 2738 arg("coords", 5, coords); 2739 end(); 2740 mgl11Ext.glDrawTexxvOES(coords); 2741 checkError(); 2742 } 2743 2744 public int glQueryMatrixxOES(int[] mantissa, int mantissaOffset, 2745 int[] exponent, int exponentOffset) { 2746 begin("glQueryMatrixxOES"); 2747 arg("mantissa", Arrays.toString(mantissa)); 2748 arg("exponent", Arrays.toString(exponent)); 2749 end(); 2750 int valid = mgl10Ext.glQueryMatrixxOES(mantissa, mantissaOffset, 2751 exponent, exponentOffset); 2752 returns(toString(16, FORMAT_FIXED, mantissa, mantissaOffset)); 2753 returns(toString(16, FORMAT_INT, exponent, exponentOffset)); 2754 checkError(); 2755 return valid; 2756 } 2757 2758 public int glQueryMatrixxOES(IntBuffer mantissa, IntBuffer exponent) { 2759 begin("glQueryMatrixxOES"); 2760 arg("mantissa", mantissa.toString()); 2761 arg("exponent", exponent.toString()); 2762 end(); 2763 int valid = mgl10Ext.glQueryMatrixxOES(mantissa, exponent); 2764 returns(toString(16, FORMAT_FIXED, mantissa)); 2765 returns(toString(16, FORMAT_INT, exponent)); 2766 checkError(); 2767 return valid; 2768 } 2769 2770 public void glBindBuffer(int target, int buffer) { 2771 begin("glBindBuffer"); 2772 arg("target", target); 2773 arg("buffer", buffer); 2774 end(); 2775 mgl11.glBindBuffer(target, buffer); 2776 checkError(); 2777 } 2778 2779 public void glBufferData(int target, int size, Buffer data, int usage) { 2780 begin("glBufferData"); 2781 arg("target", target); 2782 arg("size", size); 2783 arg("data", data.toString()); 2784 arg("usage", usage); 2785 end(); 2786 mgl11.glBufferData(target, size, data, usage); 2787 checkError(); 2788 } 2789 2790 public void glBufferSubData(int target, int offset, int size, Buffer data) { 2791 begin("glBufferSubData"); 2792 arg("target", target); 2793 arg("offset", offset); 2794 arg("size", size); 2795 arg("data", data.toString()); 2796 end(); 2797 mgl11.glBufferSubData(target, offset, size, data); 2798 checkError(); 2799 } 2800 2801 public void glColor4ub(byte red, byte green, byte blue, byte alpha) { 2802 begin("glColor4ub"); 2803 arg("red", red); 2804 arg("green", green); 2805 arg("blue", blue); 2806 arg("alpha", alpha); 2807 end(); 2808 mgl11.glColor4ub(red, green, blue, alpha); 2809 checkError(); 2810 } 2811 2812 public void glDeleteBuffers(int n, int[] buffers, int offset) { 2813 begin("glDeleteBuffers"); 2814 arg("n", n); 2815 arg("buffers", buffers.toString()); 2816 arg("offset", offset); 2817 end(); 2818 mgl11.glDeleteBuffers(n, buffers, offset); 2819 checkError(); 2820 } 2821 2822 public void glDeleteBuffers(int n, IntBuffer buffers) { 2823 begin("glDeleteBuffers"); 2824 arg("n", n); 2825 arg("buffers", buffers.toString()); 2826 end(); 2827 mgl11.glDeleteBuffers(n, buffers); 2828 checkError(); 2829 } 2830 2831 public void glGenBuffers(int n, int[] buffers, int offset) { 2832 begin("glGenBuffers"); 2833 arg("n", n); 2834 arg("buffers", buffers.toString()); 2835 arg("offset", offset); 2836 end(); 2837 mgl11.glGenBuffers(n, buffers, offset); 2838 checkError(); 2839 } 2840 2841 public void glGenBuffers(int n, IntBuffer buffers) { 2842 begin("glGenBuffers"); 2843 arg("n", n); 2844 arg("buffers", buffers.toString()); 2845 end(); 2846 mgl11.glGenBuffers(n, buffers); 2847 checkError(); 2848 } 2849 2850 public void glGetBooleanv(int pname, boolean[] params, int offset) { 2851 begin("glGetBooleanv"); 2852 arg("pname", pname); 2853 arg("params", params.toString()); 2854 arg("offset", offset); 2855 end(); 2856 mgl11.glGetBooleanv(pname, params, offset); 2857 checkError(); 2858 } 2859 2860 public void glGetBooleanv(int pname, IntBuffer params) { 2861 begin("glGetBooleanv"); 2862 arg("pname", pname); 2863 arg("params", params.toString()); 2864 end(); 2865 mgl11.glGetBooleanv(pname, params); 2866 checkError(); 2867 } 2868 2869 public void glGetBufferParameteriv(int target, int pname, int[] params, 2870 int offset) { 2871 begin("glGetBufferParameteriv"); 2872 arg("target", target); 2873 arg("pname", pname); 2874 arg("params", params.toString()); 2875 arg("offset", offset); 2876 end(); 2877 mgl11.glGetBufferParameteriv(target, pname, params, offset); 2878 checkError(); 2879 } 2880 2881 public void glGetBufferParameteriv(int target, int pname, IntBuffer params) { 2882 begin("glGetBufferParameteriv"); 2883 arg("target", target); 2884 arg("pname", pname); 2885 arg("params", params.toString()); 2886 end(); 2887 mgl11.glGetBufferParameteriv(target, pname, params); 2888 checkError(); 2889 } 2890 2891 public void glGetClipPlanef(int pname, float[] eqn, int offset) { 2892 begin("glGetClipPlanef"); 2893 arg("pname", pname); 2894 arg("eqn", eqn.toString()); 2895 arg("offset", offset); 2896 end(); 2897 mgl11.glGetClipPlanef(pname, eqn, offset); 2898 checkError(); 2899 } 2900 2901 public void glGetClipPlanef(int pname, FloatBuffer eqn) { 2902 begin("glGetClipPlanef"); 2903 arg("pname", pname); 2904 arg("eqn", eqn.toString()); 2905 end(); 2906 mgl11.glGetClipPlanef(pname, eqn); 2907 checkError(); 2908 } 2909 2910 public void glGetClipPlanex(int pname, int[] eqn, int offset) { 2911 begin("glGetClipPlanex"); 2912 arg("pname", pname); 2913 arg("eqn", eqn.toString()); 2914 arg("offset", offset); 2915 end(); 2916 mgl11.glGetClipPlanex(pname, eqn, offset); 2917 } 2918 2919 public void glGetClipPlanex(int pname, IntBuffer eqn) { 2920 begin("glGetClipPlanex"); 2921 arg("pname", pname); 2922 arg("eqn", eqn.toString()); 2923 end(); 2924 mgl11.glGetClipPlanex(pname, eqn); 2925 checkError(); 2926 } 2927 2928 public void glGetFixedv(int pname, int[] params, int offset) { 2929 begin("glGetFixedv"); 2930 arg("pname", pname); 2931 arg("params", params.toString()); 2932 arg("offset", offset); 2933 end(); 2934 mgl11.glGetFixedv(pname, params, offset); 2935 } 2936 2937 public void glGetFixedv(int pname, IntBuffer params) { 2938 begin("glGetFixedv"); 2939 arg("pname", pname); 2940 arg("params", params.toString()); 2941 end(); 2942 mgl11.glGetFixedv(pname, params); 2943 checkError(); 2944 } 2945 2946 public void glGetFloatv(int pname, float[] params, int offset) { 2947 begin("glGetFloatv"); 2948 arg("pname", pname); 2949 arg("params", params.toString()); 2950 arg("offset", offset); 2951 end(); 2952 mgl11.glGetFloatv(pname, params, offset); 2953 } 2954 2955 public void glGetFloatv(int pname, FloatBuffer params) { 2956 begin("glGetFloatv"); 2957 arg("pname", pname); 2958 arg("params", params.toString()); 2959 end(); 2960 mgl11.glGetFloatv(pname, params); 2961 checkError(); 2962 } 2963 2964 public void glGetLightfv(int light, int pname, float[] params, int offset) { 2965 begin("glGetLightfv"); 2966 arg("light", light); 2967 arg("pname", pname); 2968 arg("params", params.toString()); 2969 arg("offset", offset); 2970 end(); 2971 mgl11.glGetLightfv(light, pname, params, offset); 2972 checkError(); 2973 } 2974 2975 public void glGetLightfv(int light, int pname, FloatBuffer params) { 2976 begin("glGetLightfv"); 2977 arg("light", light); 2978 arg("pname", pname); 2979 arg("params", params.toString()); 2980 end(); 2981 mgl11.glGetLightfv(light, pname, params); 2982 checkError(); 2983 } 2984 2985 public void glGetLightxv(int light, int pname, int[] params, int offset) { 2986 begin("glGetLightxv"); 2987 arg("light", light); 2988 arg("pname", pname); 2989 arg("params", params.toString()); 2990 arg("offset", offset); 2991 end(); 2992 mgl11.glGetLightxv(light, pname, params, offset); 2993 checkError(); 2994 } 2995 2996 public void glGetLightxv(int light, int pname, IntBuffer params) { 2997 begin("glGetLightxv"); 2998 arg("light", light); 2999 arg("pname", pname); 3000 arg("params", params.toString()); 3001 end(); 3002 mgl11.glGetLightxv(light, pname, params); 3003 checkError(); 3004 } 3005 3006 public void glGetMaterialfv(int face, int pname, float[] params, 3007 int offset) { 3008 begin("glGetMaterialfv"); 3009 arg("face", face); 3010 arg("pname", pname); 3011 arg("params", params.toString()); 3012 arg("offset", offset); 3013 end(); 3014 mgl11.glGetMaterialfv(face, pname, params, offset); 3015 checkError(); 3016 } 3017 3018 public void glGetMaterialfv(int face, int pname, FloatBuffer params) { 3019 begin("glGetMaterialfv"); 3020 arg("face", face); 3021 arg("pname", pname); 3022 arg("params", params.toString()); 3023 end(); 3024 mgl11.glGetMaterialfv(face, pname, params); 3025 checkError(); 3026 } 3027 3028 public void glGetMaterialxv(int face, int pname, int[] params, int offset) { 3029 begin("glGetMaterialxv"); 3030 arg("face", face); 3031 arg("pname", pname); 3032 arg("params", params.toString()); 3033 arg("offset", offset); 3034 end(); 3035 mgl11.glGetMaterialxv(face, pname, params, offset); 3036 checkError(); 3037 } 3038 3039 public void glGetMaterialxv(int face, int pname, IntBuffer params) { 3040 begin("glGetMaterialxv"); 3041 arg("face", face); 3042 arg("pname", pname); 3043 arg("params", params.toString()); 3044 end(); 3045 mgl11.glGetMaterialxv(face, pname, params); 3046 checkError(); 3047 } 3048 3049 public void glGetTexEnviv(int env, int pname, int[] params, int offset) { 3050 begin("glGetTexEnviv"); 3051 arg("env", env); 3052 arg("pname", pname); 3053 arg("params", params.toString()); 3054 arg("offset", offset); 3055 end(); 3056 mgl11.glGetTexEnviv(env, pname, params, offset); 3057 checkError(); 3058 } 3059 3060 public void glGetTexEnviv(int env, int pname, IntBuffer params) { 3061 begin("glGetTexEnviv"); 3062 arg("env", env); 3063 arg("pname", pname); 3064 arg("params", params.toString()); 3065 end(); 3066 mgl11.glGetTexEnviv(env, pname, params); 3067 checkError(); 3068 } 3069 3070 public void glGetTexEnvxv(int env, int pname, int[] params, int offset) { 3071 begin("glGetTexEnviv"); 3072 arg("env", env); 3073 arg("pname", pname); 3074 arg("params", params.toString()); 3075 arg("offset", offset); 3076 end(); 3077 mgl11.glGetTexEnviv(env, pname, params, offset); 3078 checkError(); 3079 } 3080 3081 public void glGetTexEnvxv(int env, int pname, IntBuffer params) { 3082 begin("glGetTexEnviv"); 3083 arg("env", env); 3084 arg("pname", pname); 3085 arg("params", params.toString()); 3086 end(); 3087 mgl11.glGetTexEnvxv(env, pname, params); 3088 checkError(); 3089 } 3090 3091 public void glGetTexParameterfv(int target, int pname, float[] params, int offset) { 3092 begin("glGetTexParameterfv"); 3093 arg("target", target); 3094 arg("pname", pname); 3095 arg("params", params.toString()); 3096 arg("offset", offset); 3097 end(); 3098 mgl11.glGetTexParameterfv(target, pname, params, offset); 3099 checkError(); 3100 } 3101 3102 public void glGetTexParameterfv(int target, int pname, FloatBuffer params) { 3103 begin("glGetTexParameterfv"); 3104 arg("target", target); 3105 arg("pname", pname); 3106 arg("params", params.toString()); 3107 end(); 3108 mgl11.glGetTexParameterfv(target, pname, params); 3109 checkError(); 3110 } 3111 3112 public void glGetTexParameteriv(int target, int pname, int[] params, int offset) { 3113 begin("glGetTexParameteriv"); 3114 arg("target", target); 3115 arg("pname", pname); 3116 arg("params", params.toString()); 3117 arg("offset", offset); 3118 end(); 3119 mgl11.glGetTexEnviv(target, pname, params, offset); 3120 checkError(); 3121 } 3122 3123 public void glGetTexParameteriv(int target, int pname, IntBuffer params) { 3124 begin("glGetTexParameteriv"); 3125 arg("target", target); 3126 arg("pname", pname); 3127 arg("params", params.toString()); 3128 end(); 3129 mgl11.glGetTexParameteriv(target, pname, params); 3130 checkError(); 3131 } 3132 3133 public void glGetTexParameterxv(int target, int pname, int[] params, 3134 int offset) { 3135 begin("glGetTexParameterxv"); 3136 arg("target", target); 3137 arg("pname", pname); 3138 arg("params", params.toString()); 3139 arg("offset", offset); 3140 end(); 3141 mgl11.glGetTexParameterxv(target, pname, params, offset); 3142 checkError(); 3143 } 3144 3145 public void glGetTexParameterxv(int target, int pname, IntBuffer params) { 3146 begin("glGetTexParameterxv"); 3147 arg("target", target); 3148 arg("pname", pname); 3149 arg("params", params.toString()); 3150 end(); 3151 mgl11.glGetTexParameterxv(target, pname, params); 3152 checkError(); 3153 } 3154 3155 public boolean glIsBuffer(int buffer) { 3156 begin("glIsBuffer"); 3157 arg("buffer", buffer); 3158 end(); 3159 boolean result = mgl11.glIsBuffer(buffer); 3160 checkError(); 3161 return result; 3162 } 3163 3164 public boolean glIsEnabled(int cap) { 3165 begin("glIsEnabled"); 3166 arg("cap", cap); 3167 end(); 3168 boolean result = mgl11.glIsEnabled(cap); 3169 checkError(); 3170 return result; 3171 } 3172 3173 public boolean glIsTexture(int texture) { 3174 begin("glIsTexture"); 3175 arg("texture", texture); 3176 end(); 3177 boolean result = mgl11.glIsTexture(texture); 3178 checkError(); 3179 return result; 3180 } 3181 3182 public void glPointParameterf(int pname, float param) { 3183 begin("glPointParameterf"); 3184 arg("pname", pname); 3185 arg("param", param); 3186 end(); 3187 mgl11.glPointParameterf( pname, param); 3188 checkError(); 3189 } 3190 3191 public void glPointParameterfv(int pname, float[] params, int offset) { 3192 begin("glPointParameterfv"); 3193 arg("pname", pname); 3194 arg("params", params.toString()); 3195 arg("offset", offset); 3196 end(); 3197 mgl11.glPointParameterfv(pname, params, offset); 3198 checkError(); 3199 } 3200 3201 public void glPointParameterfv(int pname, FloatBuffer params) { 3202 begin("glPointParameterfv"); 3203 arg("pname", pname); 3204 arg("params", params.toString()); 3205 end(); 3206 mgl11.glPointParameterfv(pname, params); 3207 checkError(); 3208 } 3209 3210 public void glPointParameterx(int pname, int param) { 3211 begin("glPointParameterfv"); 3212 arg("pname", pname); 3213 arg("param", param); 3214 end(); 3215 mgl11.glPointParameterx( pname, param); 3216 checkError(); 3217 } 3218 3219 public void glPointParameterxv(int pname, int[] params, int offset) { 3220 begin("glPointParameterxv"); 3221 arg("pname", pname); 3222 arg("params", params.toString()); 3223 arg("offset", offset); 3224 end(); 3225 mgl11.glPointParameterxv(pname, params, offset); 3226 checkError(); 3227 } 3228 3229 public void glPointParameterxv(int pname, IntBuffer params) { 3230 begin("glPointParameterxv"); 3231 arg("pname", pname); 3232 arg("params", params.toString()); 3233 end(); 3234 mgl11.glPointParameterxv( pname, params); 3235 checkError(); 3236 } 3237 3238 public void glPointSizePointerOES(int type, int stride, Buffer pointer) { 3239 begin("glPointSizePointerOES"); 3240 arg("type", type); 3241 arg("stride", stride); 3242 arg("params", pointer.toString()); 3243 end(); 3244 mgl11.glPointSizePointerOES( type, stride, pointer); 3245 checkError(); 3246 } 3247 3248 public void glTexEnvi(int target, int pname, int param) { 3249 begin("glTexEnvi"); 3250 arg("target", target); 3251 arg("pname", pname); 3252 arg("param", param); 3253 end(); 3254 mgl11.glTexEnvi(target, pname, param); 3255 checkError(); 3256 } 3257 3258 public void glTexEnviv(int target, int pname, int[] params, int offset) { 3259 begin("glTexEnviv"); 3260 arg("target", target); 3261 arg("pname", pname); 3262 arg("params", params.toString()); 3263 arg("offset", offset); 3264 end(); 3265 mgl11.glTexEnviv(target, pname, params, offset); 3266 checkError(); 3267 } 3268 3269 public void glTexEnviv(int target, int pname, IntBuffer params) { 3270 begin("glTexEnviv"); 3271 arg("target", target); 3272 arg("pname", pname); 3273 arg("params", params.toString()); 3274 end(); 3275 mgl11.glTexEnviv( target, pname, params); 3276 checkError(); 3277 } 3278 3279 public void glTexParameterfv(int target, int pname, float[] params, 3280 int offset) { 3281 begin("glTexParameterfv"); 3282 arg("target", target); 3283 arg("pname", pname); 3284 arg("params", params.toString()); 3285 arg("offset", offset); 3286 end(); 3287 mgl11.glTexParameterfv( target, pname, params, offset); 3288 checkError(); 3289 } 3290 3291 public void glTexParameterfv(int target, int pname, FloatBuffer params) { 3292 begin("glTexParameterfv"); 3293 arg("target", target); 3294 arg("pname", pname); 3295 arg("params", params.toString()); 3296 end(); 3297 mgl11.glTexParameterfv(target, pname, params); 3298 checkError(); 3299 } 3300 3301 public void glTexParameteri(int target, int pname, int param) { 3302 begin("glTexParameterxv"); 3303 arg("target", target); 3304 arg("pname", pname); 3305 arg("param", param); 3306 end(); 3307 mgl11.glTexParameteri(target, pname, param); 3308 checkError(); 3309 } 3310 3311 public void glTexParameterxv(int target, int pname, int[] params, 3312 int offset) { 3313 begin("glTexParameterxv"); 3314 arg("target", target); 3315 arg("pname", pname); 3316 arg("params", params.toString()); 3317 arg("offset", offset); 3318 end(); 3319 mgl11.glTexParameterxv(target, pname, params, offset); 3320 checkError(); 3321 } 3322 3323 public void glTexParameterxv(int target, int pname, IntBuffer params) { 3324 begin("glTexParameterxv"); 3325 arg("target", target); 3326 arg("pname", pname); 3327 arg("params", params.toString()); 3328 end(); 3329 mgl11.glTexParameterxv(target, pname, params); 3330 checkError(); 3331 } 3332 3333 3334 public void glColorPointer(int size, int type, int stride, int offset) { 3335 begin("glColorPointer"); 3336 arg("size", size); 3337 arg("type", type); 3338 arg("stride", stride); 3339 arg("offset", offset); 3340 end(); 3341 mgl11.glColorPointer(size, type, stride, offset); 3342 checkError(); 3343 } 3344 3345 public void glDrawElements(int mode, int count, int type, int offset) { 3346 begin("glDrawElements"); 3347 arg("mode", mode); 3348 arg("count", count); 3349 arg("type", type); 3350 arg("offset", offset); 3351 end(); 3352 mgl11.glDrawElements(mode, count, type, offset); 3353 checkError(); 3354 } 3355 3356 public void glGetPointerv(int pname, Buffer[] params) { 3357 begin("glGetPointerv"); 3358 arg("pname", pname); 3359 arg("params", params.toString()); 3360 end(); 3361 mgl11.glGetPointerv(pname, params); 3362 checkError(); 3363 } 3364 3365 public void glNormalPointer(int type, int stride, int offset) { 3366 begin("glNormalPointer"); 3367 arg("type", type); 3368 arg("stride", stride); 3369 arg("offset", offset); 3370 end(); 3371 mgl11.glNormalPointer(type, stride, offset); 3372 } 3373 3374 public void glTexCoordPointer(int size, int type, int stride, int offset) { 3375 begin("glTexCoordPointer"); 3376 arg("size", size); 3377 arg("type", type); 3378 arg("stride", stride); 3379 arg("offset", offset); 3380 end(); 3381 mgl11.glTexCoordPointer(size, type, stride, offset); 3382 } 3383 3384 public void glVertexPointer(int size, int type, int stride, int offset) { 3385 begin("glVertexPointer"); 3386 arg("size", size); 3387 arg("type", type); 3388 arg("stride", stride); 3389 arg("offset", offset); 3390 end(); 3391 mgl11.glVertexPointer(size, type, stride, offset); 3392 } 3393 3394 public void glCurrentPaletteMatrixOES(int matrixpaletteindex) { 3395 begin("glCurrentPaletteMatrixOES"); 3396 arg("matrixpaletteindex", matrixpaletteindex); 3397 end(); 3398 mgl11Ext.glCurrentPaletteMatrixOES(matrixpaletteindex); 3399 checkError(); 3400 } 3401 3402 public void glLoadPaletteFromModelViewMatrixOES() { 3403 begin("glLoadPaletteFromModelViewMatrixOES"); 3404 end(); 3405 mgl11Ext.glLoadPaletteFromModelViewMatrixOES(); 3406 checkError(); 3407 } 3408 3409 public void glMatrixIndexPointerOES(int size, int type, int stride, 3410 Buffer pointer) { 3411 begin("glMatrixIndexPointerOES"); 3412 argPointer(size, type, stride, pointer); 3413 end(); 3414 mgl11Ext.glMatrixIndexPointerOES(size, type, stride, pointer); 3415 checkError(); 3416 } 3417 3418 public void glMatrixIndexPointerOES(int size, int type, int stride, 3419 int offset) { 3420 begin("glMatrixIndexPointerOES"); 3421 arg("size", size); 3422 arg("type", type); 3423 arg("stride", stride); 3424 arg("offset", offset); 3425 end(); 3426 mgl11Ext.glMatrixIndexPointerOES(size, type, stride, offset); 3427 checkError(); 3428 } 3429 3430 public void glWeightPointerOES(int size, int type, int stride, 3431 Buffer pointer) { 3432 begin("glWeightPointerOES"); 3433 argPointer(size, type, stride, pointer); 3434 end(); 3435 mgl11Ext.glWeightPointerOES(size, type, stride, pointer); 3436 checkError(); 3437 } 3438 3439 public void glWeightPointerOES(int size, int type, int stride, int offset) { 3440 begin("glWeightPointerOES"); 3441 arg("size", size); 3442 arg("type", type); 3443 arg("stride", stride); 3444 arg("offset", offset); 3445 end(); 3446 mgl11Ext.glWeightPointerOES(size, type, stride, offset); 3447 checkError(); 3448 } 3449 3450 @Override 3451 public void glBindFramebufferOES(int target, int framebuffer) { 3452 begin("glBindFramebufferOES"); 3453 arg("target", target); 3454 arg("framebuffer", framebuffer); 3455 end(); 3456 mgl11ExtensionPack.glBindFramebufferOES(target, framebuffer); 3457 checkError(); 3458 } 3459 3460 @Override 3461 public void glBindRenderbufferOES(int target, int renderbuffer) { 3462 begin("glBindRenderbufferOES"); 3463 arg("target", target); 3464 arg("renderbuffer", renderbuffer); 3465 end(); 3466 mgl11ExtensionPack.glBindRenderbufferOES(target, renderbuffer); 3467 checkError(); 3468 } 3469 3470 @Override 3471 public void glBlendEquation(int mode) { 3472 begin("glBlendEquation"); 3473 arg("mode", mode); 3474 end(); 3475 mgl11ExtensionPack.glBlendEquation(mode); 3476 checkError(); 3477 } 3478 3479 @Override 3480 public void glBlendEquationSeparate(int modeRGB, int modeAlpha) { 3481 begin("glBlendEquationSeparate"); 3482 arg("modeRGB", modeRGB); 3483 arg("modeAlpha", modeAlpha); 3484 end(); 3485 mgl11ExtensionPack.glBlendEquationSeparate(modeRGB, modeAlpha); 3486 checkError(); 3487 } 3488 3489 @Override 3490 public void glBlendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, 3491 int dstAlpha) { 3492 begin("glBlendFuncSeparate"); 3493 arg("srcRGB", srcRGB); 3494 arg("dstRGB", dstRGB); 3495 arg("srcAlpha", srcAlpha); 3496 arg("dstAlpha", dstAlpha); 3497 end(); 3498 mgl11ExtensionPack.glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); 3499 checkError(); 3500 } 3501 3502 @Override 3503 public int glCheckFramebufferStatusOES(int target) { 3504 begin("glCheckFramebufferStatusOES"); 3505 arg("target", target); 3506 end(); 3507 int result = mgl11ExtensionPack.glCheckFramebufferStatusOES(target); 3508 checkError(); 3509 return result; 3510 } 3511 3512 @Override 3513 public void glDeleteFramebuffersOES(int n, int[] framebuffers, int offset) { 3514 begin("glDeleteFramebuffersOES"); 3515 arg("n", n); 3516 arg("framebuffers", framebuffers.toString()); 3517 arg("offset", offset); 3518 end(); 3519 mgl11ExtensionPack.glDeleteFramebuffersOES(n, framebuffers, offset); 3520 checkError(); 3521 } 3522 3523 @Override 3524 public void glDeleteFramebuffersOES(int n, IntBuffer framebuffers) { 3525 begin("glDeleteFramebuffersOES"); 3526 arg("n", n); 3527 arg("framebuffers", framebuffers.toString()); 3528 end(); 3529 mgl11ExtensionPack.glDeleteFramebuffersOES(n, framebuffers); 3530 checkError(); 3531 } 3532 3533 @Override 3534 public void glDeleteRenderbuffersOES(int n, int[] renderbuffers, int offset) { 3535 begin("glDeleteRenderbuffersOES"); 3536 arg("n", n); 3537 arg("renderbuffers", renderbuffers.toString()); 3538 arg("offset", offset); 3539 end(); 3540 mgl11ExtensionPack.glDeleteRenderbuffersOES(n, renderbuffers, offset); 3541 checkError(); 3542 } 3543 3544 @Override 3545 public void glDeleteRenderbuffersOES(int n, IntBuffer renderbuffers) { 3546 begin("glDeleteRenderbuffersOES"); 3547 arg("n", n); 3548 arg("renderbuffers", renderbuffers.toString()); 3549 end(); 3550 mgl11ExtensionPack.glDeleteRenderbuffersOES(n, renderbuffers); 3551 checkError(); 3552 } 3553 3554 @Override 3555 public void glFramebufferRenderbufferOES(int target, int attachment, 3556 int renderbuffertarget, int renderbuffer) { 3557 begin("glFramebufferRenderbufferOES"); 3558 arg("target", target); 3559 arg("attachment", attachment); 3560 arg("renderbuffertarget", renderbuffertarget); 3561 arg("renderbuffer", renderbuffer); 3562 end(); 3563 mgl11ExtensionPack.glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer); 3564 checkError(); 3565 } 3566 3567 @Override 3568 public void glFramebufferTexture2DOES(int target, int attachment, 3569 int textarget, int texture, int level) { 3570 begin("glFramebufferTexture2DOES"); 3571 arg("target", target); 3572 arg("attachment", attachment); 3573 arg("textarget", textarget); 3574 arg("texture", texture); 3575 arg("level", level); 3576 end(); 3577 mgl11ExtensionPack.glFramebufferTexture2DOES(target, attachment, textarget, texture, level); 3578 checkError(); 3579 } 3580 3581 @Override 3582 public void glGenerateMipmapOES(int target) { 3583 begin("glGenerateMipmapOES"); 3584 arg("target", target); 3585 end(); 3586 mgl11ExtensionPack.glGenerateMipmapOES(target); 3587 checkError(); 3588 } 3589 3590 @Override 3591 public void glGenFramebuffersOES(int n, int[] framebuffers, int offset) { 3592 begin("glGenFramebuffersOES"); 3593 arg("n", n); 3594 arg("framebuffers", framebuffers.toString()); 3595 arg("offset", offset); 3596 end(); 3597 mgl11ExtensionPack.glGenFramebuffersOES(n, framebuffers, offset); 3598 checkError(); 3599 } 3600 3601 @Override 3602 public void glGenFramebuffersOES(int n, IntBuffer framebuffers) { 3603 begin("glGenFramebuffersOES"); 3604 arg("n", n); 3605 arg("framebuffers", framebuffers.toString()); 3606 end(); 3607 mgl11ExtensionPack.glGenFramebuffersOES(n, framebuffers); 3608 checkError(); 3609 } 3610 3611 @Override 3612 public void glGenRenderbuffersOES(int n, int[] renderbuffers, int offset) { 3613 begin("glGenRenderbuffersOES"); 3614 arg("n", n); 3615 arg("renderbuffers", renderbuffers.toString()); 3616 arg("offset", offset); 3617 end(); 3618 mgl11ExtensionPack.glGenRenderbuffersOES(n, renderbuffers, offset); 3619 checkError(); 3620 } 3621 3622 @Override 3623 public void glGenRenderbuffersOES(int n, IntBuffer renderbuffers) { 3624 begin("glGenRenderbuffersOES"); 3625 arg("n", n); 3626 arg("renderbuffers", renderbuffers.toString()); 3627 end(); 3628 mgl11ExtensionPack.glGenRenderbuffersOES(n, renderbuffers); 3629 checkError(); 3630 } 3631 3632 @Override 3633 public void glGetFramebufferAttachmentParameterivOES(int target, 3634 int attachment, int pname, int[] params, int offset) { 3635 begin("glGetFramebufferAttachmentParameterivOES"); 3636 arg("target", target); 3637 arg("attachment", attachment); 3638 arg("pname", pname); 3639 arg("params", params.toString()); 3640 arg("offset", offset); 3641 end(); 3642 mgl11ExtensionPack.glGetFramebufferAttachmentParameterivOES(target, attachment, pname, params, offset); 3643 checkError(); 3644 } 3645 3646 @Override 3647 public void glGetFramebufferAttachmentParameterivOES(int target, 3648 int attachment, int pname, IntBuffer params) { 3649 begin("glGetFramebufferAttachmentParameterivOES"); 3650 arg("target", target); 3651 arg("attachment", attachment); 3652 arg("pname", pname); 3653 arg("params", params.toString()); 3654 end(); 3655 mgl11ExtensionPack.glGetFramebufferAttachmentParameterivOES(target, attachment, pname, params); 3656 checkError(); 3657 } 3658 3659 @Override 3660 public void glGetRenderbufferParameterivOES(int target, int pname, 3661 int[] params, int offset) { 3662 begin("glGetRenderbufferParameterivOES"); 3663 arg("target", target); 3664 arg("pname", pname); 3665 arg("params", params.toString()); 3666 arg("offset", offset); 3667 end(); 3668 mgl11ExtensionPack.glGetRenderbufferParameterivOES(target, pname, params, offset); 3669 checkError(); 3670 } 3671 3672 @Override 3673 public void glGetRenderbufferParameterivOES(int target, int pname, 3674 IntBuffer params) { 3675 begin("glGetRenderbufferParameterivOES"); 3676 arg("target", target); 3677 arg("pname", pname); 3678 arg("params", params.toString()); 3679 end(); 3680 mgl11ExtensionPack.glGetRenderbufferParameterivOES(target, pname, params); 3681 checkError(); 3682 } 3683 3684 @Override 3685 public void glGetTexGenfv(int coord, int pname, float[] params, int offset) { 3686 begin("glGetTexGenfv"); 3687 arg("coord", coord); 3688 arg("pname", pname); 3689 arg("params", params.toString()); 3690 arg("offset", offset); 3691 end(); 3692 mgl11ExtensionPack.glGetTexGenfv(coord, pname, params, offset); 3693 checkError(); 3694 } 3695 3696 @Override 3697 public void glGetTexGenfv(int coord, int pname, FloatBuffer params) { 3698 begin("glGetTexGenfv"); 3699 arg("coord", coord); 3700 arg("pname", pname); 3701 arg("params", params.toString()); 3702 end(); 3703 mgl11ExtensionPack.glGetTexGenfv(coord, pname, params); 3704 checkError(); 3705 } 3706 3707 @Override 3708 public void glGetTexGeniv(int coord, int pname, int[] params, int offset) { 3709 begin("glGetTexGeniv"); 3710 arg("coord", coord); 3711 arg("pname", pname); 3712 arg("params", params.toString()); 3713 arg("offset", offset); 3714 end(); 3715 mgl11ExtensionPack.glGetTexGeniv(coord, pname, params, offset); 3716 checkError(); 3717 } 3718 3719 @Override 3720 public void glGetTexGeniv(int coord, int pname, IntBuffer params) { 3721 begin("glGetTexGeniv"); 3722 arg("coord", coord); 3723 arg("pname", pname); 3724 arg("params", params.toString()); 3725 end(); 3726 mgl11ExtensionPack.glGetTexGeniv(coord, pname, params); 3727 checkError(); 3728 } 3729 3730 @Override 3731 public void glGetTexGenxv(int coord, int pname, int[] params, int offset) { 3732 begin("glGetTexGenxv"); 3733 arg("coord", coord); 3734 arg("pname", pname); 3735 arg("params", params.toString()); 3736 arg("offset", offset); 3737 end(); 3738 mgl11ExtensionPack.glGetTexGenxv(coord, pname, params, offset); 3739 checkError(); 3740 } 3741 3742 @Override 3743 public void glGetTexGenxv(int coord, int pname, IntBuffer params) { 3744 begin("glGetTexGenxv"); 3745 arg("coord", coord); 3746 arg("pname", pname); 3747 arg("params", params.toString()); 3748 end(); 3749 mgl11ExtensionPack.glGetTexGenxv(coord, pname, params); 3750 checkError(); 3751 } 3752 3753 @Override 3754 public boolean glIsFramebufferOES(int framebuffer) { 3755 begin("glIsFramebufferOES"); 3756 arg("framebuffer", framebuffer); 3757 end(); 3758 boolean result = mgl11ExtensionPack.glIsFramebufferOES(framebuffer); 3759 checkError(); 3760 return result; 3761 } 3762 3763 @Override 3764 public boolean glIsRenderbufferOES(int renderbuffer) { 3765 begin("glIsRenderbufferOES"); 3766 arg("renderbuffer", renderbuffer); 3767 end(); 3768 mgl11ExtensionPack.glIsRenderbufferOES(renderbuffer); 3769 checkError(); 3770 return false; 3771 } 3772 3773 @Override 3774 public void glRenderbufferStorageOES(int target, int internalformat, 3775 int width, int height) { 3776 begin("glRenderbufferStorageOES"); 3777 arg("target", target); 3778 arg("internalformat", internalformat); 3779 arg("width", width); 3780 arg("height", height); 3781 end(); 3782 mgl11ExtensionPack.glRenderbufferStorageOES(target, internalformat, width, height); 3783 checkError(); 3784 } 3785 3786 @Override 3787 public void glTexGenf(int coord, int pname, float param) { 3788 begin("glTexGenf"); 3789 arg("coord", coord); 3790 arg("pname", pname); 3791 arg("param", param); 3792 end(); 3793 mgl11ExtensionPack.glTexGenf(coord, pname, param); 3794 checkError(); 3795 } 3796 3797 @Override 3798 public void glTexGenfv(int coord, int pname, float[] params, int offset) { 3799 begin("glTexGenfv"); 3800 arg("coord", coord); 3801 arg("pname", pname); 3802 arg("params", params.toString()); 3803 arg("offset", offset); 3804 end(); 3805 mgl11ExtensionPack.glTexGenfv(coord, pname, params, offset); 3806 checkError(); 3807 } 3808 3809 @Override 3810 public void glTexGenfv(int coord, int pname, FloatBuffer params) { 3811 begin("glTexGenfv"); 3812 arg("coord", coord); 3813 arg("pname", pname); 3814 arg("params", params.toString()); 3815 end(); 3816 mgl11ExtensionPack.glTexGenfv(coord, pname, params); 3817 checkError(); 3818 } 3819 3820 @Override 3821 public void glTexGeni(int coord, int pname, int param) { 3822 begin("glTexGeni"); 3823 arg("coord", coord); 3824 arg("pname", pname); 3825 arg("param", param); 3826 end(); 3827 mgl11ExtensionPack.glTexGeni(coord, pname, param); 3828 checkError(); 3829 } 3830 3831 @Override 3832 public void glTexGeniv(int coord, int pname, int[] params, int offset) { 3833 begin("glTexGeniv"); 3834 arg("coord", coord); 3835 arg("pname", pname); 3836 arg("params", params.toString()); 3837 arg("offset", offset); 3838 end(); 3839 mgl11ExtensionPack.glTexGeniv(coord, pname, params, offset); 3840 checkError(); 3841 } 3842 3843 @Override 3844 public void glTexGeniv(int coord, int pname, IntBuffer params) { 3845 begin("glTexGeniv"); 3846 arg("coord", coord); 3847 arg("pname", pname); 3848 arg("params", params.toString()); 3849 end(); 3850 mgl11ExtensionPack.glTexGeniv(coord, pname, params); 3851 checkError(); 3852 } 3853 3854 @Override 3855 public void glTexGenx(int coord, int pname, int param) { 3856 begin("glTexGenx"); 3857 arg("coord", coord); 3858 arg("pname", pname); 3859 arg("param", param); 3860 end(); 3861 mgl11ExtensionPack.glTexGenx(coord, pname, param); 3862 checkError(); 3863 } 3864 3865 @Override 3866 public void glTexGenxv(int coord, int pname, int[] params, int offset) { 3867 begin("glTexGenxv"); 3868 arg("coord", coord); 3869 arg("pname", pname); 3870 arg("params", params.toString()); 3871 arg("offset", offset); 3872 end(); 3873 mgl11ExtensionPack.glTexGenxv(coord, pname, params, offset); 3874 checkError(); 3875 } 3876 3877 @Override 3878 public void glTexGenxv(int coord, int pname, IntBuffer params) { 3879 begin("glTexGenxv"); 3880 arg("coord", coord); 3881 arg("pname", pname); 3882 arg("params", params.toString()); 3883 end(); 3884 mgl11ExtensionPack.glTexGenxv(coord, pname, params); 3885 checkError(); 3886 } 3887 3888 private class PointerInfo { 3889 /** 3890 * The number of coordinates per vertex. 1..4 3891 */ 3892 public int mSize; 3893 /** 3894 * The type of each coordinate. 3895 */ 3896 public int mType; 3897 /** 3898 * The byte offset between consecutive vertices. 0 means mSize * 3899 * sizeof(mType) 3900 */ 3901 public int mStride; 3902 public Buffer mPointer; 3903 public ByteBuffer mTempByteBuffer; // Only valid during glDrawXXX calls 3904 3905 public PointerInfo() { 3906 } 3907 3908 public PointerInfo(int size, int type, int stride, Buffer pointer) { 3909 mSize = size; 3910 mType = type; 3911 mStride = stride; 3912 mPointer = pointer; 3913 } 3914 3915 public int sizeof(int type) { 3916 switch (type) { 3917 case GL_UNSIGNED_BYTE: 3918 return 1; 3919 case GL_BYTE: 3920 return 1; 3921 case GL_SHORT: 3922 return 2; 3923 case GL_FIXED: 3924 return 4; 3925 case GL_FLOAT: 3926 return 4; 3927 default: 3928 return 0; 3929 } 3930 } 3931 3932 public int getStride() { 3933 return mStride > 0 ? mStride : sizeof(mType) * mSize; 3934 } 3935 3936 public void bindByteBuffer() { 3937 mTempByteBuffer = mPointer == null ? null : toByteBuffer(-1, mPointer); 3938 } 3939 3940 public void unbindByteBuffer() { 3941 mTempByteBuffer = null; 3942 } 3943 } 3944 3945 private Writer mLog; 3946 private boolean mLogArgumentNames; 3947 private int mArgCount; 3948 3949 private PointerInfo mColorPointer = new PointerInfo(); 3950 private PointerInfo mNormalPointer = new PointerInfo(); 3951 private PointerInfo mTexCoordPointer = new PointerInfo(); 3952 private PointerInfo mVertexPointer = new PointerInfo(); 3953 3954 boolean mColorArrayEnabled; 3955 boolean mNormalArrayEnabled; 3956 boolean mTextureCoordArrayEnabled; 3957 boolean mVertexArrayEnabled; 3958 3959 StringBuilder mStringBuilder; 3960 } 3961