GLLogWrapper.java revision d70213e70ed4b2648d696a554a0ba7dac4c32757 
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
17package android.opengl;
18
19import java.io.IOException;
20import java.io.Writer;
21import java.nio.Buffer;
22import java.nio.ByteBuffer;
23import java.nio.ByteOrder;
24import java.nio.CharBuffer;
25import java.nio.DoubleBuffer;
26import java.nio.FloatBuffer;
27import java.nio.IntBuffer;
28import java.nio.LongBuffer;
29import java.nio.ShortBuffer;
30import java.util.Arrays;
31
32import javax.microedition.khronos.opengles.GL;
33
34/**
35 * A wrapper that logs all GL calls (and results) in human-readable form.
36 *
37 */
38class 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            if (convertWholeBuffer) {
936                byteCount = input2.limit();
937            }
938            result = ByteBuffer.allocate(byteCount).order(input2.order());
939            int position = input2.position();
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            if (convertWholeBuffer) {
947                byteCount = input2.limit() * 2;
948            }
949            result = ByteBuffer.allocate(byteCount).order(input2.order());
950            CharBuffer result2 = result.asCharBuffer();
951            int position = input2.position();
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            if (convertWholeBuffer) {
959                byteCount = input2.limit() * 2;
960            }
961            result = ByteBuffer.allocate(byteCount).order(input2.order());
962            ShortBuffer result2 = result.asShortBuffer();
963            int position = input2.position();
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            if (convertWholeBuffer) {
971                byteCount = input2.limit() * 4;
972            }
973            result = ByteBuffer.allocate(byteCount).order(input2.order());
974            IntBuffer result2 = result.asIntBuffer();
975            int position = input2.position();
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            if (convertWholeBuffer) {
983                byteCount = input2.limit() * 4;
984            }
985            result = ByteBuffer.allocate(byteCount).order(input2.order());
986            FloatBuffer result2 = result.asFloatBuffer();
987            int position = input2.position();
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            if (convertWholeBuffer) {
995                byteCount = input2.limit() * 8;
996            }
997            result = ByteBuffer.allocate(byteCount).order(input2.order());
998            DoubleBuffer result2 = result.asDoubleBuffer();
999            int position = input2.position();
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            if (convertWholeBuffer) {
1007                byteCount = input2.limit() * 8;
1008            }
1009            result = ByteBuffer.allocate(byteCount).order(input2.order());
1010            LongBuffer result2 = result.asLongBuffer();
1011            int position = input2.position();
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) {
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    private class PointerInfo {
3451        /**
3452         * The number of coordinates per vertex. 1..4
3453         */
3454        public int mSize;
3455        /**
3456         * The type of each coordinate.
3457         */
3458        public int mType;
3459        /**
3460         * The byte offset between consecutive vertices. 0 means mSize *
3461         * sizeof(mType)
3462         */
3463        public int mStride;
3464        public Buffer mPointer;
3465        public ByteBuffer mTempByteBuffer; // Only valid during glDrawXXX calls
3466
3467        public PointerInfo(int size, int type, int stride, Buffer pointer) {
3468            mSize = size;
3469            mType = type;
3470            mStride = stride;
3471            mPointer = pointer;
3472        }
3473
3474        public int sizeof(int type) {
3475            switch (type) {
3476            case GL_UNSIGNED_BYTE:
3477                return 1;
3478            case GL_BYTE:
3479                return 1;
3480            case GL_SHORT:
3481                return 2;
3482            case GL_FIXED:
3483                return 4;
3484            case GL_FLOAT:
3485                return 4;
3486            default:
3487                return 0;
3488            }
3489        }
3490
3491        public int getStride() {
3492            return mStride > 0 ? mStride : sizeof(mType) * mSize;
3493        }
3494
3495        public void bindByteBuffer() {
3496            mTempByteBuffer = toByteBuffer(-1, mPointer);
3497        }
3498
3499        public void unbindByteBuffer() {
3500            mTempByteBuffer = null;
3501        }
3502    }
3503
3504    private Writer mLog;
3505    private boolean mLogArgumentNames;
3506    private int mArgCount;
3507
3508    private PointerInfo mColorPointer;
3509    private PointerInfo mNormalPointer;
3510    private PointerInfo mTexCoordPointer;
3511    private PointerInfo mVertexPointer;
3512
3513    boolean mColorArrayEnabled;
3514    boolean mNormalArrayEnabled;
3515    boolean mTextureCoordArrayEnabled;
3516    boolean mVertexArrayEnabled;
3517
3518    StringBuilder mStringBuilder;
3519}
3520