29406daf21
Allows calling GL11ExtensionPack APIs in a GL context that has been wrapped for debugging. Change-Id: Ib0695b51a92f5dcce32db8b0dc7ee948e5059e7f
3961 lines
112 KiB
Java
3961 lines
112 KiB
Java
/*
|
|
* Copyright (C) 2007 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package android.opengl;
|
|
|
|
import java.io.IOException;
|
|
import java.io.Writer;
|
|
import java.nio.Buffer;
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.ByteOrder;
|
|
import java.nio.CharBuffer;
|
|
import java.nio.DoubleBuffer;
|
|
import java.nio.FloatBuffer;
|
|
import java.nio.IntBuffer;
|
|
import java.nio.LongBuffer;
|
|
import java.nio.ShortBuffer;
|
|
import java.util.Arrays;
|
|
|
|
import javax.microedition.khronos.opengles.GL;
|
|
|
|
/**
|
|
* A wrapper that logs all GL calls (and results) in human-readable form.
|
|
*
|
|
*/
|
|
class GLLogWrapper extends GLWrapperBase {
|
|
private static final int FORMAT_INT = 0;
|
|
private static final int FORMAT_FLOAT = 1;
|
|
private static final int FORMAT_FIXED = 2;
|
|
|
|
public GLLogWrapper(GL gl, Writer log, boolean logArgumentNames) {
|
|
super(gl);
|
|
mLog = log;
|
|
mLogArgumentNames = logArgumentNames;
|
|
}
|
|
|
|
private void checkError() {
|
|
int glError;
|
|
if ((glError = mgl.glGetError()) != 0) {
|
|
String errorMessage = "glError: " + Integer.toString(glError);
|
|
logLine(errorMessage);
|
|
}
|
|
}
|
|
|
|
private void logLine(String message) {
|
|
log(message + '\n');
|
|
}
|
|
|
|
private void log(String message) {
|
|
try {
|
|
mLog.write(message);
|
|
} catch (IOException e) {
|
|
// Ignore exception, keep on trying
|
|
}
|
|
}
|
|
|
|
private void begin(String name) {
|
|
log(name + '(');
|
|
mArgCount = 0;
|
|
}
|
|
|
|
private void arg(String name, String value) {
|
|
if (mArgCount++ > 0) {
|
|
log(", ");
|
|
}
|
|
if (mLogArgumentNames) {
|
|
log(name + "=");
|
|
}
|
|
log(value);
|
|
}
|
|
|
|
private void end() {
|
|
log(");\n");
|
|
flush();
|
|
}
|
|
|
|
private void flush() {
|
|
try {
|
|
mLog.flush();
|
|
} catch (IOException e) {
|
|
mLog = null;
|
|
}
|
|
}
|
|
|
|
private void arg(String name, boolean value) {
|
|
arg(name, Boolean.toString(value));
|
|
}
|
|
|
|
private void arg(String name, int value) {
|
|
arg(name, Integer.toString(value));
|
|
}
|
|
|
|
private void arg(String name, float value) {
|
|
arg(name, Float.toString(value));
|
|
}
|
|
|
|
private void returns(String result) {
|
|
log(") returns " + result + ";\n");
|
|
flush();
|
|
}
|
|
|
|
private void returns(int result) {
|
|
returns(Integer.toString(result));
|
|
}
|
|
|
|
private void arg(String name, int n, int[] arr, int offset) {
|
|
arg(name, toString(n, FORMAT_INT, arr, offset));
|
|
}
|
|
|
|
private void arg(String name, int n, short[] arr, int offset) {
|
|
arg(name, toString(n, arr, offset));
|
|
}
|
|
|
|
private void arg(String name, int n, float[] arr, int offset) {
|
|
arg(name, toString(n, arr, offset));
|
|
}
|
|
|
|
private void formattedAppend(StringBuilder buf, int value, int format) {
|
|
switch (format) {
|
|
case FORMAT_INT:
|
|
buf.append(value);
|
|
break;
|
|
case FORMAT_FLOAT:
|
|
buf.append(Float.intBitsToFloat(value));
|
|
break;
|
|
case FORMAT_FIXED:
|
|
buf.append(value / 65536.0f);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private String toString(int n, int format, int[] arr, int offset) {
|
|
StringBuilder buf = new StringBuilder();
|
|
buf.append("{\n");
|
|
int arrLen = arr.length;
|
|
for (int i = 0; i < n; i++) {
|
|
int index = offset + i;
|
|
buf.append(" [" + index + "] = ");
|
|
if (index < 0 || index >= arrLen) {
|
|
buf.append("out of bounds");
|
|
} else {
|
|
formattedAppend(buf, arr[index], format);
|
|
}
|
|
buf.append('\n');
|
|
}
|
|
buf.append("}");
|
|
return buf.toString();
|
|
}
|
|
|
|
private String toString(int n, short[] arr, int offset) {
|
|
StringBuilder buf = new StringBuilder();
|
|
buf.append("{\n");
|
|
int arrLen = arr.length;
|
|
for (int i = 0; i < n; i++) {
|
|
int index = offset + i;
|
|
buf.append(" [" + index + "] = ");
|
|
if (index < 0 || index >= arrLen) {
|
|
buf.append("out of bounds");
|
|
} else {
|
|
buf.append(arr[index]);
|
|
}
|
|
buf.append('\n');
|
|
}
|
|
buf.append("}");
|
|
return buf.toString();
|
|
}
|
|
|
|
private String toString(int n, float[] arr, int offset) {
|
|
StringBuilder buf = new StringBuilder();
|
|
buf.append("{\n");
|
|
int arrLen = arr.length;
|
|
for (int i = 0; i < n; i++) {
|
|
int index = offset + i;
|
|
buf.append("[" + index + "] = ");
|
|
if (index < 0 || index >= arrLen) {
|
|
buf.append("out of bounds");
|
|
} else {
|
|
buf.append(arr[index]);
|
|
}
|
|
buf.append('\n');
|
|
}
|
|
buf.append("}");
|
|
return buf.toString();
|
|
}
|
|
|
|
private String toString(int n, FloatBuffer buf) {
|
|
StringBuilder builder = new StringBuilder();
|
|
builder.append("{\n");
|
|
for (int i = 0; i < n; i++) {
|
|
builder.append(" [" + i + "] = " + buf.get(i) + '\n');
|
|
}
|
|
builder.append("}");
|
|
return builder.toString();
|
|
}
|
|
|
|
private String toString(int n, int format, IntBuffer buf) {
|
|
StringBuilder builder = new StringBuilder();
|
|
builder.append("{\n");
|
|
for (int i = 0; i < n; i++) {
|
|
builder.append(" [" + i + "] = ");
|
|
formattedAppend(builder, buf.get(i), format);
|
|
builder.append('\n');
|
|
}
|
|
builder.append("}");
|
|
return builder.toString();
|
|
}
|
|
|
|
private String toString(int n, ShortBuffer buf) {
|
|
StringBuilder builder = new StringBuilder();
|
|
builder.append("{\n");
|
|
for (int i = 0; i < n; i++) {
|
|
builder.append(" [" + i + "] = " + buf.get(i) + '\n');
|
|
}
|
|
builder.append("}");
|
|
return builder.toString();
|
|
}
|
|
|
|
private void arg(String name, int n, FloatBuffer buf) {
|
|
arg(name, toString(n, buf));
|
|
}
|
|
|
|
private void arg(String name, int n, IntBuffer buf) {
|
|
arg(name, toString(n, FORMAT_INT, buf));
|
|
}
|
|
|
|
private void arg(String name, int n, ShortBuffer buf) {
|
|
arg(name, toString(n, buf));
|
|
}
|
|
|
|
private void argPointer(int size, int type, int stride, Buffer pointer) {
|
|
arg("size", size);
|
|
arg("type", getPointerTypeName(type));
|
|
arg("stride", stride);
|
|
arg("pointer", pointer.toString());
|
|
}
|
|
|
|
private static String getHex(int value) {
|
|
return "0x" + Integer.toHexString(value);
|
|
}
|
|
|
|
public static String getErrorString(int error) {
|
|
switch (error) {
|
|
case GL_NO_ERROR:
|
|
return "GL_NO_ERROR";
|
|
case GL_INVALID_ENUM:
|
|
return "GL_INVALID_ENUM";
|
|
case GL_INVALID_VALUE:
|
|
return "GL_INVALID_VALUE";
|
|
case GL_INVALID_OPERATION:
|
|
return "GL_INVALID_OPERATION";
|
|
case GL_STACK_OVERFLOW:
|
|
return "GL_STACK_OVERFLOW";
|
|
case GL_STACK_UNDERFLOW:
|
|
return "GL_STACK_UNDERFLOW";
|
|
case GL_OUT_OF_MEMORY:
|
|
return "GL_OUT_OF_MEMORY";
|
|
default:
|
|
return getHex(error);
|
|
}
|
|
}
|
|
|
|
private String getClearBufferMask(int mask) {
|
|
StringBuilder b = new StringBuilder();
|
|
if ((mask & GL_DEPTH_BUFFER_BIT) != 0) {
|
|
b.append("GL_DEPTH_BUFFER_BIT");
|
|
mask &= ~GL_DEPTH_BUFFER_BIT;
|
|
}
|
|
if ((mask & GL_STENCIL_BUFFER_BIT) != 0) {
|
|
if (b.length() > 0) {
|
|
b.append(" | ");
|
|
}
|
|
b.append("GL_STENCIL_BUFFER_BIT");
|
|
mask &= ~GL_STENCIL_BUFFER_BIT;
|
|
}
|
|
if ((mask & GL_COLOR_BUFFER_BIT) != 0) {
|
|
if (b.length() > 0) {
|
|
b.append(" | ");
|
|
}
|
|
b.append("GL_COLOR_BUFFER_BIT");
|
|
mask &= ~GL_COLOR_BUFFER_BIT;
|
|
}
|
|
if (mask != 0) {
|
|
if (b.length() > 0) {
|
|
b.append(" | ");
|
|
}
|
|
b.append(getHex(mask));
|
|
}
|
|
return b.toString();
|
|
}
|
|
|
|
private String getFactor(int factor) {
|
|
switch(factor) {
|
|
case GL_ZERO:
|
|
return "GL_ZERO";
|
|
case GL_ONE:
|
|
return "GL_ONE";
|
|
case GL_SRC_COLOR:
|
|
return "GL_SRC_COLOR";
|
|
case GL_ONE_MINUS_SRC_COLOR:
|
|
return "GL_ONE_MINUS_SRC_COLOR";
|
|
case GL_DST_COLOR:
|
|
return "GL_DST_COLOR";
|
|
case GL_ONE_MINUS_DST_COLOR:
|
|
return "GL_ONE_MINUS_DST_COLOR";
|
|
case GL_SRC_ALPHA:
|
|
return "GL_SRC_ALPHA";
|
|
case GL_ONE_MINUS_SRC_ALPHA:
|
|
return "GL_ONE_MINUS_SRC_ALPHA";
|
|
case GL_DST_ALPHA:
|
|
return "GL_DST_ALPHA";
|
|
case GL_ONE_MINUS_DST_ALPHA:
|
|
return "GL_ONE_MINUS_DST_ALPHA";
|
|
case GL_SRC_ALPHA_SATURATE:
|
|
return "GL_SRC_ALPHA_SATURATE";
|
|
|
|
default:
|
|
return getHex(factor);
|
|
}
|
|
}
|
|
|
|
private String getShadeModel(int model) {
|
|
switch(model) {
|
|
case GL_FLAT:
|
|
return "GL_FLAT";
|
|
case GL_SMOOTH:
|
|
return "GL_SMOOTH";
|
|
default:
|
|
return getHex(model);
|
|
}
|
|
}
|
|
|
|
private String getTextureTarget(int target) {
|
|
switch (target) {
|
|
case GL_TEXTURE_2D:
|
|
return "GL_TEXTURE_2D";
|
|
default:
|
|
return getHex(target);
|
|
}
|
|
}
|
|
|
|
private String getTextureEnvTarget(int target) {
|
|
switch (target) {
|
|
case GL_TEXTURE_ENV:
|
|
return "GL_TEXTURE_ENV";
|
|
default:
|
|
return getHex(target);
|
|
}
|
|
}
|
|
|
|
private String getTextureEnvPName(int pname) {
|
|
switch (pname) {
|
|
case GL_TEXTURE_ENV_MODE:
|
|
return "GL_TEXTURE_ENV_MODE";
|
|
case GL_TEXTURE_ENV_COLOR:
|
|
return "GL_TEXTURE_ENV_COLOR";
|
|
default:
|
|
return getHex(pname);
|
|
}
|
|
}
|
|
|
|
private int getTextureEnvParamCount(int pname) {
|
|
switch (pname) {
|
|
case GL_TEXTURE_ENV_MODE:
|
|
return 1;
|
|
case GL_TEXTURE_ENV_COLOR:
|
|
return 4;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private String getTextureEnvParamName(float param) {
|
|
int iparam = (int) param;
|
|
if (param == (float) iparam) {
|
|
switch (iparam) {
|
|
case GL_REPLACE:
|
|
return "GL_REPLACE";
|
|
case GL_MODULATE:
|
|
return "GL_MODULATE";
|
|
case GL_DECAL:
|
|
return "GL_DECAL";
|
|
case GL_BLEND:
|
|
return "GL_BLEND";
|
|
case GL_ADD:
|
|
return "GL_ADD";
|
|
case GL_COMBINE:
|
|
return "GL_COMBINE";
|
|
default:
|
|
return getHex(iparam);
|
|
}
|
|
}
|
|
return Float.toString(param);
|
|
}
|
|
|
|
private String getMatrixMode(int matrixMode) {
|
|
switch (matrixMode) {
|
|
case GL_MODELVIEW:
|
|
return "GL_MODELVIEW";
|
|
case GL_PROJECTION:
|
|
return "GL_PROJECTION";
|
|
case GL_TEXTURE:
|
|
return "GL_TEXTURE";
|
|
default:
|
|
return getHex(matrixMode);
|
|
}
|
|
}
|
|
|
|
private String getClientState(int clientState) {
|
|
switch (clientState) {
|
|
case GL_COLOR_ARRAY:
|
|
return "GL_COLOR_ARRAY";
|
|
case GL_VERTEX_ARRAY:
|
|
return "GL_VERTEX_ARRAY";
|
|
case GL_NORMAL_ARRAY:
|
|
return "GL_NORMAL_ARRAY";
|
|
case GL_TEXTURE_COORD_ARRAY:
|
|
return "GL_TEXTURE_COORD_ARRAY";
|
|
default:
|
|
return getHex(clientState);
|
|
}
|
|
}
|
|
|
|
private String getCap(int cap) {
|
|
switch (cap) {
|
|
case GL_FOG:
|
|
return "GL_FOG";
|
|
case GL_LIGHTING:
|
|
return "GL_LIGHTING";
|
|
case GL_TEXTURE_2D:
|
|
return "GL_TEXTURE_2D";
|
|
case GL_CULL_FACE:
|
|
return "GL_CULL_FACE";
|
|
case GL_ALPHA_TEST:
|
|
return "GL_ALPHA_TEST";
|
|
case GL_BLEND:
|
|
return "GL_BLEND";
|
|
case GL_COLOR_LOGIC_OP:
|
|
return "GL_COLOR_LOGIC_OP";
|
|
case GL_DITHER:
|
|
return "GL_DITHER";
|
|
case GL_STENCIL_TEST:
|
|
return "GL_STENCIL_TEST";
|
|
case GL_DEPTH_TEST:
|
|
return "GL_DEPTH_TEST";
|
|
case GL_LIGHT0:
|
|
return "GL_LIGHT0";
|
|
case GL_LIGHT1:
|
|
return "GL_LIGHT1";
|
|
case GL_LIGHT2:
|
|
return "GL_LIGHT2";
|
|
case GL_LIGHT3:
|
|
return "GL_LIGHT3";
|
|
case GL_LIGHT4:
|
|
return "GL_LIGHT4";
|
|
case GL_LIGHT5:
|
|
return "GL_LIGHT5";
|
|
case GL_LIGHT6:
|
|
return "GL_LIGHT6";
|
|
case GL_LIGHT7:
|
|
return "GL_LIGHT7";
|
|
case GL_POINT_SMOOTH:
|
|
return "GL_POINT_SMOOTH";
|
|
case GL_LINE_SMOOTH:
|
|
return "GL_LINE_SMOOTH";
|
|
case GL_COLOR_MATERIAL:
|
|
return "GL_COLOR_MATERIAL";
|
|
case GL_NORMALIZE:
|
|
return "GL_NORMALIZE";
|
|
case GL_RESCALE_NORMAL:
|
|
return "GL_RESCALE_NORMAL";
|
|
case GL_VERTEX_ARRAY:
|
|
return "GL_VERTEX_ARRAY";
|
|
case GL_NORMAL_ARRAY:
|
|
return "GL_NORMAL_ARRAY";
|
|
case GL_COLOR_ARRAY:
|
|
return "GL_COLOR_ARRAY";
|
|
case GL_TEXTURE_COORD_ARRAY:
|
|
return "GL_TEXTURE_COORD_ARRAY";
|
|
case GL_MULTISAMPLE:
|
|
return "GL_MULTISAMPLE";
|
|
case GL_SAMPLE_ALPHA_TO_COVERAGE:
|
|
return "GL_SAMPLE_ALPHA_TO_COVERAGE";
|
|
case GL_SAMPLE_ALPHA_TO_ONE:
|
|
return "GL_SAMPLE_ALPHA_TO_ONE";
|
|
case GL_SAMPLE_COVERAGE:
|
|
return "GL_SAMPLE_COVERAGE";
|
|
case GL_SCISSOR_TEST:
|
|
return "GL_SCISSOR_TEST";
|
|
default:
|
|
return getHex(cap);
|
|
}
|
|
}
|
|
|
|
private String getTexturePName(int pname) {
|
|
switch (pname) {
|
|
case GL_TEXTURE_MAG_FILTER:
|
|
return "GL_TEXTURE_MAG_FILTER";
|
|
case GL_TEXTURE_MIN_FILTER:
|
|
return "GL_TEXTURE_MIN_FILTER";
|
|
case GL_TEXTURE_WRAP_S:
|
|
return "GL_TEXTURE_WRAP_S";
|
|
case GL_TEXTURE_WRAP_T:
|
|
return "GL_TEXTURE_WRAP_T";
|
|
case GL_GENERATE_MIPMAP:
|
|
return "GL_GENERATE_MIPMAP";
|
|
case GL_TEXTURE_CROP_RECT_OES:
|
|
return "GL_TEXTURE_CROP_RECT_OES";
|
|
default:
|
|
return getHex(pname);
|
|
}
|
|
}
|
|
|
|
private String getTextureParamName(float param) {
|
|
int iparam = (int) param;
|
|
if (param == (float) iparam) {
|
|
switch (iparam) {
|
|
case GL_CLAMP_TO_EDGE:
|
|
return "GL_CLAMP_TO_EDGE";
|
|
case GL_REPEAT:
|
|
return "GL_REPEAT";
|
|
case GL_NEAREST:
|
|
return "GL_NEAREST";
|
|
case GL_LINEAR:
|
|
return "GL_LINEAR";
|
|
case GL_NEAREST_MIPMAP_NEAREST:
|
|
return "GL_NEAREST_MIPMAP_NEAREST";
|
|
case GL_LINEAR_MIPMAP_NEAREST:
|
|
return "GL_LINEAR_MIPMAP_NEAREST";
|
|
case GL_NEAREST_MIPMAP_LINEAR:
|
|
return "GL_NEAREST_MIPMAP_LINEAR";
|
|
case GL_LINEAR_MIPMAP_LINEAR:
|
|
return "GL_LINEAR_MIPMAP_LINEAR";
|
|
default:
|
|
return getHex(iparam);
|
|
}
|
|
}
|
|
return Float.toString(param);
|
|
}
|
|
|
|
private String getFogPName(int pname) {
|
|
switch (pname) {
|
|
case GL_FOG_DENSITY:
|
|
return "GL_FOG_DENSITY";
|
|
case GL_FOG_START:
|
|
return "GL_FOG_START";
|
|
case GL_FOG_END:
|
|
return "GL_FOG_END";
|
|
case GL_FOG_MODE:
|
|
return "GL_FOG_MODE";
|
|
case GL_FOG_COLOR:
|
|
return "GL_FOG_COLOR";
|
|
default:
|
|
return getHex(pname);
|
|
}
|
|
}
|
|
|
|
private int getFogParamCount(int pname) {
|
|
switch (pname) {
|
|
case GL_FOG_DENSITY:
|
|
return 1;
|
|
case GL_FOG_START:
|
|
return 1;
|
|
case GL_FOG_END:
|
|
return 1;
|
|
case GL_FOG_MODE:
|
|
return 1;
|
|
case GL_FOG_COLOR:
|
|
return 4;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private String getBeginMode(int mode) {
|
|
switch (mode) {
|
|
case GL_POINTS:
|
|
return "GL_POINTS";
|
|
case GL_LINES:
|
|
return "GL_LINES";
|
|
case GL_LINE_LOOP:
|
|
return "GL_LINE_LOOP";
|
|
case GL_LINE_STRIP:
|
|
return "GL_LINE_STRIP";
|
|
case GL_TRIANGLES:
|
|
return "GL_TRIANGLES";
|
|
case GL_TRIANGLE_STRIP:
|
|
return "GL_TRIANGLE_STRIP";
|
|
case GL_TRIANGLE_FAN:
|
|
return "GL_TRIANGLE_FAN";
|
|
default:
|
|
return getHex(mode);
|
|
}
|
|
}
|
|
|
|
private String getIndexType(int type) {
|
|
switch (type) {
|
|
case GL_UNSIGNED_SHORT:
|
|
return "GL_UNSIGNED_SHORT";
|
|
case GL_UNSIGNED_BYTE:
|
|
return "GL_UNSIGNED_BYTE";
|
|
default:
|
|
return getHex(type);
|
|
}
|
|
}
|
|
|
|
private String getIntegerStateName(int pname) {
|
|
switch (pname) {
|
|
case GL_ALPHA_BITS:
|
|
return "GL_ALPHA_BITS";
|
|
case GL_ALIASED_LINE_WIDTH_RANGE:
|
|
return "GL_ALIASED_LINE_WIDTH_RANGE";
|
|
case GL_ALIASED_POINT_SIZE_RANGE:
|
|
return "GL_ALIASED_POINT_SIZE_RANGE";
|
|
case GL_BLUE_BITS:
|
|
return "GL_BLUE_BITS";
|
|
case GL_COMPRESSED_TEXTURE_FORMATS:
|
|
return "GL_COMPRESSED_TEXTURE_FORMATS";
|
|
case GL_DEPTH_BITS:
|
|
return "GL_DEPTH_BITS";
|
|
case GL_GREEN_BITS:
|
|
return "GL_GREEN_BITS";
|
|
case GL_MAX_ELEMENTS_INDICES:
|
|
return "GL_MAX_ELEMENTS_INDICES";
|
|
case GL_MAX_ELEMENTS_VERTICES:
|
|
return "GL_MAX_ELEMENTS_VERTICES";
|
|
case GL_MAX_LIGHTS:
|
|
return "GL_MAX_LIGHTS";
|
|
case GL_MAX_TEXTURE_SIZE:
|
|
return "GL_MAX_TEXTURE_SIZE";
|
|
case GL_MAX_VIEWPORT_DIMS:
|
|
return "GL_MAX_VIEWPORT_DIMS";
|
|
case GL_MAX_MODELVIEW_STACK_DEPTH:
|
|
return "GL_MAX_MODELVIEW_STACK_DEPTH";
|
|
case GL_MAX_PROJECTION_STACK_DEPTH:
|
|
return "GL_MAX_PROJECTION_STACK_DEPTH";
|
|
case GL_MAX_TEXTURE_STACK_DEPTH:
|
|
return "GL_MAX_TEXTURE_STACK_DEPTH";
|
|
case GL_MAX_TEXTURE_UNITS:
|
|
return "GL_MAX_TEXTURE_UNITS";
|
|
case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
|
|
return "GL_NUM_COMPRESSED_TEXTURE_FORMATS";
|
|
case GL_RED_BITS:
|
|
return "GL_RED_BITS";
|
|
case GL_SMOOTH_LINE_WIDTH_RANGE:
|
|
return "GL_SMOOTH_LINE_WIDTH_RANGE";
|
|
case GL_SMOOTH_POINT_SIZE_RANGE:
|
|
return "GL_SMOOTH_POINT_SIZE_RANGE";
|
|
case GL_STENCIL_BITS:
|
|
return "GL_STENCIL_BITS";
|
|
case GL_SUBPIXEL_BITS:
|
|
return "GL_SUBPIXEL_BITS";
|
|
|
|
case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:
|
|
return "GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES";
|
|
case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:
|
|
return "GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES";
|
|
case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:
|
|
return "GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES";
|
|
|
|
default:
|
|
return getHex(pname);
|
|
}
|
|
}
|
|
|
|
private int getIntegerStateSize(int pname) {
|
|
switch (pname) {
|
|
case GL_ALPHA_BITS:
|
|
return 1;
|
|
case GL_ALIASED_LINE_WIDTH_RANGE:
|
|
return 2;
|
|
case GL_ALIASED_POINT_SIZE_RANGE:
|
|
return 2;
|
|
case GL_BLUE_BITS:
|
|
return 1;
|
|
case GL_COMPRESSED_TEXTURE_FORMATS:
|
|
// Have to ask the implementation for the size
|
|
{
|
|
int[] buffer = new int[1];
|
|
mgl.glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, buffer, 0);
|
|
return buffer[0];
|
|
}
|
|
case GL_DEPTH_BITS:
|
|
return 1;
|
|
case GL_GREEN_BITS:
|
|
return 1;
|
|
case GL_MAX_ELEMENTS_INDICES:
|
|
return 1;
|
|
case GL_MAX_ELEMENTS_VERTICES:
|
|
return 1;
|
|
case GL_MAX_LIGHTS:
|
|
return 1;
|
|
case GL_MAX_TEXTURE_SIZE:
|
|
return 1;
|
|
case GL_MAX_VIEWPORT_DIMS:
|
|
return 2;
|
|
case GL_MAX_MODELVIEW_STACK_DEPTH:
|
|
return 1;
|
|
case GL_MAX_PROJECTION_STACK_DEPTH:
|
|
return 1;
|
|
case GL_MAX_TEXTURE_STACK_DEPTH:
|
|
return 1;
|
|
case GL_MAX_TEXTURE_UNITS:
|
|
return 1;
|
|
case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
|
|
return 1;
|
|
case GL_RED_BITS:
|
|
return 1;
|
|
case GL_SMOOTH_LINE_WIDTH_RANGE:
|
|
return 2;
|
|
case GL_SMOOTH_POINT_SIZE_RANGE:
|
|
return 2;
|
|
case GL_STENCIL_BITS:
|
|
return 1;
|
|
case GL_SUBPIXEL_BITS:
|
|
return 1;
|
|
|
|
case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:
|
|
case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:
|
|
case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:
|
|
return 16;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private int getIntegerStateFormat(int pname) {
|
|
switch (pname) {
|
|
case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:
|
|
case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:
|
|
case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:
|
|
return FORMAT_FLOAT;
|
|
|
|
default:
|
|
return FORMAT_INT;
|
|
}
|
|
}
|
|
|
|
private String getHintTarget(int target) {
|
|
switch (target) {
|
|
case GL_FOG_HINT:
|
|
return "GL_FOG_HINT";
|
|
case GL_LINE_SMOOTH_HINT:
|
|
return "GL_LINE_SMOOTH_HINT";
|
|
case GL_PERSPECTIVE_CORRECTION_HINT:
|
|
return "GL_PERSPECTIVE_CORRECTION_HINT";
|
|
case GL_POINT_SMOOTH_HINT:
|
|
return "GL_POINT_SMOOTH_HINT";
|
|
case GL_POLYGON_SMOOTH_HINT:
|
|
return "GL_POLYGON_SMOOTH_HINT";
|
|
case GL_GENERATE_MIPMAP_HINT:
|
|
return "GL_GENERATE_MIPMAP_HINT";
|
|
default:
|
|
return getHex(target);
|
|
}
|
|
}
|
|
|
|
private String getHintMode(int mode) {
|
|
switch (mode) {
|
|
case GL_FASTEST:
|
|
return "GL_FASTEST";
|
|
case GL_NICEST:
|
|
return "GL_NICEST";
|
|
case GL_DONT_CARE:
|
|
return "GL_DONT_CARE";
|
|
default:
|
|
return getHex(mode);
|
|
}
|
|
}
|
|
|
|
private String getFaceName(int face) {
|
|
switch (face) {
|
|
case GL_FRONT_AND_BACK:
|
|
return "GL_FRONT_AND_BACK";
|
|
default:
|
|
return getHex(face);
|
|
}
|
|
}
|
|
|
|
private String getMaterialPName(int pname) {
|
|
switch (pname) {
|
|
case GL_AMBIENT:
|
|
return "GL_AMBIENT";
|
|
case GL_DIFFUSE:
|
|
return "GL_DIFFUSE";
|
|
case GL_SPECULAR:
|
|
return "GL_SPECULAR";
|
|
case GL_EMISSION:
|
|
return "GL_EMISSION";
|
|
case GL_SHININESS:
|
|
return "GL_SHININESS";
|
|
case GL_AMBIENT_AND_DIFFUSE:
|
|
return "GL_AMBIENT_AND_DIFFUSE";
|
|
default:
|
|
return getHex(pname);
|
|
}
|
|
}
|
|
|
|
private int getMaterialParamCount(int pname) {
|
|
switch (pname) {
|
|
case GL_AMBIENT:
|
|
return 4;
|
|
case GL_DIFFUSE:
|
|
return 4;
|
|
case GL_SPECULAR:
|
|
return 4;
|
|
case GL_EMISSION:
|
|
return 4;
|
|
case GL_SHININESS:
|
|
return 1;
|
|
case GL_AMBIENT_AND_DIFFUSE:
|
|
return 4;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private String getLightName(int light) {
|
|
if (light >= GL_LIGHT0 && light <= GL_LIGHT7) {
|
|
return "GL_LIGHT" + Integer.toString(light);
|
|
}
|
|
return getHex(light);
|
|
}
|
|
|
|
private String getLightPName(int pname) {
|
|
switch (pname) {
|
|
case GL_AMBIENT:
|
|
return "GL_AMBIENT";
|
|
case GL_DIFFUSE:
|
|
return "GL_DIFFUSE";
|
|
case GL_SPECULAR:
|
|
return "GL_SPECULAR";
|
|
case GL_POSITION:
|
|
return "GL_POSITION";
|
|
case GL_SPOT_DIRECTION:
|
|
return "GL_SPOT_DIRECTION";
|
|
case GL_SPOT_EXPONENT:
|
|
return "GL_SPOT_EXPONENT";
|
|
case GL_SPOT_CUTOFF:
|
|
return "GL_SPOT_CUTOFF";
|
|
case GL_CONSTANT_ATTENUATION:
|
|
return "GL_CONSTANT_ATTENUATION";
|
|
case GL_LINEAR_ATTENUATION:
|
|
return "GL_LINEAR_ATTENUATION";
|
|
case GL_QUADRATIC_ATTENUATION:
|
|
return "GL_QUADRATIC_ATTENUATION";
|
|
default:
|
|
return getHex(pname);
|
|
}
|
|
}
|
|
|
|
private int getLightParamCount(int pname) {
|
|
switch (pname) {
|
|
case GL_AMBIENT:
|
|
return 4;
|
|
case GL_DIFFUSE:
|
|
return 4;
|
|
case GL_SPECULAR:
|
|
return 4;
|
|
case GL_POSITION:
|
|
return 4;
|
|
case GL_SPOT_DIRECTION:
|
|
return 3;
|
|
case GL_SPOT_EXPONENT:
|
|
return 1;
|
|
case GL_SPOT_CUTOFF:
|
|
return 1;
|
|
case GL_CONSTANT_ATTENUATION:
|
|
return 1;
|
|
case GL_LINEAR_ATTENUATION:
|
|
return 1;
|
|
case GL_QUADRATIC_ATTENUATION:
|
|
return 1;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private String getLightModelPName(int pname) {
|
|
switch (pname) {
|
|
case GL_LIGHT_MODEL_AMBIENT:
|
|
return "GL_LIGHT_MODEL_AMBIENT";
|
|
case GL_LIGHT_MODEL_TWO_SIDE:
|
|
return "GL_LIGHT_MODEL_TWO_SIDE";
|
|
default:
|
|
return getHex(pname);
|
|
}
|
|
}
|
|
|
|
private int getLightModelParamCount(int pname) {
|
|
switch (pname) {
|
|
case GL_LIGHT_MODEL_AMBIENT:
|
|
return 4;
|
|
case GL_LIGHT_MODEL_TWO_SIDE:
|
|
return 1;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private String getPointerTypeName(int type) {
|
|
switch (type) {
|
|
case GL_BYTE:
|
|
return "GL_BYTE";
|
|
case GL_UNSIGNED_BYTE:
|
|
return "GL_UNSIGNED_BYTE";
|
|
case GL_SHORT:
|
|
return "GL_SHORT";
|
|
case GL_FIXED:
|
|
return "GL_FIXED";
|
|
case GL_FLOAT:
|
|
return "GL_FLOAT";
|
|
default:
|
|
return getHex(type);
|
|
}
|
|
}
|
|
|
|
private ByteBuffer toByteBuffer(int byteCount, Buffer input) {
|
|
ByteBuffer result = null;
|
|
boolean convertWholeBuffer = (byteCount < 0);
|
|
if (input instanceof ByteBuffer) {
|
|
ByteBuffer input2 = (ByteBuffer) input;
|
|
int position = input2.position();
|
|
if (convertWholeBuffer) {
|
|
byteCount = input2.limit() - position;
|
|
}
|
|
result = ByteBuffer.allocate(byteCount).order(input2.order());
|
|
for (int i = 0; i < byteCount; i++) {
|
|
result.put(input2.get());
|
|
}
|
|
input2.position(position);
|
|
} else if (input instanceof CharBuffer) {
|
|
CharBuffer input2 = (CharBuffer) input;
|
|
int position = input2.position();
|
|
if (convertWholeBuffer) {
|
|
byteCount = (input2.limit() - position) * 2;
|
|
}
|
|
result = ByteBuffer.allocate(byteCount).order(input2.order());
|
|
CharBuffer result2 = result.asCharBuffer();
|
|
for (int i = 0; i < byteCount / 2; i++) {
|
|
result2.put(input2.get());
|
|
}
|
|
input2.position(position);
|
|
} else if (input instanceof ShortBuffer) {
|
|
ShortBuffer input2 = (ShortBuffer) input;
|
|
int position = input2.position();
|
|
if (convertWholeBuffer) {
|
|
byteCount = (input2.limit() - position)* 2;
|
|
}
|
|
result = ByteBuffer.allocate(byteCount).order(input2.order());
|
|
ShortBuffer result2 = result.asShortBuffer();
|
|
for (int i = 0; i < byteCount / 2; i++) {
|
|
result2.put(input2.get());
|
|
}
|
|
input2.position(position);
|
|
} else if (input instanceof IntBuffer) {
|
|
IntBuffer input2 = (IntBuffer) input;
|
|
int position = input2.position();
|
|
if (convertWholeBuffer) {
|
|
byteCount = (input2.limit() - position) * 4;
|
|
}
|
|
result = ByteBuffer.allocate(byteCount).order(input2.order());
|
|
IntBuffer result2 = result.asIntBuffer();
|
|
for (int i = 0; i < byteCount / 4; i++) {
|
|
result2.put(input2.get());
|
|
}
|
|
input2.position(position);
|
|
} else if (input instanceof FloatBuffer) {
|
|
FloatBuffer input2 = (FloatBuffer) input;
|
|
int position = input2.position();
|
|
if (convertWholeBuffer) {
|
|
byteCount = (input2.limit() - position) * 4;
|
|
}
|
|
result = ByteBuffer.allocate(byteCount).order(input2.order());
|
|
FloatBuffer result2 = result.asFloatBuffer();
|
|
for (int i = 0; i < byteCount / 4; i++) {
|
|
result2.put(input2.get());
|
|
}
|
|
input2.position(position);
|
|
} else if (input instanceof DoubleBuffer) {
|
|
DoubleBuffer input2 = (DoubleBuffer) input;
|
|
int position = input2.position();
|
|
if (convertWholeBuffer) {
|
|
byteCount = (input2.limit() - position) * 8;
|
|
}
|
|
result = ByteBuffer.allocate(byteCount).order(input2.order());
|
|
DoubleBuffer result2 = result.asDoubleBuffer();
|
|
for (int i = 0; i < byteCount / 8; i++) {
|
|
result2.put(input2.get());
|
|
}
|
|
input2.position(position);
|
|
} else if (input instanceof LongBuffer) {
|
|
LongBuffer input2 = (LongBuffer) input;
|
|
int position = input2.position();
|
|
if (convertWholeBuffer) {
|
|
byteCount = (input2.limit() - position) * 8;
|
|
}
|
|
result = ByteBuffer.allocate(byteCount).order(input2.order());
|
|
LongBuffer result2 = result.asLongBuffer();
|
|
for (int i = 0; i < byteCount / 8; i++) {
|
|
result2.put(input2.get());
|
|
}
|
|
input2.position(position);
|
|
} else {
|
|
throw new RuntimeException("Unimplemented Buffer subclass.");
|
|
}
|
|
result.rewind();
|
|
// The OpenGL API will interpret the result in hardware byte order,
|
|
// so we better do that as well:
|
|
result.order(ByteOrder.nativeOrder());
|
|
return result;
|
|
}
|
|
|
|
private char[] toCharIndices(int count, int type, Buffer indices) {
|
|
char[] result = new char[count];
|
|
switch (type) {
|
|
case GL_UNSIGNED_BYTE: {
|
|
ByteBuffer byteBuffer = toByteBuffer(count, indices);
|
|
byte[] array = byteBuffer.array();
|
|
int offset = byteBuffer.arrayOffset();
|
|
for (int i = 0; i < count; i++) {
|
|
result[i] = (char) (0xff & array[offset + i]);
|
|
}
|
|
}
|
|
break;
|
|
case GL_UNSIGNED_SHORT: {
|
|
CharBuffer charBuffer;
|
|
if (indices instanceof CharBuffer) {
|
|
charBuffer = (CharBuffer) indices;
|
|
} else {
|
|
ByteBuffer byteBuffer = toByteBuffer(count * 2, indices);
|
|
charBuffer = byteBuffer.asCharBuffer();
|
|
}
|
|
int oldPosition = charBuffer.position();
|
|
charBuffer.position(0);
|
|
charBuffer.get(result);
|
|
charBuffer.position(oldPosition);
|
|
}
|
|
break;
|
|
default:
|
|
// Don't throw an exception, because we don't want logging to
|
|
// change the behavior.
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void doArrayElement(StringBuilder builder, boolean enabled,
|
|
String name, PointerInfo pointer, int index) {
|
|
if (!enabled) {
|
|
return;
|
|
}
|
|
builder.append(" ");
|
|
builder.append(name + ":{");
|
|
if (pointer == null || pointer.mTempByteBuffer == null ) {
|
|
builder.append("undefined }");
|
|
return;
|
|
}
|
|
if (pointer.mStride < 0) {
|
|
builder.append("invalid stride");
|
|
return;
|
|
}
|
|
|
|
int stride = pointer.getStride();
|
|
ByteBuffer byteBuffer = pointer.mTempByteBuffer;
|
|
int size = pointer.mSize;
|
|
int type = pointer.mType;
|
|
int sizeofType = pointer.sizeof(type);
|
|
int byteOffset = stride * index;
|
|
for (int i = 0; i < size; i++) {
|
|
if (i > 0) {
|
|
builder.append(", ");
|
|
}
|
|
switch (type) {
|
|
case GL_BYTE: {
|
|
byte d = byteBuffer.get(byteOffset);
|
|
builder.append(Integer.toString(d));
|
|
}
|
|
break;
|
|
case GL_UNSIGNED_BYTE: {
|
|
byte d = byteBuffer.get(byteOffset);
|
|
builder.append(Integer.toString(0xff & d));
|
|
}
|
|
break;
|
|
case GL_SHORT: {
|
|
ShortBuffer shortBuffer = byteBuffer.asShortBuffer();
|
|
short d = shortBuffer.get(byteOffset / 2);
|
|
builder.append(Integer.toString(d));
|
|
}
|
|
break;
|
|
case GL_FIXED: {
|
|
IntBuffer intBuffer = byteBuffer.asIntBuffer();
|
|
int d = intBuffer.get(byteOffset / 4);
|
|
builder.append(Integer.toString(d));
|
|
}
|
|
break;
|
|
case GL_FLOAT: {
|
|
FloatBuffer intBuffer = byteBuffer.asFloatBuffer();
|
|
float d = intBuffer.get(byteOffset / 4);
|
|
builder.append(Float.toString(d));
|
|
}
|
|
break;
|
|
default:
|
|
builder.append("?");
|
|
break;
|
|
}
|
|
byteOffset += sizeofType;
|
|
}
|
|
builder.append("}");
|
|
}
|
|
|
|
private void doElement(StringBuilder builder, int ordinal, int vertexIndex) {
|
|
builder.append(" [" + ordinal + " : " + vertexIndex + "] =");
|
|
doArrayElement(builder, mVertexArrayEnabled, "v", mVertexPointer,
|
|
vertexIndex);
|
|
doArrayElement(builder, mNormalArrayEnabled, "n", mNormalPointer,
|
|
vertexIndex);
|
|
doArrayElement(builder, mColorArrayEnabled, "c", mColorPointer,
|
|
vertexIndex);
|
|
doArrayElement(builder, mTextureCoordArrayEnabled, "t",
|
|
mTexCoordPointer, vertexIndex);
|
|
builder.append("\n");
|
|
// Vertex
|
|
// Normal
|
|
// Color
|
|
// TexCoord
|
|
}
|
|
|
|
private void bindArrays() {
|
|
if (mColorArrayEnabled)
|
|
mColorPointer.bindByteBuffer();
|
|
if (mNormalArrayEnabled)
|
|
mNormalPointer.bindByteBuffer();
|
|
if (mTextureCoordArrayEnabled)
|
|
mTexCoordPointer.bindByteBuffer();
|
|
if (mVertexArrayEnabled)
|
|
mVertexPointer.bindByteBuffer();
|
|
}
|
|
|
|
private void unbindArrays() {
|
|
if (mColorArrayEnabled)
|
|
mColorPointer.unbindByteBuffer();
|
|
if (mNormalArrayEnabled)
|
|
mNormalPointer.unbindByteBuffer();
|
|
if (mTextureCoordArrayEnabled)
|
|
mTexCoordPointer.unbindByteBuffer();
|
|
if (mVertexArrayEnabled)
|
|
mVertexPointer.unbindByteBuffer();
|
|
}
|
|
|
|
private void startLogIndices() {
|
|
mStringBuilder = new StringBuilder();
|
|
mStringBuilder.append("\n");
|
|
bindArrays();
|
|
}
|
|
|
|
private void endLogIndices() {
|
|
log(mStringBuilder.toString());
|
|
unbindArrays();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------
|
|
// GL10 methods:
|
|
|
|
public void glActiveTexture(int texture) {
|
|
begin("glActiveTexture");
|
|
arg("texture", texture);
|
|
end();
|
|
mgl.glActiveTexture(texture);
|
|
checkError();
|
|
}
|
|
|
|
public void glAlphaFunc(int func, float ref) {
|
|
begin("glAlphaFunc");
|
|
arg("func", func);
|
|
arg("ref", ref);
|
|
end();
|
|
mgl.glAlphaFunc(func, ref);
|
|
checkError();
|
|
}
|
|
|
|
public void glAlphaFuncx(int func, int ref) {
|
|
begin("glAlphaFuncx");
|
|
arg("func", func);
|
|
arg("ref", ref);
|
|
end();
|
|
mgl.glAlphaFuncx(func, ref);
|
|
checkError();
|
|
}
|
|
|
|
public void glBindTexture(int target, int texture) {
|
|
begin("glBindTexture");
|
|
arg("target", getTextureTarget(target));
|
|
arg("texture", texture);
|
|
end();
|
|
mgl.glBindTexture(target, texture);
|
|
checkError();
|
|
}
|
|
|
|
public void glBlendFunc(int sfactor, int dfactor) {
|
|
begin("glBlendFunc");
|
|
arg("sfactor", getFactor(sfactor));
|
|
arg("dfactor", getFactor(dfactor));
|
|
end();
|
|
|
|
mgl.glBlendFunc(sfactor, dfactor);
|
|
checkError();
|
|
}
|
|
|
|
public void glClear(int mask) {
|
|
begin("glClear");
|
|
arg("mask", getClearBufferMask(mask));
|
|
end();
|
|
|
|
mgl.glClear(mask);
|
|
checkError();
|
|
}
|
|
|
|
public void glClearColor(float red, float green, float blue, float alpha) {
|
|
begin("glClearColor");
|
|
arg("red", red);
|
|
arg("green", green);
|
|
arg("blue", blue);
|
|
arg("alpha", alpha);
|
|
end();
|
|
|
|
mgl.glClearColor(red, green, blue, alpha);
|
|
checkError();
|
|
}
|
|
|
|
public void glClearColorx(int red, int green, int blue, int alpha) {
|
|
begin("glClearColor");
|
|
arg("red", red);
|
|
arg("green", green);
|
|
arg("blue", blue);
|
|
arg("alpha", alpha);
|
|
end();
|
|
|
|
mgl.glClearColorx(red, green, blue, alpha);
|
|
checkError();
|
|
}
|
|
|
|
public void glClearDepthf(float depth) {
|
|
begin("glClearDepthf");
|
|
arg("depth", depth);
|
|
end();
|
|
|
|
mgl.glClearDepthf(depth);
|
|
checkError();
|
|
}
|
|
|
|
public void glClearDepthx(int depth) {
|
|
begin("glClearDepthx");
|
|
arg("depth", depth);
|
|
end();
|
|
|
|
mgl.glClearDepthx(depth);
|
|
checkError();
|
|
}
|
|
|
|
public void glClearStencil(int s) {
|
|
begin("glClearStencil");
|
|
arg("s", s);
|
|
end();
|
|
|
|
mgl.glClearStencil(s);
|
|
checkError();
|
|
}
|
|
|
|
public void glClientActiveTexture(int texture) {
|
|
begin("glClientActiveTexture");
|
|
arg("texture", texture);
|
|
end();
|
|
|
|
mgl.glClientActiveTexture(texture);
|
|
checkError();
|
|
}
|
|
|
|
public void glColor4f(float red, float green, float blue, float alpha) {
|
|
begin("glColor4f");
|
|
arg("red", red);
|
|
arg("green", green);
|
|
arg("blue", blue);
|
|
arg("alpha", alpha);
|
|
end();
|
|
|
|
mgl.glColor4f(red, green, blue, alpha);
|
|
checkError();
|
|
}
|
|
|
|
public void glColor4x(int red, int green, int blue, int alpha) {
|
|
begin("glColor4x");
|
|
arg("red", red);
|
|
arg("green", green);
|
|
arg("blue", blue);
|
|
arg("alpha", alpha);
|
|
end();
|
|
|
|
mgl.glColor4x(red, green, blue, alpha);
|
|
checkError();
|
|
}
|
|
|
|
public void glColorMask(boolean red, boolean green, boolean blue,
|
|
boolean alpha) {
|
|
begin("glColorMask");
|
|
arg("red", red);
|
|
arg("green", green);
|
|
arg("blue", blue);
|
|
arg("alpha", alpha);
|
|
end();
|
|
|
|
mgl.glColorMask(red, green, blue, alpha);
|
|
checkError();
|
|
}
|
|
|
|
public void glColorPointer(int size, int type, int stride, Buffer pointer) {
|
|
begin("glColorPointer");
|
|
argPointer(size, type, stride, pointer);
|
|
end();
|
|
mColorPointer = new PointerInfo(size, type, stride, pointer);
|
|
|
|
mgl.glColorPointer(size, type, stride, pointer);
|
|
checkError();
|
|
}
|
|
|
|
public void glCompressedTexImage2D(int target, int level,
|
|
int internalformat, int width, int height, int border,
|
|
int imageSize, Buffer data) {
|
|
begin("glCompressedTexImage2D");
|
|
arg("target", getTextureTarget(target));
|
|
arg("level", level);
|
|
arg("internalformat", internalformat);
|
|
arg("width", width);
|
|
arg("height", height);
|
|
arg("border", border);
|
|
arg("imageSize", imageSize);
|
|
arg("data", data.toString());
|
|
end();
|
|
|
|
mgl.glCompressedTexImage2D(target, level, internalformat, width,
|
|
height, border, imageSize, data);
|
|
checkError();
|
|
}
|
|
|
|
public void glCompressedTexSubImage2D(int target, int level, int xoffset,
|
|
int yoffset, int width, int height, int format, int imageSize,
|
|
Buffer data) {
|
|
begin("glCompressedTexSubImage2D");
|
|
arg("target", getTextureTarget(target));
|
|
arg("level", level);
|
|
arg("xoffset", xoffset);
|
|
arg("yoffset", yoffset);
|
|
arg("width", width);
|
|
arg("height", height);
|
|
arg("format", format);
|
|
arg("imageSize", imageSize);
|
|
arg("data", data.toString());
|
|
end();
|
|
|
|
mgl.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width,
|
|
height, format, imageSize, data);
|
|
checkError();
|
|
}
|
|
|
|
public void glCopyTexImage2D(int target, int level, int internalformat,
|
|
int x, int y, int width, int height, int border) {
|
|
begin("glCopyTexImage2D");
|
|
arg("target", getTextureTarget(target));
|
|
arg("level", level);
|
|
arg("internalformat", internalformat);
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("width", width);
|
|
arg("height", height);
|
|
arg("border", border);
|
|
end();
|
|
|
|
mgl.glCopyTexImage2D(target, level, internalformat, x, y, width,
|
|
height, border);
|
|
checkError();
|
|
}
|
|
|
|
public void glCopyTexSubImage2D(int target, int level, int xoffset,
|
|
int yoffset, int x, int y, int width, int height) {
|
|
begin("glCopyTexSubImage2D");
|
|
arg("target", getTextureTarget(target));
|
|
arg("level", level);
|
|
arg("xoffset", xoffset);
|
|
arg("yoffset", yoffset);
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("width", width);
|
|
arg("height", height);
|
|
end();
|
|
|
|
mgl.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width,
|
|
height);
|
|
checkError();
|
|
}
|
|
|
|
public void glCullFace(int mode) {
|
|
begin("glCullFace");
|
|
arg("mode", mode);
|
|
end();
|
|
|
|
mgl.glCullFace(mode);
|
|
checkError();
|
|
}
|
|
|
|
public void glDeleteTextures(int n, int[] textures, int offset) {
|
|
begin("glDeleteTextures");
|
|
arg("n", n);
|
|
arg("textures", n, textures, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glDeleteTextures(n, textures, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glDeleteTextures(int n, IntBuffer textures) {
|
|
begin("glDeleteTextures");
|
|
arg("n", n);
|
|
arg("textures", n, textures);
|
|
end();
|
|
|
|
mgl.glDeleteTextures(n, textures);
|
|
checkError();
|
|
}
|
|
|
|
public void glDepthFunc(int func) {
|
|
begin("glDepthFunc");
|
|
arg("func", func);
|
|
end();
|
|
|
|
mgl.glDepthFunc(func);
|
|
checkError();
|
|
}
|
|
|
|
public void glDepthMask(boolean flag) {
|
|
begin("glDepthMask");
|
|
arg("flag", flag);
|
|
end();
|
|
|
|
mgl.glDepthMask(flag);
|
|
checkError();
|
|
}
|
|
|
|
public void glDepthRangef(float near, float far) {
|
|
begin("glDepthRangef");
|
|
arg("near", near);
|
|
arg("far", far);
|
|
end();
|
|
|
|
mgl.glDepthRangef(near, far);
|
|
checkError();
|
|
}
|
|
|
|
public void glDepthRangex(int near, int far) {
|
|
begin("glDepthRangex");
|
|
arg("near", near);
|
|
arg("far", far);
|
|
end();
|
|
|
|
mgl.glDepthRangex(near, far);
|
|
checkError();
|
|
}
|
|
|
|
public void glDisable(int cap) {
|
|
begin("glDisable");
|
|
arg("cap", getCap(cap));
|
|
end();
|
|
|
|
mgl.glDisable(cap);
|
|
checkError();
|
|
}
|
|
|
|
public void glDisableClientState(int array) {
|
|
begin("glDisableClientState");
|
|
arg("array", getClientState(array));
|
|
end();
|
|
|
|
switch (array) {
|
|
case GL_COLOR_ARRAY:
|
|
mColorArrayEnabled = false;
|
|
break;
|
|
case GL_NORMAL_ARRAY:
|
|
mNormalArrayEnabled = false;
|
|
break;
|
|
case GL_TEXTURE_COORD_ARRAY:
|
|
mTextureCoordArrayEnabled = false;
|
|
break;
|
|
case GL_VERTEX_ARRAY:
|
|
mVertexArrayEnabled = false;
|
|
break;
|
|
}
|
|
mgl.glDisableClientState(array);
|
|
checkError();
|
|
}
|
|
|
|
public void glDrawArrays(int mode, int first, int count) {
|
|
begin("glDrawArrays");
|
|
arg("mode", mode);
|
|
arg("first", first);
|
|
arg("count", count);
|
|
startLogIndices();
|
|
for (int i = 0; i < count; i++) {
|
|
doElement(mStringBuilder, i, first + i);
|
|
}
|
|
endLogIndices();
|
|
end();
|
|
|
|
mgl.glDrawArrays(mode, first, count);
|
|
checkError();
|
|
}
|
|
|
|
public void glDrawElements(int mode, int count, int type, Buffer indices) {
|
|
begin("glDrawElements");
|
|
arg("mode", getBeginMode(mode));
|
|
arg("count", count);
|
|
arg("type", getIndexType(type));
|
|
char[] indexArray = toCharIndices(count, type, indices);
|
|
int indexArrayLength = indexArray.length;
|
|
startLogIndices();
|
|
for (int i = 0; i < indexArrayLength; i++) {
|
|
doElement(mStringBuilder, i, indexArray[i]);
|
|
}
|
|
endLogIndices();
|
|
end();
|
|
|
|
mgl.glDrawElements(mode, count, type, indices);
|
|
checkError();
|
|
}
|
|
|
|
public void glEnable(int cap) {
|
|
begin("glEnable");
|
|
arg("cap", getCap(cap));
|
|
end();
|
|
|
|
mgl.glEnable(cap);
|
|
checkError();
|
|
}
|
|
|
|
public void glEnableClientState(int array) {
|
|
begin("glEnableClientState");
|
|
arg("array", getClientState(array));
|
|
end();
|
|
|
|
switch (array) {
|
|
case GL_COLOR_ARRAY:
|
|
mColorArrayEnabled = true;
|
|
break;
|
|
case GL_NORMAL_ARRAY:
|
|
mNormalArrayEnabled = true;
|
|
break;
|
|
case GL_TEXTURE_COORD_ARRAY:
|
|
mTextureCoordArrayEnabled = true;
|
|
break;
|
|
case GL_VERTEX_ARRAY:
|
|
mVertexArrayEnabled = true;
|
|
break;
|
|
}
|
|
mgl.glEnableClientState(array);
|
|
checkError();
|
|
}
|
|
|
|
public void glFinish() {
|
|
begin("glFinish");
|
|
end();
|
|
|
|
mgl.glFinish();
|
|
checkError();
|
|
}
|
|
|
|
public void glFlush() {
|
|
begin("glFlush");
|
|
end();
|
|
|
|
mgl.glFlush();
|
|
checkError();
|
|
}
|
|
|
|
public void glFogf(int pname, float param) {
|
|
begin("glFogf");
|
|
arg("pname", pname);
|
|
arg("param", param);
|
|
end();
|
|
|
|
mgl.glFogf(pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glFogfv(int pname, float[] params, int offset) {
|
|
begin("glFogfv");
|
|
arg("pname", getFogPName(pname));
|
|
arg("params", getFogParamCount(pname), params, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glFogfv(pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glFogfv(int pname, FloatBuffer params) {
|
|
begin("glFogfv");
|
|
arg("pname", getFogPName(pname));
|
|
arg("params", getFogParamCount(pname), params);
|
|
end();
|
|
|
|
mgl.glFogfv(pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glFogx(int pname, int param) {
|
|
begin("glFogx");
|
|
arg("pname", getFogPName(pname));
|
|
arg("param", param);
|
|
end();
|
|
|
|
mgl.glFogx(pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glFogxv(int pname, int[] params, int offset) {
|
|
begin("glFogxv");
|
|
arg("pname", getFogPName(pname));
|
|
arg("params", getFogParamCount(pname), params, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glFogxv(pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glFogxv(int pname, IntBuffer params) {
|
|
begin("glFogxv");
|
|
arg("pname", getFogPName(pname));
|
|
arg("params", getFogParamCount(pname), params);
|
|
end();
|
|
|
|
mgl.glFogxv(pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glFrontFace(int mode) {
|
|
begin("glFrontFace");
|
|
arg("mode", mode);
|
|
end();
|
|
|
|
mgl.glFrontFace(mode);
|
|
checkError();
|
|
}
|
|
|
|
public void glFrustumf(float left, float right, float bottom, float top,
|
|
float near, float far) {
|
|
begin("glFrustumf");
|
|
arg("left", left);
|
|
arg("right", right);
|
|
arg("bottom", bottom);
|
|
arg("top", top);
|
|
arg("near", near);
|
|
arg("far", far);
|
|
end();
|
|
|
|
mgl.glFrustumf(left, right, bottom, top, near, far);
|
|
checkError();
|
|
}
|
|
|
|
public void glFrustumx(int left, int right, int bottom, int top, int near,
|
|
int far) {
|
|
begin("glFrustumx");
|
|
arg("left", left);
|
|
arg("right", right);
|
|
arg("bottom", bottom);
|
|
arg("top", top);
|
|
arg("near", near);
|
|
arg("far", far);
|
|
end();
|
|
|
|
mgl.glFrustumx(left, right, bottom, top, near, far);
|
|
checkError();
|
|
}
|
|
|
|
public void glGenTextures(int n, int[] textures, int offset) {
|
|
begin("glGenTextures");
|
|
arg("n", n);
|
|
arg("textures", Arrays.toString(textures));
|
|
arg("offset", offset);
|
|
|
|
mgl.glGenTextures(n, textures, offset);
|
|
|
|
returns(toString(n, FORMAT_INT, textures, offset));
|
|
|
|
checkError();
|
|
}
|
|
|
|
public void glGenTextures(int n, IntBuffer textures) {
|
|
begin("glGenTextures");
|
|
arg("n", n);
|
|
arg("textures", textures.toString());
|
|
|
|
mgl.glGenTextures(n, textures);
|
|
|
|
returns(toString(n, FORMAT_INT, textures));
|
|
|
|
checkError();
|
|
}
|
|
|
|
public int glGetError() {
|
|
begin("glGetError");
|
|
|
|
int result = mgl.glGetError();
|
|
|
|
returns(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
public void glGetIntegerv(int pname, int[] params, int offset) {
|
|
begin("glGetIntegerv");
|
|
arg("pname", getIntegerStateName(pname));
|
|
arg("params", Arrays.toString(params));
|
|
arg("offset", offset);
|
|
|
|
mgl.glGetIntegerv(pname, params, offset);
|
|
|
|
returns(toString(getIntegerStateSize(pname),
|
|
getIntegerStateFormat(pname), params, offset));
|
|
|
|
checkError();
|
|
}
|
|
|
|
public void glGetIntegerv(int pname, IntBuffer params) {
|
|
begin("glGetIntegerv");
|
|
arg("pname", getIntegerStateName(pname));
|
|
arg("params", params.toString());
|
|
|
|
mgl.glGetIntegerv(pname, params);
|
|
|
|
returns(toString(getIntegerStateSize(pname),
|
|
getIntegerStateFormat(pname), params));
|
|
|
|
checkError();
|
|
}
|
|
|
|
public String glGetString(int name) {
|
|
begin("glGetString");
|
|
arg("name", name);
|
|
|
|
String result = mgl.glGetString(name);
|
|
|
|
returns(result);
|
|
|
|
checkError();
|
|
return result;
|
|
}
|
|
|
|
public void glHint(int target, int mode) {
|
|
begin("glHint");
|
|
arg("target", getHintTarget(target));
|
|
arg("mode", getHintMode(mode));
|
|
end();
|
|
|
|
mgl.glHint(target, mode);
|
|
checkError();
|
|
}
|
|
|
|
public void glLightModelf(int pname, float param) {
|
|
begin("glLightModelf");
|
|
arg("pname", getLightModelPName(pname));
|
|
arg("param", param);
|
|
end();
|
|
|
|
mgl.glLightModelf(pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glLightModelfv(int pname, float[] params, int offset) {
|
|
begin("glLightModelfv");
|
|
arg("pname", getLightModelPName(pname));
|
|
arg("params", getLightModelParamCount(pname), params, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glLightModelfv(pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glLightModelfv(int pname, FloatBuffer params) {
|
|
begin("glLightModelfv");
|
|
arg("pname", getLightModelPName(pname));
|
|
arg("params", getLightModelParamCount(pname), params);
|
|
end();
|
|
|
|
mgl.glLightModelfv(pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glLightModelx(int pname, int param) {
|
|
begin("glLightModelx");
|
|
arg("pname", getLightModelPName(pname));
|
|
arg("param", param);
|
|
end();
|
|
|
|
mgl.glLightModelx(pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glLightModelxv(int pname, int[] params, int offset) {
|
|
begin("glLightModelxv");
|
|
arg("pname", getLightModelPName(pname));
|
|
arg("params", getLightModelParamCount(pname), params, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glLightModelxv(pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glLightModelxv(int pname, IntBuffer params) {
|
|
begin("glLightModelfv");
|
|
arg("pname", getLightModelPName(pname));
|
|
arg("params", getLightModelParamCount(pname), params);
|
|
end();
|
|
|
|
mgl.glLightModelxv(pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glLightf(int light, int pname, float param) {
|
|
begin("glLightf");
|
|
arg("light", getLightName(light));
|
|
arg("pname", getLightPName(pname));
|
|
arg("param", param);
|
|
end();
|
|
|
|
mgl.glLightf(light, pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glLightfv(int light, int pname, float[] params, int offset) {
|
|
begin("glLightfv");
|
|
arg("light", getLightName(light));
|
|
arg("pname", getLightPName(pname));
|
|
arg("params", getLightParamCount(pname), params, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glLightfv(light, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glLightfv(int light, int pname, FloatBuffer params) {
|
|
begin("glLightfv");
|
|
arg("light", getLightName(light));
|
|
arg("pname", getLightPName(pname));
|
|
arg("params", getLightParamCount(pname), params);
|
|
end();
|
|
|
|
mgl.glLightfv(light, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glLightx(int light, int pname, int param) {
|
|
begin("glLightx");
|
|
arg("light", getLightName(light));
|
|
arg("pname", getLightPName(pname));
|
|
arg("param", param);
|
|
end();
|
|
|
|
mgl.glLightx(light, pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glLightxv(int light, int pname, int[] params, int offset) {
|
|
begin("glLightxv");
|
|
arg("light", getLightName(light));
|
|
arg("pname", getLightPName(pname));
|
|
arg("params", getLightParamCount(pname), params, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glLightxv(light, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glLightxv(int light, int pname, IntBuffer params) {
|
|
begin("glLightxv");
|
|
arg("light", getLightName(light));
|
|
arg("pname", getLightPName(pname));
|
|
arg("params", getLightParamCount(pname), params);
|
|
end();
|
|
|
|
mgl.glLightxv(light, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glLineWidth(float width) {
|
|
begin("glLineWidth");
|
|
arg("width", width);
|
|
end();
|
|
|
|
mgl.glLineWidth(width);
|
|
checkError();
|
|
}
|
|
|
|
public void glLineWidthx(int width) {
|
|
begin("glLineWidthx");
|
|
arg("width", width);
|
|
end();
|
|
|
|
mgl.glLineWidthx(width);
|
|
checkError();
|
|
}
|
|
|
|
public void glLoadIdentity() {
|
|
begin("glLoadIdentity");
|
|
end();
|
|
|
|
mgl.glLoadIdentity();
|
|
checkError();
|
|
}
|
|
|
|
public void glLoadMatrixf(float[] m, int offset) {
|
|
begin("glLoadMatrixf");
|
|
arg("m", 16, m, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glLoadMatrixf(m, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glLoadMatrixf(FloatBuffer m) {
|
|
begin("glLoadMatrixf");
|
|
arg("m", 16, m);
|
|
end();
|
|
|
|
mgl.glLoadMatrixf(m);
|
|
checkError();
|
|
}
|
|
|
|
public void glLoadMatrixx(int[] m, int offset) {
|
|
begin("glLoadMatrixx");
|
|
arg("m", 16, m, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glLoadMatrixx(m, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glLoadMatrixx(IntBuffer m) {
|
|
begin("glLoadMatrixx");
|
|
arg("m", 16, m);
|
|
end();
|
|
|
|
mgl.glLoadMatrixx(m);
|
|
checkError();
|
|
}
|
|
|
|
public void glLogicOp(int opcode) {
|
|
begin("glLogicOp");
|
|
arg("opcode", opcode);
|
|
end();
|
|
|
|
mgl.glLogicOp(opcode);
|
|
checkError();
|
|
}
|
|
|
|
public void glMaterialf(int face, int pname, float param) {
|
|
begin("glMaterialf");
|
|
arg("face", getFaceName(face));
|
|
arg("pname", getMaterialPName(pname));
|
|
arg("param", param);
|
|
end();
|
|
|
|
mgl.glMaterialf(face, pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glMaterialfv(int face, int pname, float[] params, int offset) {
|
|
begin("glMaterialfv");
|
|
arg("face", getFaceName(face));
|
|
arg("pname", getMaterialPName(pname));
|
|
arg("params", getMaterialParamCount(pname), params, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glMaterialfv(face, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glMaterialfv(int face, int pname, FloatBuffer params) {
|
|
begin("glMaterialfv");
|
|
arg("face", getFaceName(face));
|
|
arg("pname", getMaterialPName(pname));
|
|
arg("params", getMaterialParamCount(pname), params);
|
|
end();
|
|
|
|
mgl.glMaterialfv(face, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glMaterialx(int face, int pname, int param) {
|
|
begin("glMaterialx");
|
|
arg("face", getFaceName(face));
|
|
arg("pname", getMaterialPName(pname));
|
|
arg("param", param);
|
|
end();
|
|
|
|
mgl.glMaterialx(face, pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glMaterialxv(int face, int pname, int[] params, int offset) {
|
|
begin("glMaterialxv");
|
|
arg("face", getFaceName(face));
|
|
arg("pname", getMaterialPName(pname));
|
|
arg("params", getMaterialParamCount(pname), params, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glMaterialxv(face, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glMaterialxv(int face, int pname, IntBuffer params) {
|
|
begin("glMaterialxv");
|
|
arg("face", getFaceName(face));
|
|
arg("pname", getMaterialPName(pname));
|
|
arg("params", getMaterialParamCount(pname), params);
|
|
end();
|
|
|
|
mgl.glMaterialxv(face, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glMatrixMode(int mode) {
|
|
begin("glMatrixMode");
|
|
arg("mode", getMatrixMode(mode));
|
|
end();
|
|
|
|
mgl.glMatrixMode(mode);
|
|
checkError();
|
|
}
|
|
|
|
public void glMultMatrixf(float[] m, int offset) {
|
|
begin("glMultMatrixf");
|
|
arg("m", 16, m, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glMultMatrixf(m, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glMultMatrixf(FloatBuffer m) {
|
|
begin("glMultMatrixf");
|
|
arg("m", 16, m);
|
|
end();
|
|
|
|
mgl.glMultMatrixf(m);
|
|
checkError();
|
|
}
|
|
|
|
public void glMultMatrixx(int[] m, int offset) {
|
|
begin("glMultMatrixx");
|
|
arg("m", 16, m, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glMultMatrixx(m, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glMultMatrixx(IntBuffer m) {
|
|
begin("glMultMatrixx");
|
|
arg("m", 16, m);
|
|
end();
|
|
|
|
mgl.glMultMatrixx(m);
|
|
checkError();
|
|
}
|
|
|
|
public void glMultiTexCoord4f(int target, float s, float t, float r, float q) {
|
|
begin("glMultiTexCoord4f");
|
|
arg("target", target);
|
|
arg("s", s);
|
|
arg("t", t);
|
|
arg("r", r);
|
|
arg("q", q);
|
|
end();
|
|
|
|
mgl.glMultiTexCoord4f(target, s, t, r, q);
|
|
checkError();
|
|
}
|
|
|
|
public void glMultiTexCoord4x(int target, int s, int t, int r, int q) {
|
|
begin("glMultiTexCoord4x");
|
|
arg("target", target);
|
|
arg("s", s);
|
|
arg("t", t);
|
|
arg("r", r);
|
|
arg("q", q);
|
|
end();
|
|
|
|
mgl.glMultiTexCoord4x(target, s, t, r, q);
|
|
checkError();
|
|
}
|
|
|
|
public void glNormal3f(float nx, float ny, float nz) {
|
|
begin("glNormal3f");
|
|
arg("nx", nx);
|
|
arg("ny", ny);
|
|
arg("nz", nz);
|
|
end();
|
|
|
|
mgl.glNormal3f(nx, ny, nz);
|
|
checkError();
|
|
}
|
|
|
|
public void glNormal3x(int nx, int ny, int nz) {
|
|
begin("glNormal3x");
|
|
arg("nx", nx);
|
|
arg("ny", ny);
|
|
arg("nz", nz);
|
|
end();
|
|
|
|
mgl.glNormal3x(nx, ny, nz);
|
|
checkError();
|
|
}
|
|
|
|
public void glNormalPointer(int type, int stride, Buffer pointer) {
|
|
begin("glNormalPointer");
|
|
arg("type", type);
|
|
arg("stride", stride);
|
|
arg("pointer", pointer.toString());
|
|
end();
|
|
mNormalPointer = new PointerInfo(3, type, stride, pointer);
|
|
|
|
mgl.glNormalPointer(type, stride, pointer);
|
|
checkError();
|
|
}
|
|
|
|
public void glOrthof(float left, float right, float bottom, float top,
|
|
float near, float far) {
|
|
begin("glOrthof");
|
|
arg("left", left);
|
|
arg("right", right);
|
|
arg("bottom", bottom);
|
|
arg("top", top);
|
|
arg("near", near);
|
|
arg("far", far);
|
|
end();
|
|
|
|
mgl.glOrthof(left, right, bottom, top, near, far);
|
|
checkError();
|
|
}
|
|
|
|
public void glOrthox(int left, int right, int bottom, int top, int near,
|
|
int far) {
|
|
begin("glOrthox");
|
|
arg("left", left);
|
|
arg("right", right);
|
|
arg("bottom", bottom);
|
|
arg("top", top);
|
|
arg("near", near);
|
|
arg("far", far);
|
|
end();
|
|
|
|
mgl.glOrthox(left, right, bottom, top, near, far);
|
|
checkError();
|
|
}
|
|
|
|
public void glPixelStorei(int pname, int param) {
|
|
begin("glPixelStorei");
|
|
arg("pname", pname);
|
|
arg("param", param);
|
|
end();
|
|
|
|
mgl.glPixelStorei(pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glPointSize(float size) {
|
|
begin("glPointSize");
|
|
arg("size", size);
|
|
end();
|
|
|
|
mgl.glPointSize(size);
|
|
checkError();
|
|
}
|
|
|
|
public void glPointSizex(int size) {
|
|
begin("glPointSizex");
|
|
arg("size", size);
|
|
end();
|
|
|
|
mgl.glPointSizex(size);
|
|
checkError();
|
|
}
|
|
|
|
public void glPolygonOffset(float factor, float units) {
|
|
begin("glPolygonOffset");
|
|
arg("factor", factor);
|
|
arg("units", units);
|
|
end();
|
|
mgl.glPolygonOffset(factor, units);
|
|
checkError();
|
|
}
|
|
|
|
public void glPolygonOffsetx(int factor, int units) {
|
|
begin("glPolygonOffsetx");
|
|
arg("factor", factor);
|
|
arg("units", units);
|
|
end();
|
|
|
|
mgl.glPolygonOffsetx(factor, units);
|
|
checkError();
|
|
}
|
|
|
|
public void glPopMatrix() {
|
|
begin("glPopMatrix");
|
|
end();
|
|
|
|
mgl.glPopMatrix();
|
|
checkError();
|
|
}
|
|
|
|
public void glPushMatrix() {
|
|
begin("glPushMatrix");
|
|
end();
|
|
|
|
mgl.glPushMatrix();
|
|
checkError();
|
|
}
|
|
|
|
public void glReadPixels(int x, int y, int width, int height, int format,
|
|
int type, Buffer pixels) {
|
|
begin("glReadPixels");
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("width", width);
|
|
arg("height", height);
|
|
arg("format", format);
|
|
arg("type", type);
|
|
arg("pixels", pixels.toString());
|
|
end();
|
|
|
|
mgl.glReadPixels(x, y, width, height, format, type, pixels);
|
|
checkError();
|
|
}
|
|
|
|
public void glRotatef(float angle, float x, float y, float z) {
|
|
begin("glRotatef");
|
|
arg("angle", angle);
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("z", z);
|
|
end();
|
|
|
|
mgl.glRotatef(angle, x, y, z);
|
|
checkError();
|
|
}
|
|
|
|
public void glRotatex(int angle, int x, int y, int z) {
|
|
begin("glRotatex");
|
|
arg("angle", angle);
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("z", z);
|
|
end();
|
|
|
|
mgl.glRotatex(angle, x, y, z);
|
|
checkError();
|
|
}
|
|
|
|
public void glSampleCoverage(float value, boolean invert) {
|
|
begin("glSampleCoveragex");
|
|
arg("value", value);
|
|
arg("invert", invert);
|
|
end();
|
|
|
|
mgl.glSampleCoverage(value, invert);
|
|
checkError();
|
|
}
|
|
|
|
public void glSampleCoveragex(int value, boolean invert) {
|
|
begin("glSampleCoveragex");
|
|
arg("value", value);
|
|
arg("invert", invert);
|
|
end();
|
|
|
|
mgl.glSampleCoveragex(value, invert);
|
|
checkError();
|
|
}
|
|
|
|
public void glScalef(float x, float y, float z) {
|
|
begin("glScalef");
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("z", z);
|
|
end();
|
|
|
|
mgl.glScalef(x, y, z);
|
|
checkError();
|
|
}
|
|
|
|
public void glScalex(int x, int y, int z) {
|
|
begin("glScalex");
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("z", z);
|
|
end();
|
|
|
|
mgl.glScalex(x, y, z);
|
|
checkError();
|
|
}
|
|
|
|
public void glScissor(int x, int y, int width, int height) {
|
|
begin("glScissor");
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("width", width);
|
|
arg("height", height);
|
|
end();
|
|
|
|
mgl.glScissor(x, y, width, height);
|
|
checkError();
|
|
}
|
|
|
|
public void glShadeModel(int mode) {
|
|
begin("glShadeModel");
|
|
arg("mode", getShadeModel(mode));
|
|
end();
|
|
|
|
mgl.glShadeModel(mode);
|
|
checkError();
|
|
}
|
|
|
|
public void glStencilFunc(int func, int ref, int mask) {
|
|
begin("glStencilFunc");
|
|
arg("func", func);
|
|
arg("ref", ref);
|
|
arg("mask", mask);
|
|
end();
|
|
|
|
mgl.glStencilFunc(func, ref, mask);
|
|
checkError();
|
|
}
|
|
|
|
public void glStencilMask(int mask) {
|
|
begin("glStencilMask");
|
|
arg("mask", mask);
|
|
end();
|
|
|
|
mgl.glStencilMask(mask);
|
|
checkError();
|
|
}
|
|
|
|
public void glStencilOp(int fail, int zfail, int zpass) {
|
|
begin("glStencilOp");
|
|
arg("fail", fail);
|
|
arg("zfail", zfail);
|
|
arg("zpass", zpass);
|
|
end();
|
|
|
|
mgl.glStencilOp(fail, zfail, zpass);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexCoordPointer(int size, int type, int stride, Buffer pointer) {
|
|
begin("glTexCoordPointer");
|
|
argPointer(size, type, stride, pointer);
|
|
end();
|
|
mTexCoordPointer = new PointerInfo(size, type, stride, pointer);
|
|
|
|
mgl.glTexCoordPointer(size, type, stride, pointer);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexEnvf(int target, int pname, float param) {
|
|
begin("glTexEnvf");
|
|
arg("target", getTextureEnvTarget(target));
|
|
arg("pname", getTextureEnvPName(pname));
|
|
arg("param", getTextureEnvParamName(param));
|
|
end();
|
|
|
|
mgl.glTexEnvf(target, pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexEnvfv(int target, int pname, float[] params, int offset) {
|
|
begin("glTexEnvfv");
|
|
arg("target", getTextureEnvTarget(target));
|
|
arg("pname", getTextureEnvPName(pname));
|
|
arg("params", getTextureEnvParamCount(pname), params, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glTexEnvfv(target, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexEnvfv(int target, int pname, FloatBuffer params) {
|
|
begin("glTexEnvfv");
|
|
arg("target", getTextureEnvTarget(target));
|
|
arg("pname", getTextureEnvPName(pname));
|
|
arg("params", getTextureEnvParamCount(pname), params);
|
|
end();
|
|
|
|
mgl.glTexEnvfv(target, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexEnvx(int target, int pname, int param) {
|
|
begin("glTexEnvx");
|
|
arg("target", getTextureEnvTarget(target));
|
|
arg("pname", getTextureEnvPName(pname));
|
|
arg("param", param);
|
|
end();
|
|
|
|
mgl.glTexEnvx(target, pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexEnvxv(int target, int pname, int[] params, int offset) {
|
|
begin("glTexEnvxv");
|
|
arg("target", getTextureEnvTarget(target));
|
|
arg("pname", getTextureEnvPName(pname));
|
|
arg("params", getTextureEnvParamCount(pname), params, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
|
|
mgl.glTexEnvxv(target, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexEnvxv(int target, int pname, IntBuffer params) {
|
|
begin("glTexEnvxv");
|
|
arg("target", getTextureEnvTarget(target));
|
|
arg("pname", getTextureEnvPName(pname));
|
|
arg("params", getTextureEnvParamCount(pname), params);
|
|
end();
|
|
|
|
mgl.glTexEnvxv(target, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexImage2D(int target, int level, int internalformat,
|
|
int width, int height, int border, int format, int type,
|
|
Buffer pixels) {
|
|
begin("glTexImage2D");
|
|
arg("target", target);
|
|
arg("level", level);
|
|
arg("internalformat", internalformat);
|
|
arg("width", width);
|
|
arg("height", height);
|
|
arg("border", border);
|
|
arg("format", format);
|
|
arg("type", type);
|
|
arg("pixels", pixels.toString());
|
|
end();
|
|
|
|
mgl.glTexImage2D(target, level, internalformat, width, height, border,
|
|
format, type, pixels);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexParameterf(int target, int pname, float param) {
|
|
begin("glTexParameterf");
|
|
arg("target", getTextureTarget(target));
|
|
arg("pname", getTexturePName(pname));
|
|
arg("param", getTextureParamName(param));
|
|
end();
|
|
|
|
mgl.glTexParameterf(target, pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexParameterx(int target, int pname, int param) {
|
|
begin("glTexParameterx");
|
|
arg("target", getTextureTarget(target));
|
|
arg("pname", getTexturePName(pname));
|
|
arg("param", param);
|
|
end();
|
|
|
|
mgl.glTexParameterx(target, pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexParameteriv(int target, int pname, int[] params, int offset) {
|
|
begin("glTexParameteriv");
|
|
arg("target", getTextureTarget(target));
|
|
arg("pname", getTexturePName(pname));
|
|
arg("params", 4, params, offset);
|
|
end();
|
|
|
|
mgl11.glTexParameteriv(target, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexParameteriv(int target, int pname, IntBuffer params) {
|
|
begin("glTexParameteriv");
|
|
arg("target", getTextureTarget(target));
|
|
arg("pname", getTexturePName(pname));
|
|
arg("params", 4, params);
|
|
end();
|
|
|
|
mgl11.glTexParameteriv(target, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexSubImage2D(int target, int level, int xoffset,
|
|
int yoffset, int width, int height, int format, int type,
|
|
Buffer pixels) {
|
|
begin("glTexSubImage2D");
|
|
arg("target", getTextureTarget(target));
|
|
arg("level", level);
|
|
arg("xoffset", xoffset);
|
|
arg("yoffset", yoffset);
|
|
arg("width", width);
|
|
arg("height", height);
|
|
arg("format", format);
|
|
arg("type", type);
|
|
arg("pixels", pixels.toString());
|
|
end();
|
|
mgl.glTexSubImage2D(target, level, xoffset, yoffset, width, height,
|
|
format, type, pixels);
|
|
checkError();
|
|
}
|
|
|
|
public void glTranslatef(float x, float y, float z) {
|
|
begin("glTranslatef");
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("z", z);
|
|
end();
|
|
mgl.glTranslatef(x, y, z);
|
|
checkError();
|
|
}
|
|
|
|
public void glTranslatex(int x, int y, int z) {
|
|
begin("glTranslatex");
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("z", z);
|
|
end();
|
|
mgl.glTranslatex(x, y, z);
|
|
checkError();
|
|
}
|
|
|
|
public void glVertexPointer(int size, int type, int stride, Buffer pointer) {
|
|
begin("glVertexPointer");
|
|
argPointer(size, type, stride, pointer);
|
|
end();
|
|
mVertexPointer = new PointerInfo(size, type, stride, pointer);
|
|
mgl.glVertexPointer(size, type, stride, pointer);
|
|
checkError();
|
|
}
|
|
|
|
public void glViewport(int x, int y, int width, int height) {
|
|
begin("glViewport");
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("width", width);
|
|
arg("height", height);
|
|
end();
|
|
mgl.glViewport(x, y, width, height);
|
|
checkError();
|
|
}
|
|
|
|
public void glClipPlanef(int plane, float[] equation, int offset) {
|
|
begin("glClipPlanef");
|
|
arg("plane", plane);
|
|
arg("equation", 4, equation, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glClipPlanef(plane, equation, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glClipPlanef(int plane, FloatBuffer equation) {
|
|
begin("glClipPlanef");
|
|
arg("plane", plane);
|
|
arg("equation", 4, equation);
|
|
end();
|
|
mgl11.glClipPlanef(plane, equation);
|
|
checkError();
|
|
}
|
|
|
|
public void glClipPlanex(int plane, int[] equation, int offset) {
|
|
begin("glClipPlanex");
|
|
arg("plane", plane);
|
|
arg("equation", 4, equation, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glClipPlanex(plane, equation, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glClipPlanex(int plane, IntBuffer equation) {
|
|
begin("glClipPlanef");
|
|
arg("plane", plane);
|
|
arg("equation", 4, equation);
|
|
end();
|
|
mgl11.glClipPlanex(plane, equation);
|
|
checkError();
|
|
}
|
|
|
|
// Draw Texture Extension
|
|
|
|
public void glDrawTexfOES(float x, float y, float z,
|
|
float width, float height) {
|
|
begin("glDrawTexfOES");
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("z", z);
|
|
arg("width", width);
|
|
arg("height", height);
|
|
end();
|
|
mgl11Ext.glDrawTexfOES(x, y, z, width, height);
|
|
checkError();
|
|
}
|
|
|
|
public void glDrawTexfvOES(float[] coords, int offset) {
|
|
begin("glDrawTexfvOES");
|
|
arg("coords", 5, coords, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11Ext.glDrawTexfvOES(coords, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glDrawTexfvOES(FloatBuffer coords) {
|
|
begin("glDrawTexfvOES");
|
|
arg("coords", 5, coords);
|
|
end();
|
|
mgl11Ext.glDrawTexfvOES(coords);
|
|
checkError();
|
|
}
|
|
|
|
public void glDrawTexiOES(int x, int y, int z, int width, int height) {
|
|
begin("glDrawTexiOES");
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("z", z);
|
|
arg("width", width);
|
|
arg("height", height);
|
|
end();
|
|
mgl11Ext.glDrawTexiOES(x, y, z, width, height);
|
|
checkError();
|
|
}
|
|
|
|
public void glDrawTexivOES(int[] coords, int offset) {
|
|
begin("glDrawTexivOES");
|
|
arg("coords", 5, coords, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11Ext.glDrawTexivOES(coords, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glDrawTexivOES(IntBuffer coords) {
|
|
begin("glDrawTexivOES");
|
|
arg("coords", 5, coords);
|
|
end();
|
|
mgl11Ext.glDrawTexivOES(coords);
|
|
checkError();
|
|
}
|
|
|
|
public void glDrawTexsOES(short x, short y, short z,
|
|
short width, short height) {
|
|
begin("glDrawTexsOES");
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("z", z);
|
|
arg("width", width);
|
|
arg("height", height);
|
|
end();
|
|
mgl11Ext.glDrawTexsOES(x, y, z, width, height);
|
|
checkError();
|
|
}
|
|
|
|
public void glDrawTexsvOES(short[] coords, int offset) {
|
|
begin("glDrawTexsvOES");
|
|
arg("coords", 5, coords, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11Ext.glDrawTexsvOES(coords, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glDrawTexsvOES(ShortBuffer coords) {
|
|
begin("glDrawTexsvOES");
|
|
arg("coords", 5, coords);
|
|
end();
|
|
mgl11Ext.glDrawTexsvOES(coords);
|
|
checkError();
|
|
}
|
|
|
|
public void glDrawTexxOES(int x, int y, int z, int width, int height) {
|
|
begin("glDrawTexxOES");
|
|
arg("x", x);
|
|
arg("y", y);
|
|
arg("z", z);
|
|
arg("width", width);
|
|
arg("height", height);
|
|
end();
|
|
mgl11Ext.glDrawTexxOES(x, y, z, width, height);
|
|
checkError();
|
|
}
|
|
|
|
public void glDrawTexxvOES(int[] coords, int offset) {
|
|
begin("glDrawTexxvOES");
|
|
arg("coords", 5, coords, offset);
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11Ext.glDrawTexxvOES(coords, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glDrawTexxvOES(IntBuffer coords) {
|
|
begin("glDrawTexxvOES");
|
|
arg("coords", 5, coords);
|
|
end();
|
|
mgl11Ext.glDrawTexxvOES(coords);
|
|
checkError();
|
|
}
|
|
|
|
public int glQueryMatrixxOES(int[] mantissa, int mantissaOffset,
|
|
int[] exponent, int exponentOffset) {
|
|
begin("glQueryMatrixxOES");
|
|
arg("mantissa", Arrays.toString(mantissa));
|
|
arg("exponent", Arrays.toString(exponent));
|
|
end();
|
|
int valid = mgl10Ext.glQueryMatrixxOES(mantissa, mantissaOffset,
|
|
exponent, exponentOffset);
|
|
returns(toString(16, FORMAT_FIXED, mantissa, mantissaOffset));
|
|
returns(toString(16, FORMAT_INT, exponent, exponentOffset));
|
|
checkError();
|
|
return valid;
|
|
}
|
|
|
|
public int glQueryMatrixxOES(IntBuffer mantissa, IntBuffer exponent) {
|
|
begin("glQueryMatrixxOES");
|
|
arg("mantissa", mantissa.toString());
|
|
arg("exponent", exponent.toString());
|
|
end();
|
|
int valid = mgl10Ext.glQueryMatrixxOES(mantissa, exponent);
|
|
returns(toString(16, FORMAT_FIXED, mantissa));
|
|
returns(toString(16, FORMAT_INT, exponent));
|
|
checkError();
|
|
return valid;
|
|
}
|
|
|
|
public void glBindBuffer(int target, int buffer) {
|
|
begin("glBindBuffer");
|
|
arg("target", target);
|
|
arg("buffer", buffer);
|
|
end();
|
|
mgl11.glBindBuffer(target, buffer);
|
|
checkError();
|
|
}
|
|
|
|
public void glBufferData(int target, int size, Buffer data, int usage) {
|
|
begin("glBufferData");
|
|
arg("target", target);
|
|
arg("size", size);
|
|
arg("data", data.toString());
|
|
arg("usage", usage);
|
|
end();
|
|
mgl11.glBufferData(target, size, data, usage);
|
|
checkError();
|
|
}
|
|
|
|
public void glBufferSubData(int target, int offset, int size, Buffer data) {
|
|
begin("glBufferSubData");
|
|
arg("target", target);
|
|
arg("offset", offset);
|
|
arg("size", size);
|
|
arg("data", data.toString());
|
|
end();
|
|
mgl11.glBufferSubData(target, offset, size, data);
|
|
checkError();
|
|
}
|
|
|
|
public void glColor4ub(byte red, byte green, byte blue, byte alpha) {
|
|
begin("glColor4ub");
|
|
arg("red", red);
|
|
arg("green", green);
|
|
arg("blue", blue);
|
|
arg("alpha", alpha);
|
|
end();
|
|
mgl11.glColor4ub(red, green, blue, alpha);
|
|
checkError();
|
|
}
|
|
|
|
public void glDeleteBuffers(int n, int[] buffers, int offset) {
|
|
begin("glDeleteBuffers");
|
|
arg("n", n);
|
|
arg("buffers", buffers.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glDeleteBuffers(n, buffers, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glDeleteBuffers(int n, IntBuffer buffers) {
|
|
begin("glDeleteBuffers");
|
|
arg("n", n);
|
|
arg("buffers", buffers.toString());
|
|
end();
|
|
mgl11.glDeleteBuffers(n, buffers);
|
|
checkError();
|
|
}
|
|
|
|
public void glGenBuffers(int n, int[] buffers, int offset) {
|
|
begin("glGenBuffers");
|
|
arg("n", n);
|
|
arg("buffers", buffers.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGenBuffers(n, buffers, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glGenBuffers(int n, IntBuffer buffers) {
|
|
begin("glGenBuffers");
|
|
arg("n", n);
|
|
arg("buffers", buffers.toString());
|
|
end();
|
|
mgl11.glGenBuffers(n, buffers);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetBooleanv(int pname, boolean[] params, int offset) {
|
|
begin("glGetBooleanv");
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetBooleanv(pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetBooleanv(int pname, IntBuffer params) {
|
|
begin("glGetBooleanv");
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glGetBooleanv(pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetBufferParameteriv(int target, int pname, int[] params,
|
|
int offset) {
|
|
begin("glGetBufferParameteriv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetBufferParameteriv(target, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetBufferParameteriv(int target, int pname, IntBuffer params) {
|
|
begin("glGetBufferParameteriv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glGetBufferParameteriv(target, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetClipPlanef(int pname, float[] eqn, int offset) {
|
|
begin("glGetClipPlanef");
|
|
arg("pname", pname);
|
|
arg("eqn", eqn.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetClipPlanef(pname, eqn, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetClipPlanef(int pname, FloatBuffer eqn) {
|
|
begin("glGetClipPlanef");
|
|
arg("pname", pname);
|
|
arg("eqn", eqn.toString());
|
|
end();
|
|
mgl11.glGetClipPlanef(pname, eqn);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetClipPlanex(int pname, int[] eqn, int offset) {
|
|
begin("glGetClipPlanex");
|
|
arg("pname", pname);
|
|
arg("eqn", eqn.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetClipPlanex(pname, eqn, offset);
|
|
}
|
|
|
|
public void glGetClipPlanex(int pname, IntBuffer eqn) {
|
|
begin("glGetClipPlanex");
|
|
arg("pname", pname);
|
|
arg("eqn", eqn.toString());
|
|
end();
|
|
mgl11.glGetClipPlanex(pname, eqn);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetFixedv(int pname, int[] params, int offset) {
|
|
begin("glGetFixedv");
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetFixedv(pname, params, offset);
|
|
}
|
|
|
|
public void glGetFixedv(int pname, IntBuffer params) {
|
|
begin("glGetFixedv");
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glGetFixedv(pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetFloatv(int pname, float[] params, int offset) {
|
|
begin("glGetFloatv");
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetFloatv(pname, params, offset);
|
|
}
|
|
|
|
public void glGetFloatv(int pname, FloatBuffer params) {
|
|
begin("glGetFloatv");
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glGetFloatv(pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetLightfv(int light, int pname, float[] params, int offset) {
|
|
begin("glGetLightfv");
|
|
arg("light", light);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetLightfv(light, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetLightfv(int light, int pname, FloatBuffer params) {
|
|
begin("glGetLightfv");
|
|
arg("light", light);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glGetLightfv(light, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetLightxv(int light, int pname, int[] params, int offset) {
|
|
begin("glGetLightxv");
|
|
arg("light", light);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetLightxv(light, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetLightxv(int light, int pname, IntBuffer params) {
|
|
begin("glGetLightxv");
|
|
arg("light", light);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glGetLightxv(light, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetMaterialfv(int face, int pname, float[] params,
|
|
int offset) {
|
|
begin("glGetMaterialfv");
|
|
arg("face", face);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetMaterialfv(face, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetMaterialfv(int face, int pname, FloatBuffer params) {
|
|
begin("glGetMaterialfv");
|
|
arg("face", face);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glGetMaterialfv(face, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetMaterialxv(int face, int pname, int[] params, int offset) {
|
|
begin("glGetMaterialxv");
|
|
arg("face", face);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetMaterialxv(face, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetMaterialxv(int face, int pname, IntBuffer params) {
|
|
begin("glGetMaterialxv");
|
|
arg("face", face);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glGetMaterialxv(face, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetTexEnviv(int env, int pname, int[] params, int offset) {
|
|
begin("glGetTexEnviv");
|
|
arg("env", env);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetTexEnviv(env, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetTexEnviv(int env, int pname, IntBuffer params) {
|
|
begin("glGetTexEnviv");
|
|
arg("env", env);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glGetTexEnviv(env, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetTexEnvxv(int env, int pname, int[] params, int offset) {
|
|
begin("glGetTexEnviv");
|
|
arg("env", env);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetTexEnviv(env, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetTexEnvxv(int env, int pname, IntBuffer params) {
|
|
begin("glGetTexEnviv");
|
|
arg("env", env);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glGetTexEnvxv(env, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetTexParameterfv(int target, int pname, float[] params, int offset) {
|
|
begin("glGetTexParameterfv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetTexParameterfv(target, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetTexParameterfv(int target, int pname, FloatBuffer params) {
|
|
begin("glGetTexParameterfv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glGetTexParameterfv(target, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetTexParameteriv(int target, int pname, int[] params, int offset) {
|
|
begin("glGetTexParameteriv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetTexEnviv(target, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetTexParameteriv(int target, int pname, IntBuffer params) {
|
|
begin("glGetTexParameteriv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glGetTexParameteriv(target, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetTexParameterxv(int target, int pname, int[] params,
|
|
int offset) {
|
|
begin("glGetTexParameterxv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glGetTexParameterxv(target, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetTexParameterxv(int target, int pname, IntBuffer params) {
|
|
begin("glGetTexParameterxv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glGetTexParameterxv(target, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public boolean glIsBuffer(int buffer) {
|
|
begin("glIsBuffer");
|
|
arg("buffer", buffer);
|
|
end();
|
|
boolean result = mgl11.glIsBuffer(buffer);
|
|
checkError();
|
|
return result;
|
|
}
|
|
|
|
public boolean glIsEnabled(int cap) {
|
|
begin("glIsEnabled");
|
|
arg("cap", cap);
|
|
end();
|
|
boolean result = mgl11.glIsEnabled(cap);
|
|
checkError();
|
|
return result;
|
|
}
|
|
|
|
public boolean glIsTexture(int texture) {
|
|
begin("glIsTexture");
|
|
arg("texture", texture);
|
|
end();
|
|
boolean result = mgl11.glIsTexture(texture);
|
|
checkError();
|
|
return result;
|
|
}
|
|
|
|
public void glPointParameterf(int pname, float param) {
|
|
begin("glPointParameterf");
|
|
arg("pname", pname);
|
|
arg("param", param);
|
|
end();
|
|
mgl11.glPointParameterf( pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glPointParameterfv(int pname, float[] params, int offset) {
|
|
begin("glPointParameterfv");
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glPointParameterfv(pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glPointParameterfv(int pname, FloatBuffer params) {
|
|
begin("glPointParameterfv");
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glPointParameterfv(pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glPointParameterx(int pname, int param) {
|
|
begin("glPointParameterfv");
|
|
arg("pname", pname);
|
|
arg("param", param);
|
|
end();
|
|
mgl11.glPointParameterx( pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glPointParameterxv(int pname, int[] params, int offset) {
|
|
begin("glPointParameterxv");
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glPointParameterxv(pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glPointParameterxv(int pname, IntBuffer params) {
|
|
begin("glPointParameterxv");
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glPointParameterxv( pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glPointSizePointerOES(int type, int stride, Buffer pointer) {
|
|
begin("glPointSizePointerOES");
|
|
arg("type", type);
|
|
arg("stride", stride);
|
|
arg("params", pointer.toString());
|
|
end();
|
|
mgl11.glPointSizePointerOES( type, stride, pointer);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexEnvi(int target, int pname, int param) {
|
|
begin("glTexEnvi");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("param", param);
|
|
end();
|
|
mgl11.glTexEnvi(target, pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexEnviv(int target, int pname, int[] params, int offset) {
|
|
begin("glTexEnviv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glTexEnviv(target, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexEnviv(int target, int pname, IntBuffer params) {
|
|
begin("glTexEnviv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glTexEnviv( target, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexParameterfv(int target, int pname, float[] params,
|
|
int offset) {
|
|
begin("glTexParameterfv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glTexParameterfv( target, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexParameterfv(int target, int pname, FloatBuffer params) {
|
|
begin("glTexParameterfv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glTexParameterfv(target, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexParameteri(int target, int pname, int param) {
|
|
begin("glTexParameterxv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("param", param);
|
|
end();
|
|
mgl11.glTexParameteri(target, pname, param);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexParameterxv(int target, int pname, int[] params,
|
|
int offset) {
|
|
begin("glTexParameterxv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glTexParameterxv(target, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glTexParameterxv(int target, int pname, IntBuffer params) {
|
|
begin("glTexParameterxv");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glTexParameterxv(target, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
|
|
public void glColorPointer(int size, int type, int stride, int offset) {
|
|
begin("glColorPointer");
|
|
arg("size", size);
|
|
arg("type", type);
|
|
arg("stride", stride);
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glColorPointer(size, type, stride, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glDrawElements(int mode, int count, int type, int offset) {
|
|
begin("glDrawElements");
|
|
arg("mode", mode);
|
|
arg("count", count);
|
|
arg("type", type);
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glDrawElements(mode, count, type, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glGetPointerv(int pname, Buffer[] params) {
|
|
begin("glGetPointerv");
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11.glGetPointerv(pname, params);
|
|
checkError();
|
|
}
|
|
|
|
public void glNormalPointer(int type, int stride, int offset) {
|
|
begin("glNormalPointer");
|
|
arg("type", type);
|
|
arg("stride", stride);
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glNormalPointer(type, stride, offset);
|
|
}
|
|
|
|
public void glTexCoordPointer(int size, int type, int stride, int offset) {
|
|
begin("glTexCoordPointer");
|
|
arg("size", size);
|
|
arg("type", type);
|
|
arg("stride", stride);
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glTexCoordPointer(size, type, stride, offset);
|
|
}
|
|
|
|
public void glVertexPointer(int size, int type, int stride, int offset) {
|
|
begin("glVertexPointer");
|
|
arg("size", size);
|
|
arg("type", type);
|
|
arg("stride", stride);
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11.glVertexPointer(size, type, stride, offset);
|
|
}
|
|
|
|
public void glCurrentPaletteMatrixOES(int matrixpaletteindex) {
|
|
begin("glCurrentPaletteMatrixOES");
|
|
arg("matrixpaletteindex", matrixpaletteindex);
|
|
end();
|
|
mgl11Ext.glCurrentPaletteMatrixOES(matrixpaletteindex);
|
|
checkError();
|
|
}
|
|
|
|
public void glLoadPaletteFromModelViewMatrixOES() {
|
|
begin("glLoadPaletteFromModelViewMatrixOES");
|
|
end();
|
|
mgl11Ext.glLoadPaletteFromModelViewMatrixOES();
|
|
checkError();
|
|
}
|
|
|
|
public void glMatrixIndexPointerOES(int size, int type, int stride,
|
|
Buffer pointer) {
|
|
begin("glMatrixIndexPointerOES");
|
|
argPointer(size, type, stride, pointer);
|
|
end();
|
|
mgl11Ext.glMatrixIndexPointerOES(size, type, stride, pointer);
|
|
checkError();
|
|
}
|
|
|
|
public void glMatrixIndexPointerOES(int size, int type, int stride,
|
|
int offset) {
|
|
begin("glMatrixIndexPointerOES");
|
|
arg("size", size);
|
|
arg("type", type);
|
|
arg("stride", stride);
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11Ext.glMatrixIndexPointerOES(size, type, stride, offset);
|
|
checkError();
|
|
}
|
|
|
|
public void glWeightPointerOES(int size, int type, int stride,
|
|
Buffer pointer) {
|
|
begin("glWeightPointerOES");
|
|
argPointer(size, type, stride, pointer);
|
|
end();
|
|
mgl11Ext.glWeightPointerOES(size, type, stride, pointer);
|
|
checkError();
|
|
}
|
|
|
|
public void glWeightPointerOES(int size, int type, int stride, int offset) {
|
|
begin("glWeightPointerOES");
|
|
arg("size", size);
|
|
arg("type", type);
|
|
arg("stride", stride);
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11Ext.glWeightPointerOES(size, type, stride, offset);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glBindFramebufferOES(int target, int framebuffer) {
|
|
begin("glBindFramebufferOES");
|
|
arg("target", target);
|
|
arg("framebuffer", framebuffer);
|
|
end();
|
|
mgl11ExtensionPack.glBindFramebufferOES(target, framebuffer);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glBindRenderbufferOES(int target, int renderbuffer) {
|
|
begin("glBindRenderbufferOES");
|
|
arg("target", target);
|
|
arg("renderbuffer", renderbuffer);
|
|
end();
|
|
mgl11ExtensionPack.glBindRenderbufferOES(target, renderbuffer);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glBlendEquation(int mode) {
|
|
begin("glBlendEquation");
|
|
arg("mode", mode);
|
|
end();
|
|
mgl11ExtensionPack.glBlendEquation(mode);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glBlendEquationSeparate(int modeRGB, int modeAlpha) {
|
|
begin("glBlendEquationSeparate");
|
|
arg("modeRGB", modeRGB);
|
|
arg("modeAlpha", modeAlpha);
|
|
end();
|
|
mgl11ExtensionPack.glBlendEquationSeparate(modeRGB, modeAlpha);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glBlendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha,
|
|
int dstAlpha) {
|
|
begin("glBlendFuncSeparate");
|
|
arg("srcRGB", srcRGB);
|
|
arg("dstRGB", dstRGB);
|
|
arg("srcAlpha", srcAlpha);
|
|
arg("dstAlpha", dstAlpha);
|
|
end();
|
|
mgl11ExtensionPack.glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public int glCheckFramebufferStatusOES(int target) {
|
|
begin("glCheckFramebufferStatusOES");
|
|
arg("target", target);
|
|
end();
|
|
int result = mgl11ExtensionPack.glCheckFramebufferStatusOES(target);
|
|
checkError();
|
|
return result;
|
|
}
|
|
|
|
@Override
|
|
public void glDeleteFramebuffersOES(int n, int[] framebuffers, int offset) {
|
|
begin("glDeleteFramebuffersOES");
|
|
arg("n", n);
|
|
arg("framebuffers", framebuffers.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11ExtensionPack.glDeleteFramebuffersOES(n, framebuffers, offset);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glDeleteFramebuffersOES(int n, IntBuffer framebuffers) {
|
|
begin("glDeleteFramebuffersOES");
|
|
arg("n", n);
|
|
arg("framebuffers", framebuffers.toString());
|
|
end();
|
|
mgl11ExtensionPack.glDeleteFramebuffersOES(n, framebuffers);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glDeleteRenderbuffersOES(int n, int[] renderbuffers, int offset) {
|
|
begin("glDeleteRenderbuffersOES");
|
|
arg("n", n);
|
|
arg("renderbuffers", renderbuffers.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11ExtensionPack.glDeleteRenderbuffersOES(n, renderbuffers, offset);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glDeleteRenderbuffersOES(int n, IntBuffer renderbuffers) {
|
|
begin("glDeleteRenderbuffersOES");
|
|
arg("n", n);
|
|
arg("renderbuffers", renderbuffers.toString());
|
|
end();
|
|
mgl11ExtensionPack.glDeleteRenderbuffersOES(n, renderbuffers);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glFramebufferRenderbufferOES(int target, int attachment,
|
|
int renderbuffertarget, int renderbuffer) {
|
|
begin("glFramebufferRenderbufferOES");
|
|
arg("target", target);
|
|
arg("attachment", attachment);
|
|
arg("renderbuffertarget", renderbuffertarget);
|
|
arg("renderbuffer", renderbuffer);
|
|
end();
|
|
mgl11ExtensionPack.glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glFramebufferTexture2DOES(int target, int attachment,
|
|
int textarget, int texture, int level) {
|
|
begin("glFramebufferTexture2DOES");
|
|
arg("target", target);
|
|
arg("attachment", attachment);
|
|
arg("textarget", textarget);
|
|
arg("texture", texture);
|
|
arg("level", level);
|
|
end();
|
|
mgl11ExtensionPack.glFramebufferTexture2DOES(target, attachment, textarget, texture, level);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGenerateMipmapOES(int target) {
|
|
begin("glGenerateMipmapOES");
|
|
arg("target", target);
|
|
end();
|
|
mgl11ExtensionPack.glGenerateMipmapOES(target);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGenFramebuffersOES(int n, int[] framebuffers, int offset) {
|
|
begin("glGenFramebuffersOES");
|
|
arg("n", n);
|
|
arg("framebuffers", framebuffers.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11ExtensionPack.glGenFramebuffersOES(n, framebuffers, offset);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGenFramebuffersOES(int n, IntBuffer framebuffers) {
|
|
begin("glGenFramebuffersOES");
|
|
arg("n", n);
|
|
arg("framebuffers", framebuffers.toString());
|
|
end();
|
|
mgl11ExtensionPack.glGenFramebuffersOES(n, framebuffers);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGenRenderbuffersOES(int n, int[] renderbuffers, int offset) {
|
|
begin("glGenRenderbuffersOES");
|
|
arg("n", n);
|
|
arg("renderbuffers", renderbuffers.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11ExtensionPack.glGenRenderbuffersOES(n, renderbuffers, offset);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGenRenderbuffersOES(int n, IntBuffer renderbuffers) {
|
|
begin("glGenRenderbuffersOES");
|
|
arg("n", n);
|
|
arg("renderbuffers", renderbuffers.toString());
|
|
end();
|
|
mgl11ExtensionPack.glGenRenderbuffersOES(n, renderbuffers);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGetFramebufferAttachmentParameterivOES(int target,
|
|
int attachment, int pname, int[] params, int offset) {
|
|
begin("glGetFramebufferAttachmentParameterivOES");
|
|
arg("target", target);
|
|
arg("attachment", attachment);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11ExtensionPack.glGetFramebufferAttachmentParameterivOES(target, attachment, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGetFramebufferAttachmentParameterivOES(int target,
|
|
int attachment, int pname, IntBuffer params) {
|
|
begin("glGetFramebufferAttachmentParameterivOES");
|
|
arg("target", target);
|
|
arg("attachment", attachment);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11ExtensionPack.glGetFramebufferAttachmentParameterivOES(target, attachment, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGetRenderbufferParameterivOES(int target, int pname,
|
|
int[] params, int offset) {
|
|
begin("glGetRenderbufferParameterivOES");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11ExtensionPack.glGetRenderbufferParameterivOES(target, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGetRenderbufferParameterivOES(int target, int pname,
|
|
IntBuffer params) {
|
|
begin("glGetRenderbufferParameterivOES");
|
|
arg("target", target);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11ExtensionPack.glGetRenderbufferParameterivOES(target, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGetTexGenfv(int coord, int pname, float[] params, int offset) {
|
|
begin("glGetTexGenfv");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11ExtensionPack.glGetTexGenfv(coord, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGetTexGenfv(int coord, int pname, FloatBuffer params) {
|
|
begin("glGetTexGenfv");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11ExtensionPack.glGetTexGenfv(coord, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGetTexGeniv(int coord, int pname, int[] params, int offset) {
|
|
begin("glGetTexGeniv");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11ExtensionPack.glGetTexGeniv(coord, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGetTexGeniv(int coord, int pname, IntBuffer params) {
|
|
begin("glGetTexGeniv");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11ExtensionPack.glGetTexGeniv(coord, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGetTexGenxv(int coord, int pname, int[] params, int offset) {
|
|
begin("glGetTexGenxv");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11ExtensionPack.glGetTexGenxv(coord, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glGetTexGenxv(int coord, int pname, IntBuffer params) {
|
|
begin("glGetTexGenxv");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11ExtensionPack.glGetTexGenxv(coord, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public boolean glIsFramebufferOES(int framebuffer) {
|
|
begin("glIsFramebufferOES");
|
|
arg("framebuffer", framebuffer);
|
|
end();
|
|
boolean result = mgl11ExtensionPack.glIsFramebufferOES(framebuffer);
|
|
checkError();
|
|
return result;
|
|
}
|
|
|
|
@Override
|
|
public boolean glIsRenderbufferOES(int renderbuffer) {
|
|
begin("glIsRenderbufferOES");
|
|
arg("renderbuffer", renderbuffer);
|
|
end();
|
|
mgl11ExtensionPack.glIsRenderbufferOES(renderbuffer);
|
|
checkError();
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void glRenderbufferStorageOES(int target, int internalformat,
|
|
int width, int height) {
|
|
begin("glRenderbufferStorageOES");
|
|
arg("target", target);
|
|
arg("internalformat", internalformat);
|
|
arg("width", width);
|
|
arg("height", height);
|
|
end();
|
|
mgl11ExtensionPack.glRenderbufferStorageOES(target, internalformat, width, height);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glTexGenf(int coord, int pname, float param) {
|
|
begin("glTexGenf");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("param", param);
|
|
end();
|
|
mgl11ExtensionPack.glTexGenf(coord, pname, param);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glTexGenfv(int coord, int pname, float[] params, int offset) {
|
|
begin("glTexGenfv");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11ExtensionPack.glTexGenfv(coord, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glTexGenfv(int coord, int pname, FloatBuffer params) {
|
|
begin("glTexGenfv");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11ExtensionPack.glTexGenfv(coord, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glTexGeni(int coord, int pname, int param) {
|
|
begin("glTexGeni");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("param", param);
|
|
end();
|
|
mgl11ExtensionPack.glTexGeni(coord, pname, param);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glTexGeniv(int coord, int pname, int[] params, int offset) {
|
|
begin("glTexGeniv");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11ExtensionPack.glTexGeniv(coord, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glTexGeniv(int coord, int pname, IntBuffer params) {
|
|
begin("glTexGeniv");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11ExtensionPack.glTexGeniv(coord, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glTexGenx(int coord, int pname, int param) {
|
|
begin("glTexGenx");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("param", param);
|
|
end();
|
|
mgl11ExtensionPack.glTexGenx(coord, pname, param);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glTexGenxv(int coord, int pname, int[] params, int offset) {
|
|
begin("glTexGenxv");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
arg("offset", offset);
|
|
end();
|
|
mgl11ExtensionPack.glTexGenxv(coord, pname, params, offset);
|
|
checkError();
|
|
}
|
|
|
|
@Override
|
|
public void glTexGenxv(int coord, int pname, IntBuffer params) {
|
|
begin("glTexGenxv");
|
|
arg("coord", coord);
|
|
arg("pname", pname);
|
|
arg("params", params.toString());
|
|
end();
|
|
mgl11ExtensionPack.glTexGenxv(coord, pname, params);
|
|
checkError();
|
|
}
|
|
|
|
private class PointerInfo {
|
|
/**
|
|
* The number of coordinates per vertex. 1..4
|
|
*/
|
|
public int mSize;
|
|
/**
|
|
* The type of each coordinate.
|
|
*/
|
|
public int mType;
|
|
/**
|
|
* The byte offset between consecutive vertices. 0 means mSize *
|
|
* sizeof(mType)
|
|
*/
|
|
public int mStride;
|
|
public Buffer mPointer;
|
|
public ByteBuffer mTempByteBuffer; // Only valid during glDrawXXX calls
|
|
|
|
public PointerInfo() {
|
|
}
|
|
|
|
public PointerInfo(int size, int type, int stride, Buffer pointer) {
|
|
mSize = size;
|
|
mType = type;
|
|
mStride = stride;
|
|
mPointer = pointer;
|
|
}
|
|
|
|
public int sizeof(int type) {
|
|
switch (type) {
|
|
case GL_UNSIGNED_BYTE:
|
|
return 1;
|
|
case GL_BYTE:
|
|
return 1;
|
|
case GL_SHORT:
|
|
return 2;
|
|
case GL_FIXED:
|
|
return 4;
|
|
case GL_FLOAT:
|
|
return 4;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public int getStride() {
|
|
return mStride > 0 ? mStride : sizeof(mType) * mSize;
|
|
}
|
|
|
|
public void bindByteBuffer() {
|
|
mTempByteBuffer = mPointer == null ? null : toByteBuffer(-1, mPointer);
|
|
}
|
|
|
|
public void unbindByteBuffer() {
|
|
mTempByteBuffer = null;
|
|
}
|
|
}
|
|
|
|
private Writer mLog;
|
|
private boolean mLogArgumentNames;
|
|
private int mArgCount;
|
|
|
|
private PointerInfo mColorPointer = new PointerInfo();
|
|
private PointerInfo mNormalPointer = new PointerInfo();
|
|
private PointerInfo mTexCoordPointer = new PointerInfo();
|
|
private PointerInfo mVertexPointer = new PointerInfo();
|
|
|
|
boolean mColorArrayEnabled;
|
|
boolean mNormalArrayEnabled;
|
|
boolean mTextureCoordArrayEnabled;
|
|
boolean mVertexArrayEnabled;
|
|
|
|
StringBuilder mStringBuilder;
|
|
}
|