/*
* Copyright 1990-2007 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License version
* 2 only, as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License version 2 for more details (a copy is
* included at /legal/license.txt).
*
* You should have received a copy of the GNU General Public License
* version 2 along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
* Clara, CA 95054 or visit www.sun.com if you need additional
* information or have any questions.
*/
package javax.microedition.khronos.opengles;
import java.nio.*;
/**
* The <code>GL10</code> interface contains the Java(TM) programming
* language bindings for OpenGL(R) ES 1.0 core functionality.
*
* <p> The <code>OES_byte_coordinates</code>,
* <code>OES_single_precision</code>, <code>OES_fixed_point</code>,
* <code>OES_read_format</code>, and
* <code>OES_compressed_paletted_texture</code> extensions are
* included as part of this interface.
*
* <p> Methods with an <code>x</code> or <code>xv</code> suffix belong
* to the <code>OES_fixed_point</code> extension and take one or more
* fixed-point arguments. Fixed-point arguments may be derived from
* floating-point values by multiplying by 65536 (2^16) and rounding
* to the nearest integer.
*
* <p> For ease of use, this interface documents method behavior for
* all versions of OpenGL ES including version 1.1 and extensions.
* When running on an OpenGL ES 1.0 implementation, sections marked
* "(1.1 only)" should be disregarded.
*
* <p> See the <code>GL</code> interface for a description of how to
* obtain an instance of this interface.
*/
public interface GL10 extends GL {
// ClearBufferMask
/** OpenGL ES 1.0 constant. */
int GL_DEPTH_BUFFER_BIT = 0x00000100;
/** OpenGL ES 1.0 constant. */
int GL_STENCIL_BUFFER_BIT = 0x00000400;
/** OpenGL ES 1.0 constant. */
int GL_COLOR_BUFFER_BIT = 0x00004000;
// Boolean
/** OpenGL ES 1.0 constant. */
int GL_FALSE = 0;
/** OpenGL ES 1.0 constant. */
int GL_TRUE = 1;
// BeginMode
/** OpenGL ES 1.0 constant. */
int GL_POINTS = 0x0000;
/** OpenGL ES 1.0 constant. */
int GL_LINES = 0x0001;
/** OpenGL ES 1.0 constant. */
int GL_LINE_LOOP = 0x0002;
/** OpenGL ES 1.0 constant. */
int GL_LINE_STRIP = 0x0003;
/** OpenGL ES 1.0 constant. */
int GL_TRIANGLES = 0x0004;
/** OpenGL ES 1.0 constant. */
int GL_TRIANGLE_STRIP = 0x0005;
/** OpenGL ES 1.0 constant. */
int GL_TRIANGLE_FAN = 0x0006;
// AlphaFunction
/** OpenGL ES 1.0 constant. */
int GL_NEVER = 0x0200;
/** OpenGL ES 1.0 constant. */
int GL_LESS = 0x0201;
/** OpenGL ES 1.0 constant. */
int GL_EQUAL = 0x0202;
/** OpenGL ES 1.0 constant. */
int GL_LEQUAL = 0x0203;
/** OpenGL ES 1.0 constant. */
int GL_GREATER = 0x0204;
/** OpenGL ES 1.0 constant. */
int GL_NOTEQUAL = 0x0205;
/** OpenGL ES 1.0 constant. */
int GL_GEQUAL = 0x0206;
/** OpenGL ES 1.0 constant. */
int GL_ALWAYS = 0x0207;
// BlendingFactorDest
/** OpenGL ES 1.0 constant. */
int GL_ZERO = 0;
/** OpenGL ES 1.0 constant. */
int GL_ONE = 1;
/** OpenGL ES 1.0 constant. */
int GL_SRC_COLOR = 0x0300;
/** OpenGL ES 1.0 constant. */
int GL_ONE_MINUS_SRC_COLOR = 0x0301;
/** OpenGL ES 1.0 constant. */
int GL_SRC_ALPHA = 0x0302;
/** OpenGL ES 1.0 constant. */
int GL_ONE_MINUS_SRC_ALPHA = 0x0303;
/** OpenGL ES 1.0 constant. */
int GL_DST_ALPHA = 0x0304;
/** OpenGL ES 1.0 constant. */
int GL_ONE_MINUS_DST_ALPHA = 0x0305;
// BlendingFactorSrc
/** OpenGL ES 1.0 constant. */
int GL_DST_COLOR = 0x0306;
/** OpenGL ES 1.0 constant. */
int GL_ONE_MINUS_DST_COLOR = 0x0307;
/** OpenGL ES 1.0 constant. */
int GL_SRC_ALPHA_SATURATE = 0x0308;
// CullFaceMode
/** OpenGL ES 1.0 constant. */
int GL_FRONT = 0x0404;
/** OpenGL ES 1.0 constant. */
int GL_BACK = 0x0405;
/** OpenGL ES 1.0 constant. */
int GL_FRONT_AND_BACK = 0x0408;
// EnableCap
/** OpenGL ES 1.0 constant. */
int GL_FOG = 0x0B60;
/** OpenGL ES 1.0 constant. */
int GL_LIGHTING = 0x0B50;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE_2D = 0x0DE1;
/** OpenGL ES 1.0 constant. */
int GL_CULL_FACE = 0x0B44;
/** OpenGL ES 1.0 constant. */
int GL_ALPHA_TEST = 0x0BC0;
/** OpenGL ES 1.0 constant. */
int GL_BLEND = 0x0BE2;
/** OpenGL ES 1.0 constant. */
int GL_COLOR_LOGIC_OP = 0x0BF2;
/** OpenGL ES 1.0 constant. */
int GL_DITHER = 0x0BD0;
/** OpenGL ES 1.0 constant. */
int GL_STENCIL_TEST = 0x0B90;
/** OpenGL ES 1.0 constant. */
int GL_DEPTH_TEST = 0x0B71;
/** OpenGL ES 1.0 constant. */
int GL_POINT_SMOOTH = 0x0B10;
/** OpenGL ES 1.0 constant. */
int GL_LINE_SMOOTH = 0x0B20;
/** OpenGL ES 1.0 constant. */
int GL_SCISSOR_TEST = 0x0C11;
/** OpenGL ES 1.0 constant. */
int GL_COLOR_MATERIAL = 0x0B57;
/** OpenGL ES 1.0 constant. */
int GL_NORMALIZE = 0x0BA1;
/** OpenGL ES 1.0 constant. */
int GL_RESCALE_NORMAL = 0x803A;
/** OpenGL ES 1.0 constant. */
int GL_POLYGON_OFFSET_FILL = 0x8037;
/** OpenGL ES 1.0 constant. */
int GL_VERTEX_ARRAY = 0x8074;
/** OpenGL ES 1.0 constant. */
int GL_NORMAL_ARRAY = 0x8075;
/** OpenGL ES 1.0 constant. */
int GL_COLOR_ARRAY = 0x8076;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE_COORD_ARRAY = 0x8078;
/** OpenGL ES 1.0 constant. */
int GL_MULTISAMPLE = 0x809D;
/** OpenGL ES 1.0 constant. */
int GL_SAMPLE_ALPHA_TO_COVERAGE = 0x809E;
/** OpenGL ES 1.0 constant. */
int GL_SAMPLE_ALPHA_TO_ONE = 0x809F;
/** OpenGL ES 1.0 constant. */
int GL_SAMPLE_COVERAGE = 0x80A0;
// ErrorCode
/** OpenGL ES 1.0 constant. */
int GL_NO_ERROR = 0;
/** OpenGL ES 1.0 constant. */
int GL_INVALID_ENUM = 0x0500;
/** OpenGL ES 1.0 constant. */
int GL_INVALID_VALUE = 0x0501;
/** OpenGL ES 1.0 constant. */
int GL_INVALID_OPERATION = 0x0502;
/** OpenGL ES 1.0 constant. */
int GL_STACK_OVERFLOW = 0x0503;
/** OpenGL ES 1.0 constant. */
int GL_STACK_UNDERFLOW = 0x0504;
/** OpenGL ES 1.0 constant. */
int GL_OUT_OF_MEMORY = 0x0505;
// FogMode
/** OpenGL ES 1.0 constant. */
int GL_EXP = 0x0800;
/** OpenGL ES 1.0 constant. */
int GL_EXP2 = 0x0801;
// FogParameter
/** OpenGL ES 1.0 constant. */
int GL_FOG_DENSITY = 0x0B62;
/** OpenGL ES 1.0 constant. */
int GL_FOG_START = 0x0B63;
/** OpenGL ES 1.0 constant. */
int GL_FOG_END = 0x0B64;
/** OpenGL ES 1.0 constant. */
int GL_FOG_MODE = 0x0B65;
/** OpenGL ES 1.0 constant. */
int GL_FOG_COLOR = 0x0B66;
// FrontFaceDirection
/** OpenGL ES 1.0 constant. */
int GL_CW = 0x0900;
/** OpenGL ES 1.0 constant. */
int GL_CCW = 0x0901;
// GetPName
/** OpenGL ES 1.0 constant. */
int GL_SMOOTH_POINT_SIZE_RANGE = 0x0B12;
/** OpenGL ES 1.0 constant. */
int GL_SMOOTH_LINE_WIDTH_RANGE = 0x0B22;
/** OpenGL ES 1.0 constant. */
int GL_ALIASED_POINT_SIZE_RANGE = 0x846D;
/** OpenGL ES 1.0 constant. */
int GL_ALIASED_LINE_WIDTH_RANGE = 0x846E;
/** OpenGL ES 1.0 constant. */
int GL_IMPLEMENTATION_COLOR_READ_TYPE_OES = 0x8B9A;
/** OpenGL ES 1.0 constant. */
int GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES = 0x8B9B;
/** OpenGL ES 1.0 constant. */
int GL_MAX_LIGHTS = 0x0D31;
/** OpenGL ES 1.0 constant. */
int GL_MAX_TEXTURE_SIZE = 0x0D33;
/** OpenGL ES 1.0 constant. */
int GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36;
/** OpenGL ES 1.0 constant. */
int GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38;
/** OpenGL ES 1.0 constant. */
int GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39;
/** OpenGL ES 1.0 constant. */
int GL_MAX_VIEWPORT_DIMS = 0x0D3A;
/** OpenGL ES 1.0 constant. */
int GL_MAX_ELEMENTS_VERTICES = 0x80E8;
/** OpenGL ES 1.0 constant. */
int GL_MAX_ELEMENTS_INDICES = 0x80E9;
/** OpenGL ES 1.0 constant. */
int GL_MAX_TEXTURE_UNITS = 0x84E2;
/** OpenGL ES 1.0 constant. */
int GL_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2;
/** OpenGL ES 1.0 constant. */
int GL_COMPRESSED_TEXTURE_FORMATS = 0x86A3;
/** OpenGL ES 1.0 constant. */
int GL_SUBPIXEL_BITS = 0x0D50;
/** OpenGL ES 1.0 constant. */
int GL_RED_BITS = 0x0D52;
/** OpenGL ES 1.0 constant. */
int GL_GREEN_BITS = 0x0D53;
/** OpenGL ES 1.0 constant. */
int GL_BLUE_BITS = 0x0D54;
/** OpenGL ES 1.0 constant. */
int GL_ALPHA_BITS = 0x0D55;
/** OpenGL ES 1.0 constant. */
int GL_DEPTH_BITS = 0x0D56;
/** OpenGL ES 1.0 constant. */
int GL_STENCIL_BITS = 0x0D57;
// HintMode
/** OpenGL ES 1.0 constant. */
int GL_DONT_CARE = 0x1100;
/** OpenGL ES 1.0 constant. */
int GL_FASTEST = 0x1101;
/** OpenGL ES 1.0 constant. */
int GL_NICEST = 0x1102;
// HintTarget
/** OpenGL ES 1.0 constant. */
int GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50;
/** OpenGL ES 1.0 constant. */
int GL_POINT_SMOOTH_HINT = 0x0C51;
/** OpenGL ES 1.0 constant. */
int GL_LINE_SMOOTH_HINT = 0x0C52;
/** OpenGL ES 1.0 constant. */
int GL_POLYGON_SMOOTH_HINT = 0x0C53;
/** OpenGL ES 1.0 constant. */
int GL_FOG_HINT = 0x0C54;
// LightModelParameter
/** OpenGL ES 1.0 constant. */
int GL_LIGHT_MODEL_AMBIENT = 0x0B53;
/** OpenGL ES 1.0 constant. */
int GL_LIGHT_MODEL_TWO_SIDE = 0x0B52;
/** OpenGL ES 1.0 constant. */
// LightParameter
/** OpenGL ES 1.0 constant. */
int GL_AMBIENT = 0x1200;
/** OpenGL ES 1.0 constant. */
int GL_DIFFUSE = 0x1201;
/** OpenGL ES 1.0 constant. */
int GL_SPECULAR = 0x1202;
/** OpenGL ES 1.0 constant. */
int GL_POSITION = 0x1203;
/** OpenGL ES 1.0 constant. */
int GL_SPOT_DIRECTION = 0x1204;
/** OpenGL ES 1.0 constant. */
int GL_SPOT_EXPONENT = 0x1205;
/** OpenGL ES 1.0 constant. */
int GL_SPOT_CUTOFF = 0x1206;
/** OpenGL ES 1.0 constant. */
int GL_CONSTANT_ATTENUATION = 0x1207;
/** OpenGL ES 1.0 constant. */
int GL_LINEAR_ATTENUATION = 0x1208;
/** OpenGL ES 1.0 constant. */
int GL_QUADRATIC_ATTENUATION = 0x1209;
// DataType
/** OpenGL ES 1.0 constant. */
int GL_BYTE = 0x1400;
/** OpenGL ES 1.0 constant. */
int GL_UNSIGNED_BYTE = 0x1401;
/** OpenGL ES 1.0 constant. */
int GL_SHORT = 0x1402;
/** OpenGL ES 1.0 constant. */
int GL_UNSIGNED_SHORT = 0x1403;
/** OpenGL ES 1.0 constant. */
int GL_FLOAT = 0x1406;
/** OpenGL ES 1.0 constant. */
int GL_FIXED = 0x140C;
// LogicOp
/** OpenGL ES 1.0 constant. */
int GL_CLEAR = 0x1500;
/** OpenGL ES 1.0 constant. */
int GL_AND = 0x1501;
/** OpenGL ES 1.0 constant. */
int GL_AND_REVERSE = 0x1502;
/** OpenGL ES 1.0 constant. */
int GL_COPY = 0x1503;
/** OpenGL ES 1.0 constant. */
int GL_AND_INVERTED = 0x1504;
/** OpenGL ES 1.0 constant. */
int GL_NOOP = 0x1505;
/** OpenGL ES 1.0 constant. */
int GL_XOR = 0x1506;
/** OpenGL ES 1.0 constant. */
int GL_OR = 0x1507;
/** OpenGL ES 1.0 constant. */
int GL_NOR = 0x1508;
/** OpenGL ES 1.0 constant. */
int GL_EQUIV = 0x1509;
/** OpenGL ES 1.0 constant. */
int GL_INVERT = 0x150A;
/** OpenGL ES 1.0 constant. */
int GL_OR_REVERSE = 0x150B;
/** OpenGL ES 1.0 constant. */
int GL_COPY_INVERTED = 0x150C;
/** OpenGL ES 1.0 constant. */
int GL_OR_INVERTED = 0x150D;
/** OpenGL ES 1.0 constant. */
int GL_NAND = 0x150E;
/** OpenGL ES 1.0 constant. */
int GL_SET = 0x150F;
// MaterialParameters
/** OpenGL ES 1.0 constant. */
int GL_EMISSION = 0x1600;
/** OpenGL ES 1.0 constant. */
int GL_SHININESS = 0x1601;
/** OpenGL ES 1.0 constant. */
int GL_AMBIENT_AND_DIFFUSE = 0x1602;
// MatrixMode
/** OpenGL ES 1.0 constant. */
int GL_MODELVIEW = 0x1700;
/** OpenGL ES 1.0 constant. */
int GL_PROJECTION = 0x1701;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE = 0x1702;
// PixelFormat
/** OpenGL ES 1.0 constant. */
int GL_ALPHA = 0x1906;
/** OpenGL ES 1.0 constant. */
int GL_RGB = 0x1907;
/** OpenGL ES 1.0 constant. */
int GL_RGBA = 0x1908;
/** OpenGL ES 1.0 constant. */
int GL_LUMINANCE = 0x1909;
/** OpenGL ES 1.0 constant. */
int GL_LUMINANCE_ALPHA = 0x190A;
// PixelStoreParameter
/** OpenGL ES 1.0 constant. */
int GL_UNPACK_ALIGNMENT = 0x0CF5;
/** OpenGL ES 1.0 constant. */
int GL_PACK_ALIGNMENT = 0x0D05;
// PixelType
/** OpenGL ES 1.0 constant. */
int GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033;
/** OpenGL ES 1.0 constant. */
int GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034;
/** OpenGL ES 1.0 constant. */
int GL_UNSIGNED_SHORT_5_6_5 = 0x8363;
// ShadingModel
/** OpenGL ES 1.0 constant. */
int GL_FLAT = 0x1D00;
/** OpenGL ES 1.0 constant. */
int GL_SMOOTH = 0x1D01;
// StencilOp
/** OpenGL ES 1.0 constant. */
int GL_KEEP = 0x1E00;
/** OpenGL ES 1.0 constant. */
int GL_REPLACE = 0x1E01;
/** OpenGL ES 1.0 constant. */
int GL_INCR = 0x1E02;
/** OpenGL ES 1.0 constant. */
int GL_DECR = 0x1E03;
// StringName
/** OpenGL ES 1.0 constant. */
int GL_VENDOR = 0x1F00;
/** OpenGL ES 1.0 constant. */
int GL_RENDERER = 0x1F01;
/** OpenGL ES 1.0 constant. */
int GL_VERSION = 0x1F02;
/** OpenGL ES 1.0 constant. */
int GL_EXTENSIONS = 0x1F03;
// TextureEnvMode
/** OpenGL ES 1.0 constant. */
int GL_MODULATE = 0x2100;
/** OpenGL ES 1.0 constant. */
int GL_DECAL = 0x2101;
/** OpenGL ES 1.0 constant. */
int GL_ADD = 0x0104;
// TextureEnvParameter
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE_ENV_MODE = 0x2200;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE_ENV_COLOR = 0x2201;
// TextureEnvTarget
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE_ENV = 0x2300;
// TextureMagFilter
/** OpenGL ES 1.0 constant. */
int GL_NEAREST = 0x2600;
/** OpenGL ES 1.0 constant. */
int GL_LINEAR = 0x2601;
// TextureMinFilter
/** OpenGL ES 1.0 constant. */
int GL_NEAREST_MIPMAP_NEAREST = 0x2700;
/** OpenGL ES 1.0 constant. */
int GL_LINEAR_MIPMAP_NEAREST = 0x2701;
/** OpenGL ES 1.0 constant. */
int GL_NEAREST_MIPMAP_LINEAR = 0x2702;
/** OpenGL ES 1.0 constant. */
int GL_LINEAR_MIPMAP_LINEAR = 0x2703;
// TextureParameterName
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE_MAG_FILTER = 0x2800;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE_MIN_FILTER = 0x2801;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE_WRAP_S = 0x2802;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE_WRAP_T = 0x2803;
// TextureUnit
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE0 = 0x84C0;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE1 = 0x84C1;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE2 = 0x84C2;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE3 = 0x84C3;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE4 = 0x84C4;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE5 = 0x84C5;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE6 = 0x84C6;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE7 = 0x84C7;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE8 = 0x84C8;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE9 = 0x84C9;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE10 = 0x84CA;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE11 = 0x84CB;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE12 = 0x84CC;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE13 = 0x84CD;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE14 = 0x84CE;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE15 = 0x84CF;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE16 = 0x84D0;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE17 = 0x84D1;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE18 = 0x84D2;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE19 = 0x84D3;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE20 = 0x84D4;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE21 = 0x84D5;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE22 = 0x84D6;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE23 = 0x84D7;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE24 = 0x84D8;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE25 = 0x84D9;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE26 = 0x84DA;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE27 = 0x84DB;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE28 = 0x84DC;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE29 = 0x84DD;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE30 = 0x84DE;
/** OpenGL ES 1.0 constant. */
int GL_TEXTURE31 = 0x84DF;
// TextureWrapMode
/** OpenGL ES 1.0 constant. */
int GL_REPEAT = 0x2901;
/** OpenGL ES 1.0 constant. */
int GL_CLAMP_TO_EDGE = 0x812F;
// PixelInternalFormat
/** OpenGL ES 1.0 constant. */
int GL_PALETTE4_RGB8_OES = 0x8B90;
/** OpenGL ES 1.0 constant. */
int GL_PALETTE4_RGBA8_OES = 0x8B91;
/** OpenGL ES 1.0 constant. */
int GL_PALETTE4_R5_G6_B5_OES = 0x8B92;
/** OpenGL ES 1.0 constant. */
int GL_PALETTE4_RGBA4_OES = 0x8B93;
/** OpenGL ES 1.0 constant. */
int GL_PALETTE4_RGB5_A1_OES = 0x8B94;
/** OpenGL ES 1.0 constant. */
int GL_PALETTE8_RGB8_OES = 0x8B95;
/** OpenGL ES 1.0 constant. */
int GL_PALETTE8_RGBA8_OES = 0x8B96;
/** OpenGL ES 1.0 constant. */
int GL_PALETTE8_R5_G6_B5_OES = 0x8B97;
/** OpenGL ES 1.0 constant. */
int GL_PALETTE8_RGBA4_OES = 0x8B98;
/** OpenGL ES 1.0 constant. */
int GL_PALETTE8_RGB5_A1_OES = 0x8B99;
// LightName
/** OpenGL ES 1.0 constant. */
int GL_LIGHT0 = 0x4000;
/** OpenGL ES 1.0 constant. */
int GL_LIGHT1 = 0x4001;
/** OpenGL ES 1.0 constant. */
int GL_LIGHT2 = 0x4002;
/** OpenGL ES 1.0 constant. */
int GL_LIGHT3 = 0x4003;
/** OpenGL ES 1.0 constant. */
int GL_LIGHT4 = 0x4004;
/** OpenGL ES 1.0 constant. */
int GL_LIGHT5 = 0x4005;
/** OpenGL ES 1.0 constant. */
int GL_LIGHT6 = 0x4006;
/** OpenGL ES 1.0 constant. */
int GL_LIGHT7 = 0x4007;
/**
* Select server-side active texture unit.
*
* <p><code>glActiveTexture</code> selects which texture unit
* subsequent texture state calls will affect. The number of texture
* units an implementation supports is implementation dependent, it
* must be at least 1 for OpenGL ES 1.0, or 2 for OpenGL ES 1.1.
*
* <h4>Notes</h4>
*
* <p>It is always the case that <code>GL_TEXTURE</code><i>i</i> =
* <code>GL_TEXTURE0</code> + <i>i</i>.
*
* <p>A texture unit consists of the texture enable state, texture
* matrix stack, texture environment and currently bound
* texture. Modifying any of these states has an effect only on the
* active texture unit.
*
* <p>Vertex arrays are client-side GL resources, which are selected by
* the <code>glClientActiveTexture</code> routine.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if
* <code>texture</code> is not one of
* <code>GL_TEXTURE</code><i>i</i>, where <code>0 <= <i>i</i> <
* GL_MAX_TEXTURE_UNITS</code>.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_MAX_TEXTURE_UNITS</code>.
*
* @param texture Specifies which texture unit to make active. The
* number of texture units is implementation dependent, but must be
* at least one (for 1.0) or two (for 1.1). <code>texture</code>
* must be one of <code>GL_TEXTURE</code><i>i</i>, where <code>0 <=
* <i>i</i> < GL_MAX_TEXTURE_UNITS</code>, which is an
* implementation-dependent value. The intial value is
* <code>GL_TEXTURE0</code>.
*
*/
void glActiveTexture(int texture);
/**
* Specify the alpha test function.
*
* <p>The alpha test discards fragments depending on the outcome of a
* comparison between an incoming fragment's alpha value and a
* constant reference value. <code>glAlphaFunc</code> specifies the
* reference value and the comparison function. The comparison is
* performed only if alpha testing is enabled. To enable and disable
* alpha testing, call <code>glEnable</code> and
* <code>glDisable</code> with argument
* <code>GL_ALPHA_TEST</code>. Alpha testing is initially disabled.
*
* <p><code>func</code> and <code>ref</code> specify the conditions
* under which the pixel is drawn. The incoming alpha value is
* compared to <code>ref</code> using the function specified by
* <code>func</code>. If the value passes the comparison, the
* incoming fragment is drawn if it also passes subsequent stencil
* and depth buffer tests. If the value fails the comparison, no
* change is made to the frame buffer at that pixel location. The
* comparison functions are as follows:
*
* <ul>
* <li><code>GL_NEVER</code></li>
* Never passes.
* <li><code>GL_LESS</code></li>
* Passes if the incoming alpha value is less than the reference value.
* <li><code>GL_EQUAL</code></li>
* Passes if the incoming alpha value is equal to the reference value.
* <li><code>GL_LEQUAL</code></li>
* Passes if the incoming alpha value is less than or equal to the
* reference value.
* <li><code>GL_GREATER</code></li>
* Passes if the incoming alpha value is greater than the reference value.
* <li><code>GL_NOTEQUAL</code></li>
* Passes if the incoming alpha value is not equal to the reference value.
* <li><code>GL_GEQUAL</code></li>
* Passes if the incoming alpha value is greater than or equal to
* the reference value.
* <li><code>GL_ALWAYS</code></li>
* Always passes (initial value).
* </ul>
*
* <p><code>glAlphaFunc</code> operates on all pixel write
* operations, including those resulting from the scan conversion of
* points, lines, and polygons. <code>glAlphaFunc</code> does not
* affect <code>glClear</code>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if <code>func</code>
* is not an accepted value.
*
* @param func Specifies the alpha comparison function. Symbolic
* constants <code>GL_NEVER</code>, <code>GL_LESS</code>,
* <code>GL_EQUAL</code>, <code>GL_LEQUAL</code>,
* <code>GL_GREATER</code>, <code>GL_NOTEQUAL</code>,
* <code>GL_GEQUAL</code>, and <code>GL_ALWAYS</code> are accepted. The
* initial value is <code>GL_ALWAYS</code>.
* @param ref Specifies the reference value that incoming alpha
* values are compared to. This value is clamped to the range
* <code>[0, 1]</code>, where 0 represents the lowest possible alpha
* value and 1 the highest possible value. The initial reference
* value is 0.
*/
void glAlphaFunc(int func, float ref);
/**
* Fixed-point version of <code>glAlphaFunc</code>.
*
* @see #glAlphaFunc
*/
void glAlphaFuncx(int func, int ref);
/**
* Bind a named texture to a texturing target.
*
* <p><code>glBindTexture</code> lets you create or use a named
* texture. Calling <code>glBindTexture</code> with
* <code>target</code> set to <code>GL_TEXTURE_2D</code>, and
* <code>texture</code> set to the name of the new texture binds the
* texture name to the target. When a texture is bound to a target,
* the previous binding for that target is automatically broken.
*
* <p>Texture names are unsigned integers. The value 0 is reserved
* to represent the default texture for each texture target. Texture
* names and the corresponding texture contents are local to the
* shared texture-object space (see <code>eglCreateContext</code>)
* of the current GL rendering context.
*
* <p>You may use <code>glGenTextures</code> to generate a set of new
* texture names.
*
* <p>While a texture is bound, GL operations on the target to which it
* is bound affect the bound texture. If texture mapping of the
* dimensionality of the target to which a texture is bound is
* active, the bound texture is used. In effect, the texture targets
* become aliases for the textures currently bound to them, and the
* texture name 0 refers to the default textures that were bound to
* them at initialization.
*
* <p>A texture binding created with <code>glBindTexture</code> remains
* active until a different texture is bound to the same target, or
* until the bound texture is deleted with
* <code>glDeleteTextures</code>.
*
* <p>Once created, a named texture may be re-bound to the target of
* the matching dimensionality as often as needed. It is usually
* much faster to use <code>glBindTexture</code> to bind an existing named
* texture to one of the texture targets than it is to reload the
* texture image using <code>glTexImage2D</code>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if
* <code>target</code> is not one of the allowable values.
*
* @param target Specifies the target to which the texture is
* bound. Must be <code>GL_TEXTURE_2D</code>.
* @param texture Specifies the name of a texture.
*/
void glBindTexture(int target, int texture);
/**
* Specify pixel arithmetic.
*
* <p>Pixels can be drawn using a function that blends the incoming
* (source) values with the values that are already in the color
* buffer (the destination values). Use <code>glEnable</code> and
* <code>glDisable</code> with argument <code>GL_BLEND</code> to
* enable and disable blending. Blending is initially disabled.
*
* <p><code>glBlendFunc</code> defines the operation of blending
* when it is enabled. <code>sfactor</code> specifies which of eleven
* methods is used to scale the source color
* components. <code>dfactor</code> specifies which of ten methods
* is used to scale the destination color components. The eleven
* possible methods are described in the following table. Each
* method defines four scale factors, one each for red, green, blue,
* and alpha.
*
* <p>In the table and in subsequent equations, source and
* destination color components are referred to as <code>(Rs, Gs,
* Bs, As)</code> and <code>(Rd, Gd, Bd, Ad)</code>. They are
* understood to have integer values between 0 and <code>(kR, kG,
* kB, kA)</code>, where
*
* <pre>
* kc = 2mc - 1
* </pre>
*
* and <code>(mR, mG, mB, mA)</code> is the number of red, green,
* blue, and alpha bitplanes.
*
* <p>Source and destination scale factors are referred to as
* <code>(sR, sG, sB, sA)</code> and <code>(dR, dG, dB,
* dA)</code>. The scale factors described in the table, denoted
* <code>(fR, fG, fB, fA)</code>, represent either source or
* destination factors. All scale factors have range [0, 1].
*
* <pre>
* Parameter (fR, fG, fB, fA)
*
* GL_ZERO (0, 0, 0, 0)
* GL_ONE (1, 1, 1, 1)
* GL_SRC_COLOR (Rs/kR, Gs/kG, Bs/kB, As/kA )
* GL_ONE_MINUS_SRC_COLOR (1, 1, 1, 1) - (Rs/kR, Gs/kG, Bs/kB, As/kA)
* GL_DST_COLOR (Rd/kR, Gd/kG, Bd/kB, Ad/kA )
* GL_ONE_MINUS_DST_COLOR (1, 1, 1, 1) - (Rd/kR, Gd/kG, Bd/kB, Ad/kA)
* GL_SRC_ALPHA (As/kA, As/kA, As/kA, As/kA )
* GL_ONE_MINUS_SRC_ALPHA (1, 1, 1, 1) - (As/kA, As/kA, As/kA, As/kA)
* GL_DST_ALPHA (Ad/kA, Ad/kA, Ad/kA, Ad/kA )
* GL_ONE_MINUS_DST_ALPHA (1, 1, 1, 1) - (Ad/kA, Ad/kA, Ad/kA, Ad/kA)
* GL_SRC_ALPHA_SATURATE (i, i, i, 1)
* </pre>
*
* <p>In the table,
*
* <pre>
* i = min(As, kA - Ad) / kA
* </pre>
*
* <p>To determine the blended values of a pixel, the system uses the
* following equations:
*
* <pre>
* Rd = min( kR, Rs sR + Rd dR )
* Gd = min( kG, Gs sG + Gd dG )
* Bd = min( kB, Bs sB + Bd dB )
* Ad = min( kA, As sA + Ad dA )
* </pre>
*
* <p>Despite the apparent precision of the above equations,
* blending arithmetic is not exactly specified, because blending
* operates with imprecise integer color values. However, a blend
* factor that should be equal to 1 is guaranteed not to modify its
* multiplicand, and a blend factor equal to 0 reduces its
* multiplicand to 0. For example, when <code>sfactor</code> is
* <code>GL_SRC_ALPHA</code>, <code>dfactor</code> is
* <code>GL_ONE_MINUS_SRC_ALPHA</code>, and <code>As</code> is equal
* to <code>kA</code>, the equations reduce to simple replacement:
*
* <pre>
* Rd = Rs
* Gd = Gs
* Bd = Bs
* Ad = As
* </pre>
*
* <p><code>glBlendFunc</code> operates on all pixel write
* operations, including the scan conversion of points, lines, and
* polygons. <code>glBlendFunc</code> does not affect
* <code>glClear</code>.
*
* <h4>Examples</h4>
*
* <p>Transparency is best implemented using
* <code>glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)</code> with
* primitives sorted from farthest to nearest. Note that this
* transparency calculation does not require the presence of alpha
* bitplanes in the color buffer.
*
* <p><code>glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)</code> is
* also useful for rendering antialiased points and lines.
*
* <h4>Notes</h4> Incoming (source) alpha is correctly thought of as
* a material opacity, ranging from 1.0 (kA), representing complete
* opacity, to 0.0 (0), representing complete transparency.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if either
* <code>sfactor</code> or <code>dfactor</code> is not an accepted
* value.
*
* @param sfactor Specifies how the red, green, blue, and alpha
* source blending factors are computed. The following symbolic
* constants are accepted: <code>GL_ZERO</code>,
* <code>GL_ONE</code>, <code>GL_SRC_COLOR</code> (1.1 only),
* <code>GL_ONE_MINUS_SRC_COLOR</code> (1.1 only),
* <code>GL_DST_COLOR</code>, <code>GL_ONE_MINUS_DST_COLOR</code>,
* <code>GL_SRC_ALPHA</code>, <code>GL_ONE_MINUS_SRC_ALPHA</code>,
* <code>GL_DST_ALPHA</code>, <code>GL_ONE_MINUS_DST_ALPHA</code>,
* and <code>GL_SRC_ALPHA_SATURATE</code>. The initial value is
* <code>GL_ONE</code>.
* @param dfactor Specifies how the red, green, blue, and alpha
* destination blending factors are computed. The following symbolic
* constants are accepted: <code>GL_ZERO</code>,
* <code>GL_ONE</code>, <code>GL_SRC_COLOR</code>,
* <code>GL_ONE_MINUS_SRC_COLOR</code>, <code>GL_DST_COLOR</code>
* (1.1 only), <code>GL_ONE_MINUS_DST_COLOR</code> (1.1 only),
* <code>GL_SRC_ALPHA</code>, <code>GL_ONE_MINUS_SRC_ALPHA</code>,
* <code>GL_DST_ALPHA</code>, and
* <code>GL_ONE_MINUS_DST_ALPHA</code>. The initial value is
* <code>GL_ZERO</code>.
*/
void glBlendFunc(int sfactor, int dfactor);
/**
* Clear buffers to preset values.
*
* <p><code>glClear</code> sets the bitplane area of the window to
* values previously selected by <code>glClearColor</code>,
* <code>glClearDepth</code>, and <code>glClearStencil</code>.
*
* <p>The pixel ownership test, the scissor test, dithering, and the
* color buffer masks affect the operation of
* <code>glClear</code>. The scissor box bounds the cleared
* region. Alpha function, blend function, logical operation,
* stenciling, texture mapping, and depth-buffering are ignored by
* <code>glClear</code>.
*
* <p><code>glClear</code> takes a single argument that is the
* bitwise OR of several values indicating which buffer is to be
* cleared.
*
* <p>The values are as follows:
*
* <ul>
* <li><code>GL_COLOR_BUFFER_BIT</code></li>
* Indicates the color buffer.
* <li><code>GL_DEPTH_BUFFER_BIT</code></li>
* Indicates the depth buffer.
* <li><code>GL_STENCIL_BUFFER_BIT</code></li>
* Indicates the stencil buffer.
* </ul>
*
* <p>The value to which each buffer is cleared depends on the
* setting of the clear value for that buffer.
*
* <h4>Notes</h4>
*
* <p>If a buffer is not present, then a <code>glClear</code>
* directed at that buffer has no effect.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_VALUE</code> is generated if any bit other
* than the defined bits is set in <code>mask</code>.
*
* @param mask Bitwise OR of masks that indicate the buffers to be
* cleared. Valid masks are <code>GL_COLOR_BUFFER_BIT</code>,
* <code>GL_DEPTH_BUFFER_BIT</code>, and <code>GL_STENCIL_BUFFER_BIT</code>.
*/
void glClear(int mask);
/**
* Specify clear values for the color buffer.
*
* <p><code>glClearColor</code> specifies the red, green, blue, and
* alpha values used by <code>glClear</code> to clear the color
* buffer. Values specified by <code>glClearColor</code> are clamped
* to the range <code>[0, 1]</code>.
*
* @param red Specifies the red value used when the color buffer is
* cleared. The initial value is 0.
* @param green Specifies the green value used when the color buffer
* is cleared. The initial value is 0.
* @param blue Specifies the blue value used when the color buffer is
* cleared. The initial value is 0.
* @param alpha Specifies the alpha value used when the color buffer
* is cleared. The initial value is 0.
*/
void glClearColor(float red, float green, float blue, float alpha);
/**
* Fixed-point version of <code>glClearColor</code>.
*
* @see #glClearColor
*/
void glClearColorx(int red, int green, int blue, int alpha);
/**
* Specify the clear value for the depth buffer.
*
* <p><code>glClearDepth</code> specifies the depth value used by
* <code>glClear</code> to clear the depth buffer. Values specified
* by <code>glClearDepth</code> are clamped to the range <code>[0, 1]</code>.
*
* @param depth Specifies the depth value used when the depth buffer
* is cleared. The initial value is 1.
*/
void glClearDepthf(float depth);
/**
* Fixed-point version of <code>glClearDepth</code>.
*
* @see #glClearDepthf
*/
void glClearDepthx(int depth);
/**
* Specify the clear value for the stencil buffer.
*
* <p><code>glClearStencil</code> specifies the index used by
* <code>glClear</code> to clear the stencil buffer. <code>s</code>
* is masked with 2^<i>m</i> - 1, where <i>m</i> is the number of
* bits in the stencil buffer.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_STENCIL_BITS</code>
*
* @param s Specifies the index used when the stencil buffer is
* cleared. The initial value is 0.
*/
void glClearStencil(int s);
/**
* Select client-side active texture unit.
*
* <p><code>glClientActiveTexture</code> selects the vertex array
* client state parameters to be modified by
* <code>glTexCoordPointer</code>, and enabled or disabled with
* <code>glEnableClientState</code> or
* <code>glDisableClientState</code>, respectively, when called with
* a parameter of <code>GL_TEXTURE_COORD_ARRAY</code>.
*
* <h4>Notes</h4>
*
* <p>It is always the case that <code>GL_TEXTURE</code><i>i</i> =
* <code>GL_TEXTURE0</code> + <i>i</i>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if
* <code>texture</code> is not one of
* <code>GL_TEXTURE</code><i>i</i>, where <code>0 <= <i>i</i> <
* GL_MAX_TEXTURE_UNITS</code>.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_MAX_TEXTURE_UNITS</code>
*
* @param texture Specifies which texture unit to make active. The
* number of texture units is implementation dependent, but must be
* at least one (for 1.0), or two (for 1.1). <code>texture</code>
* must be one of <code>GL_TEXTURE</code><i>i</i>, <code>0 <=
* <i>i</i> < GL_MAX_TEXTURE_UNITS</code>, which is an
* implementation-dependent value. The initial value is
* <code>GL_TEXTURE0</code>.
*/
void glClientActiveTexture(int texture);
/**
* Set the current color.
*
* <p>The GL stores a current four-valued RGBA
* color. <code>glColor</code> sets a new four-valued RGBA color.
*
* <p>Current color values are stored in fixed-point or
* floating-point. In case the values are stored in floating-point,
* the mantissa and exponent sizes are unspecified.
*
* <p>Neither fixed-point nor floating-point values are clamped to
* the range <code>[0, 1]</code> before the current color is
* updated. However, color components are clamped to this range
* before they are interpolated or written into the color buffer.
*
* @param red Specifies a new red value for the current color. The
* initial value is 1.
* @param green Specifies a new green value for the current color. The
* initial value is 1.
* @param blue Specifies a new blue value for the current color. The
* initial value is 1.
* @param alpha Specifies a new alpha value for the current color. The
* initial value is 1.
*/
void glColor4f(float red, float green, float blue, float alpha);
/**
* Fixed-point version of <code>glColor</code>.
*
* @see #glColor4f
*/
void glColor4x(int red, int green, int blue, int alpha);
/**
* Enable and disable writing of color buffer components.
*
* <p><code>glColorMask</code> specifies whether the individual
* components in the color buffer can or cannot be written. If
* <code>red</code> is <code>false</code>, for example, no change
* is made to the red component of any pixel in the color buffer,
* regardless of the drawing operation attempted, including
* <code>glClear</code>.
*
* <p>Changes to individual bits of components cannot be
* controlled. Rather, changes are either enabled or disabled for
* entire color components.
*
* @param red Specifies whether red can or cannot be written into
* the color buffer. The initial value is <code>true</code>, indicating
* that the color component can be written.
* @param green Specifies whether green can or cannot be written into
* the color buffer. The initial value is <code>true</code>, indicating
* that the color component can be written.
* @param blue Specifies whether blue can or cannot be written into
* the color buffer. The initial value is <code>true</code>, indicating
* that the color component can be written.
* @param alpha Specifies whether alpha can or cannot be written
* into the color buffer. The initial value is <code>true</code>,
* indicating that the color component can be written.
*/
void glColorMask(boolean red, boolean green, boolean blue, boolean alpha);
/**
* Define an array of colors.
*
* <p><code>glColorPointer</code> specifies an array of color
* components to use when rendering. <code>size</code> specifies the
* number of components per color, and must be 4. <code>type</code>
* specifies the data type of each color component, and
* <code>stride</code> specifies the byte stride from one color to
* the next allowing vertices and attributes to be packed into a
* single array or stored in separate arrays. (Single-array storage
* may be more efficient on some implementations.)
*
* <p>When a color array is specified, <code>size</code>,
* <code>type</code>, <code>stride</code>, and <code>pointer</code>
* are saved as client-side state.
*
* <p>If the color array is enabled, it is used when
* <code>glDrawArrays</code>, or <code>glDrawElements</code> is
* called. To enable and disable the color array, call
* <code>glEnableClientState</code> and
* <code>glDisableClientState</code> with the argument
* <code>GL_COLOR_ARRAY</code>. The color array is initially
* disabled and isn't accessed when <code>glDrawArrays</code> or
* <code>glDrawElements</code> is called.
*
* <p>Use <code>glDrawArrays</code> to construct a sequence of
* primitives (all of the same type) from prespecified vertex and
* vertex attribute arrays. Use <code>glDrawElements</code> to
* construct a sequence of primitives by indexing vertices and
* vertex attributes.
*
* <p>Setting <code>pointer</code> to <code>null</code> releases any
* previously set <code>Buffer</code>.
*
* <h4>Notes</h4>
*
* <p><code>glColorPointer</code> is typically implemented on the
* client side.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>size</code> is not 4.
*
* <p><code>GL_INVALID_ENUM</code> is generated if <code>type</code>
* is not an accepted value.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>stride</code> is negative.
*
* <p> The <code>pointer</code> argument must be a direct buffer
* with a type matching that specified by the <code>type</code>
* argument.
*
* @param size Specifies the number of components per color. Must be
* 4. The initial value is 4.
* @param type Specifies the data type of each color component in
* the array. Symbolic constants <code>GL_UNSIGNED_BYTE</code>,
* <code>GL_FIXED</code>, and <code>GL_FLOAT</code> are
* accepted. The initial value is <code>GL_FLOAT</code>.
* @param stride Specifies the byte offset between consecutive
* colors. If <code>stride</code> is 0, the colors are understood to
* be tightly packed in the array. The initial value is 0.
* @param pointer Specifies a <code>Buffer</code> containing the
* colors.
*
* @exception IllegalStateException if OpenGL ES 1.1 is being used and
* VBOs are enabled.
* @exception IllegalArgumentException if <code>pointer</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>pointer</code> is
* not direct.
*/
void glColorPointer(int size, int type, int stride, Buffer pointer);
/**
* Specify a two-dimensional compressed texture image.
*
* <p><code>glCompressedTexImage2D</code> defines a two-dimensional
* texture image in compressed format.
*
* <p>The supported compressed formats are paletted textures. The
* layout of the compressed image is a palette followed by multiple
* mip-levels of texture indices used for lookup into the
* palette. The palette format can be one of <code>R5_G6_B5</code>,
* <code>RGBA4</code>, <code>RGB5_A1</code>, <code>RGB8</code>, or
* <code>RGBA8</code>. The texture indices can have a resolution of
* 4 or 8 bits. As a result, the number of palette entries is either
* 16 or 256. If level is 0, only one mip-level of texture indices
* is described in data. Otherwise, the negative value of level
* specifies up to which mip-level the texture indices are
* described. A possibly remaining pad nibble (half byte) for the
* lowest resolution mip-level is ignored.
*
* <h4>Notes</h4>
*
* <p><code>glPixelStore</code> has no effect on compressed texture
* images.
*
* <p><code>glCompressedTexImage2D</code> specifies the
* two-dimensional texture for the currently bound texture,
* specified with <code>glBindTexture</code>, and the current
* texture unit, specified with <code>glActiveTexture</code>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if
* <code>target</code> is not <code>GL_TEXTURE_2D</code>.
*
* <p><code>GL_INVALID_VALUE</code> may be generated if
* <code>level</code> is greater than 0 or the absolute value of
* level is greater than log_2(<i>max</i>), where <i>max</i> is the
* returned value of <code>GL_MAX_TEXTURE_SIZE</code>.
*
* <p>(1.0) <code>GL_INVALID_VALUE</code> is generated if
* <code>internalformat</code> is not one of the accepted symbolic
* constants.
*
* <p>(1.1) <code>GL_INVALID_ENUM</code> is generated if
* <code>internalformat</code> is not one of the accepted symbolic
* constants.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>width</code> or <code>height</code> is less than 0 or
* greater than 2 + <code>GL_MAX_TEXTURE_SIZE</code>, or if either
* cannot be represented as 2^<i>k</i> + 2*<code>border</code> for
* some integer <i>k</i>.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>border</code> is not 0.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>imageSize</code> is not consistent with format, dimentions,
* and contents of the compressed image.
*
* @param target Specifies the target texture. Must be
* <code>GL_TEXTURE_2D</code>.
* @param level Specifies the level-of-detail number. Must be less
* than or equal to 0. Level 0 indicates a single
* mip-level. Negative values indicate how many mip-levels are
* described by data.
* @param internalformat Specifies the color components in the
* texture. The following symbolic constants are accepted:
* <code>GL_PALETTE4_RGB8_OES</code>,
* <code>GL_PALETTE4_RGBA8_OES</code>,
* <code>GL_PALETTE4_R5_G6_B5_OES</code>,
* <code>GL_PALETTE4_RGBA4_OES</code>,
* <code>GL_PALETTE4_RGB5_A1_OES</code>,
* <code>GL_PALETTE8_RGB8_OES</code>,
* <code>GL_PALETTE8_RGBA8_OES</code>,
* <code>GL_PALETTE8_R5_G6_B5_OES</code>,
* <code>GL_PALETTE8_RGBA4_OES</code>, and
* <code>GL_PALETTE8_RGB5_A1_OES</code>.
* @param width Specifies the width of the texture image. Must be
* 2^<i>n</i> + 2*<code>border</code> for some integer <i>n</i>. All
* implementations support texture images that are at least 64
* texels wide.
* @param height Specifies the height of the texture image. Must be
* 2^<i>m</i> + 2*<code>border</code> for some integer <i>m</i>. All
* implementations support texture images that are at least 64
* texels high.
* @param border Specifies the width of the border. Must be 0.
* @param imageSize Specifies the size of the compressed image data
* in bytes.
* @param data Specifies a <code>Buffer</code> containing the
* compressed image data.
*
* @exception IllegalArgumentException if <code>data</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>data.remaining()</code> is less than
* <code>imageSize</code>.
*/
void glCompressedTexImage2D(int target, int level,
int internalformat,
int width, int height,
int border, int imageSize,
Buffer data);
/**
* Specify a two-dimensional compressed texture subimage.
*
* <p><code>glCompressedTexSubImage2D</code> redefines a contiguous
* subregion of an existing two-dimensional compressed texture
* image. The texels referenced by <code>pixels</code> replace the
* portion of the existing texture array with x indices
* <code>xoffset</code> and <code>xoffset</code> +
* <code>width</code> - 1, inclusive, and y indices
* <code>yoffset</code> and <code>yoffset</code> +
* <code>height</code> - 1, inclusive. This region may not include
* any texels outside the range of the texture array as it was
* originally specified. It is not an error to specify a subtexture
* with zero width or height, but such a specification has no
* effect.
*
* <p>Currently, there is no supported compressed format for this
* function.
*
* <h4>Notes</h4>
*
* <p><code>glPixelStore</code> has no effect on compressed texture
* images.
*
* <p><code>glCompressedTexSubImage2D</code> specifies the
* two-dimensional sub texture for the currently bound texture,
* specified with <code>glBindTexture</code>, and the current
* texture unit, specified with <code>glActiveTexture</code>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if
* <code>target</code> is not <code>GL_TEXTURE_2D</code>.
*
* <p><code>GL_INVALID_OPERATION</code> is generated if the texture
* array has not been defined by a previous
* <code>glCompressedTexImage2D</code> operation.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>level</code> is less than 0.
*
* <p><code>GL_INVALID_VALUE</code> may be generated if
* <code>level</code> is greater than log2(<i>max</i>), where
* <i>max</i> is the returned value of
* <code>GL_MAX_TEXTURE_SIZE</code>.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>xoffset</code> < <i>-b</i>, <code>xoffset</code> + width >
* (<i>w - b</i>), <code>yoffset</code> < <i>-b</i>, or
* <code>yoffset</code> + <code>height</code> > (<i>h</i> - <i>b</i>)
* , where <i>w</i> is the texture width, <i>h</i> is the texture
* height, and <i>b</i> is the border of the texture image being
* modified. Note that <i>w</i> and <i>h</i> include twice the
* border width.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>width</code> or <code>height</code> is less than 0.
*
* <p><code>GL_INVALID_ENUM</code> is generated if <code>type</code>
* is not a type constant.
*
* <p><code>GL_INVALID_OPERATION</code> is generated if type
* <code>is</code> <code>GL_UNSIGNED_SHORT_5_6_5</code> and
* <code>format</code> is not <code>GL_RGB</code>.
*
* <p><code>GL_INVALID_OPERATION</code> is generated if
* <code>type</code> is one of
* <code>GL_UNSIGNED_SHORT_4_4_4_4</code>, or
* <code>GL_UNSIGNED_SHORT_5_5_5_1</code> and <code>format</code> is
* not <code>GL_RGBA</code>.
*
* <p><code>GL_INVALID_OPERATION</code> is generated if none of the
* above error conditions apply.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_MAX_TEXTURE_SIZE</code>
*
* @param target Specifies the target texture. Must be
* <code>GL_TEXTURE_2D</code>.
* @param level Specifies the level-of-detail number.
* @param xoffset Specifies a texel offset in the x direction within
* the texture array.
* @param yoffset Specifies a texel offset in the y direction within
* the texture array.
* @param width Specifies the width of the texture subimage.
* @param height Specifies the height of the texture subimage.
* @param format Specifies the format of the pixel data. Currently,
* there is no supported format.
* @param imageSize Specifies the size of the compressed pixel data in bytes.
* @param data Specifies a <code>Buffer</code> containing the
* compressed image data.
*
* @exception IllegalArgumentException if <code>data</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>data.remaining()</code> is less than
* <code>imageSize</code>.
*/
void glCompressedTexSubImage2D(int target, int level,
int xoffset, int yoffset,
int width, int height,
int format, int imageSize,
Buffer data);
/**
* Specify a two-dimensional texture image with pixels from the
* color buffer.
*
* <p><code>glCopyTexImage2D</code> defines a two-dimensional
* texture image with pixels from the color buffer.
*
* <p>The screen-aligned pixel rectangle with lower left corner at
* (<code>x</code>, <code>y</code>) and with a width of
* <code>width</code> + 2*<code>border</code> and a height of
* <code>height</code> + 2*<code>border</code> defines the texture
* array at the mipmap level specified by
* <code>level</code>. <code>internalformat</code> specifies the
* color components of the texture.
*
* <p>The red, green, blue, and alpha components of each pixel that
* is read are converted to an internal fixed-point or
* floating-point format with unspecified precision. The conversion
* maps the largest representable component value to 1.0, and
* component value 0 to 0.0. The values are then converted to the
* texture's internal format for storage in the texel array.
*
* <p><code>internalformat</code> must be chosen such that color
* buffer components can be dropped during conversion to the
* internal format, but new components cannot be added. For example,
* an RGB color buffer can be used to create <code>LUMINANCE</code>
* or <code>RGB</code> textures, but not <code>ALPHA</code>,
* <code>LUMINANCE_ALPHA</code> or <code>RGBA</code> textures.
*
* <p>Pixel ordering is such that lower x and y screen coordinates
* correspond to lower s and t texture coordinates.
*
* <p>If any of the pixels within the specified rectangle of the
* color buffer are outside the window associated with the current
* rendering context, then the values obtained for those pixels are
* undefined.
*
* <h4>Notes</h4>
*
* <p>An image with <code>height</code> or <code>width</code> of 0
* indicates a null-texture.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if
* <code>target</code> is not <code>GL_TEXTURE_2D</code>. <!-- If the
* <code>OES_texture_cube_map</code> extension is present, then
* <code>GL_TEXTURE_CUBE_MAP_POSITIVE_X</code>,
* <code>GL_TEXTURE_CUBE_MAP_POSITIVE_Y</code>,
* <code>GL_TEXTURE_CUBE_MAP_POSITIVE_Z</code>,
* <code>GL_TEXTURE_CUBE_MAP_NEGATIVE_X</code>,
* <code>GL_TEXTURE_CUBE_MAP_NEGATIVE_Y</code>, and
* <code>GL_TEXTURE_CUBE_MAP_NEGATIVE_Z</code> are also accepted. -->
*
* <p><code>GL_INVALID_OPERATION</code> is generated if
* <code>internalformat</code> is not compatible with the color
* buffer format.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>level</code> is less than 0.
*
* <p><code>GL_INVALID_VALUE</code> may be generated if level is
* greater than log_2(<i>max</i>), where <i>max</i> is the returned
* value of <code>GL_MAX_TEXTURE_SIZE</code>.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>width</code> or <code>height</code> is less than 0, greater
* than <code>GL_MAX_TEXTURE_SIZE</code>, or if <code>width</code>
* or <code>height</code> cannot be represented as 2^<i>k</i> +
* 2*<code>border</code> for some integer <i>k</i>.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>border</code> is not 0.
*
* <p>(1.0) <code>GL_INVALID_VALUE</code> is generated if
* <code>internalformat</code> is not an accepted constant.
*
* <p>(1.1) <code>GL_INVALID_ENUM</code> is generated if
* <code>internalformat</code> is not an accepted constant.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_MAX_TEXTURE_SIZE</code>
*
* @param target Specifies the target texture. Must be
* <code>GL_TEXTURE_2D</code>.
* @param level Specifies the level-of-detail number. Level 0 is the
* base image level. Level n is the nth mipmap reduction image.
* @param internalformat Specifies the color components of the
* texture. Must be one of the following symbolic constants:
* <code>GL_ALPHA</code>, <code>GL_LUMINANCE</code>,
* <code>GL_LUMINANCE_ALPHA</code>, <code>GL_RGB</code>, or
* <code>GL_RGBA</code>.
* @param x Specifies the window x coordinate of the lower left
* corner of the rectangular region of pixels to be copied.
* @param y Specifies the window y coordinate of the lower left
* corner of the rectangular region of pixels to be copied.
* @param width Specifies the width of the texture image. Must be 0
* or 2^<i>n</i? + 2*<code>border</code> for some integer <i>n</i>.
* @param height Specifies the height of the texture image. Must be
* 0 or 2^<i>m</i> + 2*<code>border</code> for some integer <i>m</i>.
* @param border Specifies the width of the border. Must be 0.
*/
void glCopyTexImage2D(int target, int level,
int internalformat,
int x, int y,
int width, int height,
int border);
/**
* Specify a two-dimensional texture subimage with pixels from the
* color buffer.
*
* <p><code>glCopyTexSubImage2D</code> replaces a rectangular portion of a
* two-dimensional texture image with pixels from the color buffer.
*
* <p>The screen-aligned pixel rectangle with lower left corner at
* (<code>x</code>, <code>y</code>) and with width width and height
* height replaces the portion of the texture array with x indices
* <code>xoffset</code> through <code>xoffset</code> +
* <code>width</code> - 1, inclusive, and y indices
* <code>yoffset</code> through <code>yoffset</code> +
* <code>height</code> - 1, inclusive, at the mipmap level specified
* by level.
*
* <p>The pixels in the rectangle are processed the same way as with
* <code>glCopyTexImage2D</code>.
*
* <p><code>glCopyTexSubImage2D</code> requires that the internal
* format of the currently bound texture is such that color buffer
* components can be dropped during conversion to the internal
* format, but new components cannot be added. For example, an RGB
* color buffer can be used to create LUMINANCE or RGB textures, but
* not ALPHA, LUMINANCE_ALPHA or RGBA textures.
*
* <p>The destination rectangle in the texture array may not include
* any texels outside the texture array as it was originally
* specified. It is not an error to specify a subtexture with zero
* width or height, but such a specification has no effect.
*
* <p>If any of the pixels within the specified rectangle of the
* current color buffer are outside the read window associated with
* the current rendering context, then the values obtained for those
* pixels are undefined.
*
* <p>No change is made to the <code>internalformat</code>,
* <code>width</code>, <code>height</code>, or <code>border</code>
* parameters of the specified texture array or to texel values
* outside the specified subregion.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if
* <code>target</code> is not <code>GL_TEXTURE_2D</code>.
*
* <p><code>GL_INVALID_OPERATION</code> is generated if the texture
* array has not been defined by a previous
* <code>glTexImage2D</code> or <code>glCopyTexImage2D</code>
* operation or if the internal format of the currently bound
* texture is not compatible with the color buffer format.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>level</code> is less than 0.
*
* <p><code>GL_INVALID_VALUE</code> may be generated if
* <code>level</code> is greater than log_2(<i>max</i>), where
* <i>max</i> is the returned value of
* <code>GL_MAX_TEXTURE_SIZE</code>.
*
* <p><code>GL_INVALID_VALUE</code> is generated if x < <i>-b</i>,
* or y < <i>-b</i>, where <i>b</i> is the border of the texture
* being modified.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>xoffset</code> < <i>-b</i>, <code>xoffset</code> +
* <code>width</code> > (<i>w - b</i>) , <code>yoffset</code> <
* <i>-b</i>, or <code>yoffset</code> + <code>height</code> > (<i>h
* - b</i>) , where <i>w</i> is the texture width, <i>h</i> is the
* texture height, and <i>b</i> is the border of the texture image
* being modified. Note that <i>w</i> and <i>h</i> include twice the
* border width.
*
* <h4>Associated Gets</h4>
*
* <p><p><code>glGetIntegerv</code> with argument
* <code>GL_MAX_TEXTURE_SIZE</code>
*
* @param target Specifies the target texture. Must be
* <code>GL_TEXTURE_2D</code>.
* @param level Specifies the level-of-detail number. Level 0 is the
* base image level. Level n is the nth mipmap reduction image.
* @param xoffset Specifies a texel offset in the x direction within
* the texture array.
* @param yoffset Specifies a texel offset in the y direction within
* the texture array.
* @param x Specifies the window x coordinate of the lower left
* corner of the rectangular region of pixels to be copied.
* @param y Specifies the window y coordinate of the lower left
* corner of the rectangular region of pixels to be copied.
* @param width Specifies the width of the texture subimage.
* @param height Specifies the height of the texture subimage.
*/
void glCopyTexSubImage2D(int target, int level,
int xoffset, int yoffset,
int x, int y,
int width, int height);
/**
* Specify whether front- or back-facing polygons are culled.
*
* <p><code>glCullFace</code> specifies whether front- or
* back-facing polygons are culled (as specified by
* <code>mode</code>) when culling is enabled. To enable and disable
* culling, call <code>glEnable</code> and <code>glDisable</code>
* with argument <code>GL_CULL_FACE</code>. Culling is initially
* disabled.
*
* <p><code>glFrontFace</code> specifies which of the clockwise and
* counterclockwise polygons are front-facing and back-facing.
*
* <h4>Notes</h4>
*
* <p>If mode is <code>GL_FRONT_AND_BACK</code>, no polygons are
* drawn, but other primitives such as points and lines are drawn.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if <code>mode</code>
* is not an accepted value.
*
* @param mode Specifies whether front- or back-facing polygons are
* culled. Symbolic constants <code>GL_FRONT</code>,
* <code>GL_BACK</code>, and <code>GL_FRONT_AND_BACK</code> are
* accepted. The initial value is <code>GL_BACK</code>.
*/
void glCullFace(int mode);
/**
* Delete named textures.
*
* <p><code>glDeleteTextures</code> deletes <code>n</code> textures
* named by the elements of the array <code>textures</code>. After a
* texture is deleted, it has no contents or dimensionality, and its
* name is free for reuse (for example by
* <code>glGenTextures</code>). If a texture that is currently bound
* is deleted, the binding reverts to 0 (the default texture).
*
* <p><code>glDeleteTextures</code> silently ignores 0's and names
* that do not correspond to existing textures.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_VALUE</code> is generated if <code>n</code>
* is negative.
*
* @param n Specifies the number of textures to be deleted.
* @param textures Specifies an array of textures to be deleted.
* @param offset the starting offset within the
* <code>textures</code> array.
*
* @exception IllegalArgumentException if <code>textures</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>textures.length -
* offset</code> is less than <code>n</code>.
*/
void glDeleteTextures(int n, int[] textures, int offset);
/**
* Integer <code>Buffer</code> version of <code>glDeleteTextures</code>.
*
* @param textures an <code>IntBuffer</code>.
*
* @exception IllegalArgumentException if <code>textures</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>textures.remaining()</code> is less than <code>n</code>.
*
* @see #glDeleteTextures(int n, int[] textures, int offset)
*/
void glDeleteTextures(int n, IntBuffer textures);
/**
* Specify the value used for depth buffer comparisons.
*
* <p><code>glDepthFunc</code> specifies the function used to compare
* each incoming pixel depth value with the depth value present in
* the depth buffer. The comparison is performed only if depth
* testing is enabled. To enable and disable depth testing, call
* <code>glEnable</code> and <code>glDisable</code> with argument
* <code>GL_DEPTH_TEST</code>. Depth testing is initially disabled.
*
* <p>func specifies the conditions under which the pixel will be
* drawn. The comparison functions are as follows:
*
* <ul>
* <li><code>GL_NEVER</code></li>
* Never passes.
* <li><code>GL_LESS</code></li>
* Passes if the incoming depth value is less than the stored depth value.
* <li><code>GL_EQUAL</code></li>
* Passes if the incoming depth value is equal to the stored depth value.
* <li><code>GL_LEQUAL</code></li>
* Passes if the incoming depth value is less than or equal to the
* stored depth value.
* <li><code>GL_GREATER</code></li>
* Passes if the incoming depth value is greater than the stored
* depth value.
* <li><code>GL_NOTEQUAL</code></li>
* Passes if the incoming depth value is not equal to the stored
* depth value.
* <li><code>GL_GEQUAL</code></li>
* Passes if the incoming depth value is greater than or equal to
* the stored depth value.
* <li><code>GL_ALWAYS</code></li>
* Always passes.
* </ul>
*
* <p>The initial value of func is <code>GL_LESS</code>. Initially,
* depth testing is disabled. Even if the depth buffer exists and
* the depth mask is non-zero, the depth buffer is not updated if
* the depth test is disabled.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if <code>func</code>
* is not an accepted value.
*
* @param func Specifies the depth comparison function. Symbolic
* constants <code>GL_NEVER</code>, <code>GL_LESS</code>,
* <code>GL_EQUAL</code>, <code>GL_LEQUAL</code>,
* <code>GL_GREATER</code>, <code>GL_NOTEQUAL</code>,
* <code>GL_GEQUAL</code>, and <code>GL_ALWAYS</code> are
* accepted. The initial value is <code>GL_LESS</code>.
*/
void glDepthFunc(int func);
/**
* Enable or disable writing into the depth buffer.
*
* <p><code>glDepthMask</code> specifies whether the depth buffer is
* enabled for writing. If <code>flag</code> is <code>false</code>,
* depth buffer writing is disabled. Otherwise, it is
* enabled. Initially, depth buffer writing is enabled.
*
* <h4>1.0 Notes</h4>
*
* <p><code>glDepthMask</code> does not affect <code>glClear</code>.
*
* @param flag Specifies whether the depth buffer is enabled for
* writing. If flag is <code>GL_FALSE</code>, depth buffer writing
* is disabled, otherwise it is enabled. The initial value is
* <code>true</code>.
*/
void glDepthMask(boolean flag);
/**
* Specify mapping of depth values from normalized device
* coordinates to window coordinates.
*
* <p>After clipping and division by w, depth coordinates range from
* -1 to 1, corresponding to the near and far clipping
* planes. <code>glDepthRange</code> specifies a linear mapping of
* the normalized depth coordinates in this range to window depth
* coordinates. Regardless of the actual depth buffer
* implementation, window coordinate depth values are treated as
* though they range from 0 through 1 (like color components). Thus,
* the values accepted by <code>glDepthRange</code> are both clamped
* to this range before they are accepted.
*
* <p>The setting of (0, 1) maps the near plane to 0 and the far
* plane to 1. With this mapping, the depth buffer range is fully
* utilized.
*
* <h4>Notes</h4>
*
* <p>It is not necessary that <code>near</code> be less than
* <code>far</code>. Reverse mappings such as <code>near</code> = 1,
* and <code>far</code> = 0 are acceptable.
*
* @param zNear Specifies the mapping of the near clipping plane to
* window coordinates. The initial value is 0.
* @param zFar Specifies the mapping of the far clipping plane to
* window coordinates. The initial value is 1.
*/
void glDepthRangef(float zNear, float zFar);
/**
* Fixed-point version of <code>glDepthRange</code>.
*
* @see #glDepthRangef(float zNear, float zFar)
*/
void glDepthRangex(int zNear, int zFar);
/**
* Disable server-side GL capabilities.
*
* @see #glEnable
*/
void glDisable(int cap);
/**
* Disable client-side capability.
*
* @see #glEnableClientState
*/
void glDisableClientState(int array);
/**
* Render primitives from array data.
*
* <p><code>glDrawArrays</code> specifies multiple geometric
* primitives with very few subroutine calls. You can prespecify
* separate arrays of vertices, normals, colors, and texture
* coordinates and use them to construct a sequence of primitives
* with a single call to <code>glDrawArrays</code>.
*
* <p>When <code>glDrawArrays</code> is called, it uses
* <code>count</code> sequential elements from each enabled array to
* construct a sequence of geometric primitives, beginning with
* element <code>first</code>. <code>mode</code> specifies what kind
* of primitives are constructed, and how the array elements
* construct those primitives. If <code>GL_VERTEX_ARRAY</code> is
* not enabled, no geometric primitives are generated.
*
* <p>Vertex attributes that are modified by
* <code>glDrawArrays</code> have an unspecified value after
* <code>glDrawArrays</code> returns. For example, if
* <code>GL_COLOR_ARRAY</code> is enabled, the value of the current
* color is undefined after <code>glDrawArrays</code>
* executes. Attributes that aren't modified remain well defined.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if <code>mode</code>
* is not an accepted value.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>count</code> is negative.
*
* @exception ArrayIndexOutOfBoundsException if any index in the
* sequence <code>first, ..., first + count - 1</code> will result
* in a reference to an entry outside of the current vertex, color,
* normal, texture coordinate, point size, matrix index, or weight
* array.
*
* @param mode Specifies what kind of primitives to render. Symbolic
* constants <code>GL_POINTS</code>, <code>GL_LINE_STRIP</code>,
* <code>GL_LINE_LOOP</code>, <code>GL_LINES</code>,
* <code>GL_TRIANGLE_STRIP</code>, <code>GL_TRIANGLE_FAN</code>, and
* <code>GL_TRIANGLES</code> are accepted.
* @param first Specifies the starting index in the enabled arrays.
* @param count Specifies the number of indices to be rendered.
*/
void glDrawArrays(int mode, int first, int count);
/**
* Render primitives from array data.
*
* <p><code>glDrawElements</code> specifies multiple geometric
* primitives with very few subroutine calls. You can prespecify
* separate arrays of vertices, normals, colors, and texture
* coordinates and use them to construct a sequence of primitives
* with a single call to <code>glDrawElements</code>.
*
* <p>When <code>glDrawElements</code> is called, it uses
* <code>count</code> sequential indices from <code>indices</code>
* to lookup elements in enabled arrays to construct a sequence of
* geometric primitives. <code>mode</code> specifies what kind of
* primitives are constructed, and how the array elements construct
* these primitives. If <code>GL_VERTEX_ARRAY</code> is not enabled,
* no geometric primitives are constructed.
*
* <p>Vertex attributes that are modified by
* <code>glDrawElements</code> have an unspecified value after
* <code>glDrawElements</code> returns. For example, if
* <code>GL_COLOR_ARRAY</code> is enabled, the value of the current
* color is undefined after <code>glDrawElements</code>
* executes. Attributes that aren't modified maintain their previous
* values.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if <code>mode</code>
* is not an accepted value.
*
* <p><code>GL_INVALID_ENUM</code> is generated if <code>type</code>
* is not an accepted value.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>count</code> is negative.
*
* @param mode Specifies what kind of primitives to render. Symbolic
* constants <code>GL_POINTS</code>, <code>GL_LINE_STRIP</code>,
* <code>GL_LINE_LOOP</code>, <code>GL_LINES</code>,
* <code>GL_TRIANGLE_STRIP</code>, <code>GL_TRIANGLE_FAN</code>, and
* <code>GL_TRIANGLES</code> are accepted.
* @param count Specifies the number of elements to be rendered.
* @param type Specifies the type of the values in indices. Must be
* either <code>GL_UNSIGNED_BYTE</code> or <code>GL_UNSIGNED_SHORT</code>.
* @param indices Specifies a pointer to the location where the
* indices are stored.
*
* @exception IllegalStateException if the most recent call to
* <code>glBindBuffer</code> for the
* <code>GL_ELEMENT_ARRAY_BUFFER</code> target had a non-zero
* <code>buffer</code> parameter (i.e., an index buffer is bound).
* @exception IllegalArgumentException if <code>indices</code> is
* <code>null</code>.
* @exception ArrayIndexOutOfBoundsException if any index in the
* sequence of indices from <code>0</code> to <code>count - 1</code>
* would result in a reference to an entry outside of the currently
* bound index or data (vertex, color, normal, texture coordinate
* array, weight, matrix index, or point size) array.
*/
void glDrawElements(int mode, int count, int type, Buffer indices);
/**
* Enable server-side GL capabilities.
*
* <p><code>glEnable</code> and <code>glDisable</code> enable and
* disable various capabilities. The initial value for each
* capability with the exception of <code>GL_DITHER</code> and
* <code>GL_MULTISAMPLE</code> is <code>GL_FALSE</code>. The initial
* value for <code>GL_DITHER</code> and <code>GL_MULTISAMPLE</code>
* is <code>GL_TRUE</code>.
*
* <p>Both <code>glEnable</code> and <code>glDisable</code> take a
* single argument, <code>cap</code>, which can assume one of the
* following values:
*
* <ul>
* <li><code>GL_ALPHA_TEST</code></li>
*
* <p>If enabled, do alpha testing. See <code>glAlphaFunc</code>.
*
* <li><code>GL_BLEND</code></li>
*
* <p>If enabled, blend the incoming color values with the values in
* the color buffers. See <code>glBlendFunc</code>.
*
* <li><code>GL_COLOR_LOGIC_OP</code></li>
*
* <p>If enabled, apply the currently selected logical operation to the
* incoming color and color buffer values. See <code>glLogicOp</code>.
*
* <li><code>GL_COLOR_MATERIAL</code></li>
*
* <p>If enabled, have ambient and diffuse material parameters track
* the current color.
*
* <li><code>GL_CULL_FACE</code></li>
*
* <p>If enabled, cull polygons based on their winding in window
* coordinates. See <code>glCullFace</code>.
*
* <li><code>GL_DEPTH_TEST</code></li>
*
* <p>If enabled, do depth comparisons and update the depth
* buffer. Note that even if the depth buffer exists and the depth
* mask is non-zero, the depth buffer is not updated if the depth
* test is disabled. See <code>glDepthFunc</code>,
* <code>glDepthMask</code>, and <code>glDepthRange</code>.
*
* <li><code>GL_DITHER</code></li>
*
* <p>If enabled, dither color components or indices before they are
* written to the color buffer.
*
* <li><code>GL_FOG</code></li>
*
* <p>If enabled, blend a fog color into the posttexturing color. See
* <code>glFog</code>.
*
* <li><code>GL_LIGHT</code><i>i</i></li>
*
* <p>If enabled, include light <i>i</i> in the evaluation of the
* lighting equation. See <code>glLightModel</code> and
* <code>glLight</code>.
*
* <li><code>GL_LIGHTING</code></li>
*
* <p>If enabled, use the current lighting parameters to compute the
* vertex color. Otherwise, simply associate the current color with
* each vertex. See <code>glMaterial</code>,
* <code>glLightModel</code>, and <code>glLight</code>.
*
* <li><code>GL_LINE_SMOOTH</code></li>
*
* <p>If enabled, draw lines with correct filtering. Otherwise, draw
* aliased lines. See <code>glLineWidth</code>.
*
* <li><code>GL_MULTISAMPLE</code></li>
*
* <p>If enabled, perform multisampling of fragments for single-pass
* antialiasing and other effects. See <code>glSampleCoverage</code>.
*
* <li><code>GL_NORMALIZE</code></li>
*
* <p>If enabled, normal vectors are scaled to unit length after
* transformation. See <code>glNormal</code> and
* <code>glNormalPointer</code>.
*
* <li><code>GL_POINT_SMOOTH</code></li>
*
* <p>If enabled, draw points with proper filtering. Otherwise, draw
* aliased points. See <code>glPointSize</code>.
*
* <li><code>GL_POLYGON_OFFSET_FILL</code></li>
*
* <p>If enabled, an offset is added to depth values of a polygon's
* fragments before the depth comparison is performed. See
* <code>glPolygonOffset</code>.
*
* <li><code>GL_RESCALE_NORMAL</code></li>
*
* <p>If enabled, normal vectors are scaled by a factor derived from
* the modelview matrix. See <code>glNormal</code> and
* <code>glNormalPointer</code>.
*
* <li><code>GL_SAMPLE_ALPHA_TO_MASK</code> (1.0 only)</li>
*
* <p>If enabled, convert fragment alpha values to multisample coverage
* modification masks. See <code>glSampleCoverage</code>.
*
* <li><code>GL_SAMPLE_ALPHA_TO_COVERAGE</code> (1.1 only)</li>
*
* <p>If enabled, a temporary coverage value is generated where each
* bit is determined by the alpha value at the corresponding sample
* location. The temporary coverage value is then ANDed with the
* fragment coverage value. Otherwise the fragment coverage value is
* unchanged at this point. See <code>glSampleCoverage</code>.
*
* <li><code>GL_SAMPLE_ALPHA_TO_ONE</code></li>
*
* <p>If enabled, set fragment alpha to the maximum permissible value
* after computing multisample coverage modification masks. See
* <code>glSampleCoverage</code>.
*
* <li><code>GL_SAMPLE_MASK</code> (1.0 only)</li>
*
* <p>If enabled, apply a mask to modify fragment coverage during
* multisampling. See <code>glSampleCoverage</code>.
*
* <li><code>GL_SAMPLE_COVERAGE</code> (1.1 only)</li>
*
* <p>If enabled, the fragment coverage is ANDed with another temporary
* coverage. This temporary coverage is generated in the same manner
* as for <code>GL_SAMPLE_ALPHA_TO_COVERAGE</code> described above,
* but as a function of the value of
* <code>GL_SAMPLE_COVERAGE_VALUE</code>. If
* <code>GL_SAMPLE_COVERAGE_INVERT</code> is <code>GL_TRUE</code>,
* the temporary coverage is inverted (all bit values are inverted)
* before it is ANDed with the fragment coverage. See
* <code>glSampleCoverage</code>.
*
* <li><code>GL_SCISSOR_TEST</code></li>
*
* <p>If enabled, discard fragments that are outside the scissor
* rectangle. See <code>glScissor</code>.
*
* <li><code>GL_STENCIL_TEST</code></li>
*
* <p>If enabled, do stencil testing and update the stencil buffer. See
* <code>glStencilFunc</code>, <code>glStencilMask</code>, and
* <code>glStencilOp</code>.
*
* <li><code>GL_TEXTURE_2D</code></li>
*
* <p>If enabled, two-dimensional texturing is performed for the active
* texture unit. See <code>glActiveTexture</code>,
* <code>glTexImage2D</code>, <code>glCompressedTexImage2D</code>,
* and <code>glCopyTexImage2D</code>.
*
* <li><code>GL_CLIP_PLANE</code><i>i</i> (1.1 only)</li>
*
* <p>If enabled, clipping plane <i>i</i> is enabled. See
* <code>glClipPlane</code>.
*
* <li><code>GL_POINT_SPRITE_OES</code>
* (1.1 + <code>OES_point_sprite</code> extension)</li>
*
* <p>If enabled, point sprites are enabled. See
* <code>glPointSize</code> and <code>glTexEnv</code>.
*
* </ul>
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if cap is not one of
* the values listed previously.
*
* @param cap Specifies a symbolic constant indicating a GL capability.
*/
void glEnable(int cap);
/**
* Enable client-side capability.
*
* <p><code>glEnableClientState</code> and
* <code>glDisableClientState</code> enable or disable individual
* client-side capabilities. By default, all client-side
* capabilities are disabled. Both <code>glEnableClientState</code>
* and <code>glDisableClientState</code> take a single argument,
* <code>array</code>, which can assume one of the following values:
*
* <ul>
*
* <li><code>GL_COLOR_ARRAY</code></li>
*
* <p>If enabled, the color array is enabled for writing and used
* during rendering when <code>glDrawArrays</code>, or
* <code>glDrawElements</code> is called. See
* <code>glColorPointer</code>.
*
* <li><code>GL_NORMAL_ARRAY</code></li>
*
* <p>If enabled, the normal array is enabled for writing and used
* during rendering when <code>glDrawArrays</code>, or
* <code>glDrawElements</code> is called. See
* <code>glNormalPointer</code>.
*
* <li><code>GL_TEXTURE_COORD_ARRAY</code></li>
*
* <p>If enabled, the texture coordinate array is enabled for writing
* and used during rendering when <code>glDrawArrays</code>, or
* <code>glDrawElements</code> is called. See
* <code>glTexCoordPointer</code>.
*
* <li><code>GL_VERTEX_ARRAY</code></li>
*
* <p>If enabled, the vertex array is enabled for writing and used
* during rendering when <code>glDrawArrays</code>, or
* <code>glDrawElements</code> is called. See
* <code>glVertexPointer</code>.
*
* <li><code>GL_POINT_SIZE_ARRAY_OES</code>
* (<code>OES_point_size_array</code> extension)</li>
*
* <p>If enabled, the point size array controls the sizes used to
* render points and point sprites. In this case the point size
* defined by <code>glPointSize</code> is ignored. The point sizes
* supplied in the point size arrays will be the sizes used to
* render both points and point sprites. See
* <code>glPointSize</code>.
*
* </ul>
*
* <h4>Notes</h4>
*
* <p>Enabling and disabling <code>GL_TEXTURE_COORD_ARRAY</code>
* affects the active client texture unit. The active client texture
* unit is controlled with <code>glClientActiveTexture</code>.
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if
* <code>array</code> is not an accepted value.
*
* @param array Specifies the capability to enable or
* disable. Symbolic constants <code>GL_COLOR_ARRAY</code>,
* <code>GL_NORMAL_ARRAY</code>,
* <code>GL_TEXTURE_COORD_ARRAY</code>,
* <code>GL_VERTEX_ARRAY</code>, and
* <code>GL_POINT_SIZE_ARRAY_OES</code>
* (<code>OES_point_size_array</code> extension) are accepted. <!-- If the
* <code>OES_matrix_palette</code> extension is present, symbolic
* constants <code>GL_MATRIX_INDEX_ARRAY_OES</code>,
* <code>GL_WEIGHT_ARRAY_OES</code> are additionally accepted. -->
*/
void glEnableClientState(int array);
/**
* Block until all GL execution is complete.
*
* <p><code>glFinish</code> does not return until the effects of all
* previously called GL commands are complete. Such effects include
* all changes to GL state, all changes to connection state, and all
* changes to the frame buffer contents.
*
* <h4>Notes</h4>
*
* <p><code>glFinish</code> requires a round trip to the server.
*/
void glFinish();
/**
* Force execution of GL commands in finite time.
*
* <p>Different GL implementations buffer commands in several
* different locations, including network buffers and the graphics
* accelerator itself. <code>glFlush</code> empties all of these
* buffers, causing all issued commands to be executed as quickly as
* they are accepted by the actual rendering engine. Though this
* execution may not be completed in any particular time period, it
* does complete in finite time.
*
* <p>Because any GL program might be executed over a network, or on an
* accelerator that buffers commands, all programs should call
* <code>glFlush</code> whenever they count on having all of their previously
* issued commands completed. For example, call <code>glFlush</code> before
* waiting for user input that depends on the generated image.
*
* <h4>Notes</h4>
*
* <p><code>glFlush</code> can return at any time. It does not wait until the
* execution of all previously issued GL commands is complete.
*/
void glFlush();
/**
* Specify fog parameters.
*
* <p>If fog is enabled, fog affects rasterized geometry, bitmaps,
* and pixel blocks, but not buffer clear operations. To enable and
* disable fog, call <code>glEnable</code> and
* <code>glDisable</code> with argument <code>GL_FOG</code>. Fog is
* initially disabled.
*
* <p><code>glFog</code> assigns the value in <code>param</code> to
* the fog parameter specified by <code>pname</code>. The following
* values are accepted for <code>pname</code>:
*
* <ul>
*
* <li><code>GL_FOG_MODE</code></li>
*
* <p><code>param</code> is a single value that specifies the equation
* to be used to compute the fog blend factor f. Three symbolic
* constants are accepted: <code>GL_LINEAR</code>,
* <code>GL_EXP</code>, and <code>GL_EXP2</code>. The equations
* corresponding to these symbolic constants are defined below. The
* initial fog mode is <code>GL_EXP</code>.
*
* <li><code>GL_FOG_DENSITY</code></li>
*
* <p><code>param</code> is a single value that specifies density, the
* fog density used in both exponential fog equations. Only
* nonnegative densities are accepted. The initial fog density is 1.
*
* <li><code>GL_FOG_START</code></li>
*
* <p><code>param</code> is a single value that specifies start, the
* near distance used in the linear fog equation. The initial near
* distance is 0.
*
* <li><code>GL_FOG_END</code></li>
*
* <p><code>param</code> is a single value that specifies end, the far
* distance used in the linear fog equation. The initial far
* distance is 1.
*
* </ul>
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if
* <code>pname</code> is not an accepted value, or if
* <code>pname</code> is <code>GL_FOG_MODE</code> and
* <code>param</code> is not an accepted value.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>pname</code> is <code>GL_FOG_DENSITY</code>, and
* <code>param</code> is negative.
*
* @param pname Specifies a single-valued fog
* parameter. <code>GL_FOG_MODE</code>, <code>GL_FOG_DENSITY</code>,
* <code>GL_FOG_START</code>, and <code>GL_FOG_END</code> are
* accepted.
* @param param Specifies the value that <code>pname</code> will be
* set to.
*/
void glFogf(int pname, float param);
/**
* Specify fog parameters (array version).
*
* <p>If fog is enabled, fog affects rasterized geometry, bitmaps,
* and pixel blocks, but not buffer clear operations. To enable and
* disable fog, call <code>glEnable</code> and
* <code>glDisable</code> with argument <code>GL_FOG</code>. Fog is
* initially disabled.
*
* <p><code>glFog</code> assigns the value or values in
* <code>params</code> to the fog parameter specified by
* <code>pname</code>. The following values are accepted for
* <code>pname</code>:
*
* <ul>
*
* <li><code>GL_FOG_MODE</code></li>
*
* <p><code>params</code> contains a single value that specifies the
* equation to be used to compute the fog blend factor f. Three
* symbolic constants are accepted: <code>GL_LINEAR</code>,
* <code>GL_EXP</code>, and <code>GL_EXP2</code>. The equations
* corresponding to these symbolic constants are defined below. The
* initial fog mode is <code>GL_EXP</code>.
*
* <li><code>GL_FOG_DENSITY</code></li>
*
* <p><code>params</code> contains a single value that specifies
* density, the fog density used in both exponential fog
* equations. Only nonnegative densities are accepted. The initial
* fog density is 1.
*
* <li><code>GL_FOG_START</code></li>
*
* <p><code>params</code> contains a single value that specifies start,
* the near distance used in the linear fog equation. The initial
* near distance is 0.
*
* <li><code>GL_FOG_END</code></li>
*
* <p><code>params</code> contains a single value that specifies end,
* the far distance used in the linear fog equation. The initial far
* distance is 1.
*
* <li><code>GL_FOG_COLOR</code></li>
*
* <p><code>params</code> contains four values that specify
* <i>Cf</i>, the fog color. Both fixed-point and floating-point
* values are mapped directly. After conversion, all color
* components are clamped to the range <code>[0, 1]</code>. The
* initial fog color is <code>(0, 0, 0, 0)</code>.
*
* </ul>
*
* <p>Fog blends a fog color with each rasterized pixel fragment's
* posttexturing color using a blending factor f. Factor f is computed in
* one of three ways, depending on the fog mode. Let z be the distance in
* eye coordinates from the origin to the fragment being fogged. The
* equation for <code>GL_LINEAR</code> fog is
*
* <pre>
* f = (end - z)/(end - start)
* </pre>
*
* <p>The equation for <code>GL_EXP</code> fog is
*
* <pre>
* f = e -(density - z)
* </pre>
*
* <p>The equation for <code>GL_EXP2</code> fog is
*
* <pre>
* f = e -(density - z)2
* </pre>
*
* <p>Regardless of the fog mode, <i>f</i> is clamped to the range
* <code>[0, 1]</code> after it is computed. Then, the fragment's
* red, green, and blue colors, represented by <i>Cr</i>, are
* replaced by:
*
* <pre>
* C'r = f Cr + (1 - f) Cf
* </pre>
*
* <p>Fog does not affect a fragment's alpha component.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if
* <code>pname</code> is not an accepted value, or if
* <code>pname</code> is <code>GL_FOG_MODE</code> and
* <code>params</code> is not an accepted value.
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>pname</code> is <code>GL_FOG_DENSITY</code>, and the first
* value in <code>params</code> is negative.
*
* @param pname Specifies a fog parameter. <code>GL_FOG_MODE</code>,
* <code>GL_FOG_DENSITY</code>, <code>GL_FOG_START</code>,
* <code>GL_FOG_END</code>, and <code>GL_FOG_COLOR</code> are
* accepted.
* @param params Specifies the value or values to be assigned to
* <code>pname</code>. <code>GL_FOG_COLOR</code> requires an array
* of four values. All other parameters accept an array containing
* only a single value.
* @param offset the starting offset within the
* <code>params</code> array.
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>params.length -
* offset</code> is smaller than the number of values required by
* the parameter.
*/
void glFogfv(int pname, float[] params, int offset);
/**
* Floating-point <code>Buffer</code> version of <code>glFog</code>.
*
* @see #glFogfv(int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>params.remaining()</code> is smaller than the number of
* values required by the parameter.
*/
void glFogfv(int pname, FloatBuffer params);
/**
* Fixed-point version of <code>glFog</code>.
*
* @see #glFogf(int pname, float param)
*/
void glFogx(int pname, int param);
/**
* Fixed-point array version of <code>glFog</code>.
*
* @see #glFogfv(int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>params.length -
* offset</code> is smaller than the number of values required by
* the parameter.
*/
void glFogxv(int pname, int[] params, int offset);
/**
* Fixed-point <code>Buffer</code> version of <code>glFog</code>.
*
* @see #glFogfv(int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>params.remaining()</code> is smaller than the number of
* values required by the parameter.
*/
void glFogxv(int pname, IntBuffer params);
/**
* Define front- and back-facing polygons.
*
* <p>In a scene composed entirely of opaque closed surfaces,
* back-facing polygons are never visible. Eliminating (culling)
* these invisible polygons has the obvious benefit of speeding up
* the rendering of the image. To enable and disable culling, call
* <code>glEnable</code> and <code>glDisable</code> with argument
* <code>GL_CULL_FACE</code>. Culling is initially disabled.
*
* <p>The projection of a polygon to window coordinates is said to
* have clockwise winding if an imaginary object following the path
* from its first vertex, its second vertex, and so on, to its last
* vertex, and finally back to its first vertex, moves in a
* clockwise direction about the interior of the polygon. The
* polygon's winding is said to be counterclockwise if the imaginary
* object following the same path moves in a counterclockwise
* direction about the interior of the polygon. glFrontFace
* specifies whether polygons with clockwise winding in window
* coordinates, or counterclockwise winding in window coordinates,
* are taken to be front-facing. Passing <code>GL_CCW</code> to
* <code>mode</code> selects counterclockwise polygons as
* front-facing. <code>GL_CW</code> selects clockwise polygons as
* front-facing. By default, counterclockwise polygons are taken to
* be front-facing.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if <code>mode</code>
* is not an accepted value.
*
* @param mode Specifies the orientation of front-facing
* polygons. <code>GL_CW</code> and <code>GL_CCW</code> are
* accepted. The initial value is <code>GL_CCW</code>.
*/
void glFrontFace(int mode);
// Need revisit - definition wrong?
/**
* Multiply the current matrix by a perspective matrix.
*
* <p><code>glFrustum</code> describes a perspective matrix that
* produces a perspective projection. The current matrix (see
* <code>glMatrixMode</code>) is multiplied by this matrix and the
* result replaces the current matrix, as if
* <code>glMultMatrix</code> were called with the following matrix
* as its argument:
*
* <pre>
* ( 2/(right - left) 0 A 0 )
* ( 0 2/(top - bottom) B 0 )
* ( 0 0 C D )
* ( 0 0 -1 0 )
* </pre>
*
* <p>where
*
* <pre>
* A = - (right + left)/(right - left)
* B = - (top + bottom)/(top - bottom)
* C = - (far + near)/(far - near)
* D = - 2farnear/(far - near)
* </pre>
*
* <p>Typically, the matrix mode is <code>GL_PROJECTION</code>, and
* (<code>left</code>, <code>bottom</code>, -<code>near</code>) and
* (<code>right</code>, <code>top</code>, -<code>near</code>)
* specify the points on the near clipping plane that are mapped to
* the lower left and upper right corners of the window, assuming
* that the eye is located at (0, 0, 0). -<code>far</code> specifies
* the location of the far clipping plane. Both <code>near</code>
* and <code>far</code> must be positive.
*
* <p>Use <code>glPushMatrix</code> and <code>glPopMatrix</code> to
* save and restore the current matrix stack.
*
* <h4>Notes</h4>
*
* <p>Depth buffer precision is affected by the values specified for
* near and far. The greater the ratio of <code>far</code> to
* <code>near</code> is, the less effective the depth buffer will be
* at distinguishing between surfaces that are near each other. If
*
* <pre>
* r = far/near
* </pre>
*
* roughly log_2(<i>r</i>) bits of depth buffer precision are
* lost. Because <i>r</i> approaches infinity as <code>near</code>
* approaches 0, <code>near</code> must never be set to 0.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_VALUE</code> is generated if
* <code>near</code> or <code>far</code> is not positive, or if
* <code>left</code> = <code>right</code>, or <code>bottom</code> =
* <code>top</code>.
*
* @param left Specifies the coordinate for the left vertical
* clipping plane.
* @param right Specifies the coordinate for the right vertical
* clipping plane.
* @param bottom Specifies the coordinate for the bottom horizontal
* clipping plane.
* @param top Specifies the coordinate for the top horizontal
* clipping plane.
* @param near Specifies the distances to the near depth clipping
* plane. The distance must be positive.
* @param far Specifies the distances to the near depth clipping
* plane. The distance must be positive.
*/
void glFrustumf(float left, float right,
float bottom, float top,
float near, float far);
/**
* Fixed-point version of <code>glFrustum</code>.
*
* @see #glFrustumf
*/
void glFrustumx(int left, int right,
int bottom, int top,
int near, int far);
/**
* Generate texture names.
*
* <p><code>glGenTextures</code> returns <code>n</code> texture
* names in <code>textures</code>. There is no guarantee that the
* names form a contiguous set of integers. However, it is
* guaranteed that none of the returned names was in use immediately
* before the call to <code>glGenTextures</code>.
*
* <p>The generated textures have no dimensionality; they assume the
* dimensionality of the texture target to which they are first
* bound (see glBindTexture).
*
* <p>Texture names returned by a call to <code>glGenTextures</code> are not
* returned by subsequent calls, unless they are first deleted with
* <code>glDeleteTextures</code>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_VALUE</code> is generated if <code>n</code>
* is negative.
*
* @param n Specifies the number of texture names to be generated.
* @param textures Specifies an array in which the generated texture
* names are stored.
* @param offset the starting offset within the
* <code>textures</code> array.
*
* @exception IllegalArgumentException if <code>textures</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>textures.length -
* offset</code> is less than <code>n</code>.
*/
void glGenTextures(int n, int[] textures, int offset);
/**
* Integer <code>Buffer</code> version of <code>glGenTextures</code>.
*
* @see #glGenTextures(int n, int[] textures, int offset)
*
* @exception IllegalArgumentException if <code>textures</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>textures.remaining()</code> is less than <code>n</code>.
*/
void glGenTextures(int n, IntBuffer textures);
/**
* Return error information.
*
* <p><code>glGetError</code> returns the value of the error
* flag. Each detectable error is assigned a numeric code and
* symbolic name. When an error occurs, the error flag is set to the
* appropriate error code value. No other errors are recorded until
* <code>glGetError</code> is called, the error code is returned,
* and the flag is reset to <code>GL_NO_ERROR</code>. If a call to
* <code>glGetError</code> returns <code>GL_NO_ERROR</code>, there
* has been no detectable error since the last call to
* <code>glGetError</code>, or since the GL was initialized.
*
* <p>To allow for distributed implementations, there may be several
* error flags. If any single error flag has recorded an error, the
* value of that flag is returned and that flag is reset to
* <code>GL_NO_ERROR</code> when <code>glGetError</code> is
* called. If more than one flag has recorded an error,
* <code>glGetError</code> returns and clears an arbitrary error
* flag value. Thus, <code>glGetError</code> should always be called
* in a loop, until it returns <code>GL_NO_ERROR</code>, if all
* error flags are to be reset.
*
* <p>Initially, all error flags are set to <code>GL_NO_ERROR</code>.
*
* <p>The following errors are currently defined:
*
* <ul>
*
* <li><code>GL_NO_ERROR</code></li>
*
* <p>No error has been recorded. The value of this symbolic constant
* is guaranteed to be 0.
*
* <li><code>GL_INVALID_ENUM</code></li>
*
* <p>An unacceptable value is specified for an enumerated
* argument. The offending command is ignored, and has no other side
* effect than to set the error flag.
*
* <li><code>GL_INVALID_VALUE</code></li>
*
* <p>A numeric argument is out of range. The offending command is
* ignored, and has no other side effect than to set the error flag.
*
* <li><code>GL_INVALID_OPERATION</code></li>
*
* <p>The specified operation is not allowed in the current state. The
* offending command is ignored, and has no other side effect than
* to set the error flag.
*
* <li><code>GL_STACK_OVERFLOW</code></li>
*
* <p>This command would cause a stack overflow. The offending command
* is ignored, and has no other side effect than to set the error
* flag.
*
* <li><code>GL_STACK_UNDERFLOW</code></li>
*
* <p>This command would cause a stack underflow. The offending command
* is ignored, and has no other side effect than to set the error
* flag.
*
* <li><code>GL_OUT_OF_MEMORY</code></li>
*
* <p>There is not enough memory left to execute the command. The state
* of the GL is undefined, except for the state of the error flags,
* after this error is recorded.
*
* </ul>
*
* <p>When an error flag is set, results of a GL operation are
* undefined only if <code>GL_OUT_OF_MEMORY</code> has occurred. In
* all other cases, the command generating the error is ignored and
* has no effect on the GL state or frame buffer contents. If the
* generating command returns a value, it returns 0. If
* <code>glGetError</code> itself generates an error, it returns 0.
*
* @return One of the error codes listed above.
*/
int glGetError();
/**
* Return the value or values of a selected parameter.
*
* <p><code>glGet</code> returns values for static state
* variables in GL. <code>pname</code> is a symbolic constant
* indicating the static state variable to be returned, and
* <code>params</code> is an array of integers in which to place the
* returned data.
*
* <p> A boolean value is interpreted as either 1 or 0, and a
* floating-point value is rounded to the nearest integer, unless
* the value is an RGBA color component, a <code>DepthRange</code>
* value, a depth buffer clear value, or a normal coordinate. In
* these cases, the <code>glGet</code> command does a linear mapping
* that maps 1.0 to the most positive representable integer value,
* and -1.0 to the most negative representable integer value.
*
* <p> In OpenGL ES 1.0, on <code>glGetIntegerv</code> is provided.
* OpenGL ES 1.1 additionally provides <code>glGetBooleanv</code>,
* <code>glGetFixedv</code>, and <code>glGetFloatv</code>.
*
* <p>The following symbolic constants are accepted by
* <code>pname</code>:
*
* <ul>
* <li><code>GL_ALIASED_POINT_SIZE_RANGE</code></li>
*
* <p><code>params</code> returns two values, the smallest and largest
* supported sizes for aliased points. The range must include 1. See
* <code>glPointSize</code>.
*
* <li><code>GL_ALIASED_LINE_WIDTH_RANGE</code></li>
*
* <p><code>params</code> returns two values, the smallest and largest
* supported widths for aliased lines. The range must include 1. See
* <code>glLineWidth</code>.
*
* <li><code>GL_ALPHA_BITS</code></li>
*
* <p><code>params</code> returns one value, the number of alpha
* bitplanes in the color buffer.
*
* <li><code>GL_ALPHA_TEST_FUNC</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the symbolic name of
* the alpha test function. See <code>glAlphaFunc</code>.
*
* <li><code>GL_ALPHA_TEST_REF</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the reference value for
* the alpha test. An integer value, if requested, is linearly
* mapped from the internal floating-point representation such that
* 1.0 returns the most positive representable integer value, and
* -1.0 returns the most negative representable integer value. See
* <code>glAlphaFunc</code>.
*
* <li><code>GL_BLEND_DST</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the symbolic constant
* identifying the destination blend function set by
* <code>glBlendFunc</code>, or the destination RGB blend function
* set by <code>glBlendFuncSeparate</code>. See
* <code>glBlendFunc</code> and <code>glBlendFuncSeparate</code>.
*
* <li><code>GL_BLUE_BITS</code></li>
*
* <p><code>params</code> returns one value, the number of blue
* bitplanes in the color buffer.
*
* <li><code>GL_COLOR_ARRAY_BUFFER_BINDING</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the color array buffer
* binding. See <code>glColorPointer</code>.
*
* <li><code>GL_COLOR_ARRAY_SIZE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the number of
* components per color in the color array. See
* <code>glColorPointer</code>.
*
* <li><code>GL_COLOR_ARRAY_STRIDE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the byte offset between
* consecutive colors in the color array. See
* <code>glColorPointer</code>.
*
* <li><code>GL_COLOR_ARRAY_TYPE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, returns the data type
* of each component in the color array. See
* <code>glColorPointer</code>.
*
* <li><code>GL_COLOR_CLEAR_VALUE</code> (1.1 only)</li>
*
* <p><code>params</code> returns four values: the red, green, blue,
* and alpha values used to clear the color buffers. See
* <code>glClearColor</code>
*
* <li><code>GL_COLOR_WRITEMASK</code> (1.1 only)</li>
*
* <p><code>params</code> returns four boolean values: the red,
* green, blue, and alpha write enables for the color buffers. See
* <code>glColorMask</code>.
*
* <li><code>GL_COMPRESSED_TEXTURE_FORMATS</code></li>
*
* <p><code>params</code> returns
* <code>GL_NUM_COMPRESSED_TEXTURE_FORMATS</code> values, the
* supported compressed texture formats. See glCompressedTexImage2D
* and <code>glCompressedTexSubImage2D</code>.
*
* <li><code>GL_CULL_FACE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, a symbolic constant
* indicating which polygon faces are to be culled. See
* <code>glCullFace</code>.
*
* <li><code>GL_DEPTH_BITS</code></li>
*
* <p><code>params</code> returns one value, the number of bitplanes in
* the depth buffer.
*
* <li><code>GL_DEPTH_CLEAR_VALUE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the value that is used
* to clear the depth buffer. See <code>glClearDepth</code>.
*
* <li><code>GL_DEPTH_FUNC</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the symbolic name of
* the depth comparision function. See <code>glDepthFunc</code>.
*
* <li><code>GL_DEPTH_RANGE</code> (1.1 only)</li>
*
* <p><code>params</code> returns two values: the near and far
* mapping limits for the depth buffer. See
* <code>glDepthRange</code>.
*
* <li><code>GL_DEPTH_WRITEMASK</code> (1.1 only)</li>
*
* <p><code>params</code> returns a single boolean value indicating
* if the depth buffer is enabled for writing. See
* <code>glDepthMask</code>.
*
* <li><code>GL_FOG_COLOR</code> (1.1 only)</li>
*
* <p><code>params</code> returns four values: the red, green, blue,
* and alpha components of the fog color. See <code>glFog</code>.
*
* <li><code>GL_FOG_DENSITY</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the fog density
* parameter. See <code>glFog</code>.
*
* <li><code>GL_FOG_END</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the end factor for the
* linear fog equation. See <code>glFog</code>.
*
* <li><code>GL_FOG_HINT</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, a symbolic constant
* indicating the mode of the fog hint. See <code>glHint</code>.
*
* <li><code>GL_FOG_MODE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, a symbolic constant
* indicating which fog equation is selected. See <code>glFog</code>.
*
* <li><code>GL_FOG_START</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the start factor for
* the linear fog equation. See <code>glFog</code>.
*
* <li><code>GL_FRONT_FACE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, a symbolic constant
* indicating whether clockwise or counterclockwise polygon winding
* is treated as front-facing. See <code>glFrontFace</code>.
*
* <li><code>GL_GREEN_BITS</code></li>
*
* <p><code>params</code> returns one value, the number of green
* bitplanes in the color buffer.
*
* <li><code>GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES</code>
* (<code>OES_read_format</code> extension)</li>
*
* <p><code>params</code> returns one value, the preferred format for
* pixel read back. See <code>glReadPixels</code>.
*
* <li><code>GL_IMPLEMENTATION_COLOR_READ_TYPE_OES</code> (
* (<code>OES_read_format</code> extension)</li>
*
* <p><code>params</code> returns one value, the preferred type for
* pixel read back. See <code>glReadPixels</code>.
*
* <li><code>GL_LIGHT_MODEL_AMBIENT</code> (1.1 only)</li>
*
* <p><code>params</code> returns four values: the red, green, blue,
* and alpha components of the ambient intensity of the entire
* scene. See <code>glLightModel</code>.
*
* <li><code>GL_LIGHT_MODEL_TWO_SIDE</code> (1.1 only)</li>
*
* <p><code>params</code> returns a single boolean value indicating
* whether separate materials are used to compute lighting for front
* and back facing polygons. See <code>glLightModel</code>.
*
* <li><code>GL_LINE_SMOOTH_HINT</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, a symbolic constant
* indicating the mode of the line antialiasing hint. See
* <code>glHint</code>.
*
* <li><code>GL_LINE_WIDTH</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the line width as
* specified with <code>glLineWidth</code>.
*
* <li><code>GL_LOGIC_OP_MODE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, a symbolic constant
* indicating the selected logic operation mode. See
* <code>glLogicOp</code>.
*
* <li><code>GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES</code>
* (<code>OES_matrix_palette</code> extension)</li>
*
* <p><code>params</code> returns one value, the matrix index array
* buffer binding. See <code>glMatrixIndexPointer</code>.
*
* <li><code>GL_MATRIX_INDEX_ARRAY_SIZE_OES</code>
* (<code>OES_matrix_palette</code> extension)</li>
*
* <p><code>params</code> returns one value, the number of matrix
* indices per vertex. See <code>glMatrixIndexPointer</code>.
*
* <li><code>GL_MATRIX_INDEX_ARRAY_STRIDE_OES</code>
* (<code>OES_matrix_palette</code> extension)</li>
*
* <p><code>params</code> returns one value, the byte offset between
* matrix indices. See <code>glMatrixIndexPointer</code>.
*
* <li><code>GL_MATRIX_INDEX_ARRAY_TYPE_OES</code>
* (<code>OES_matrix_palette</code> extension)</li>
*
* <p><code>params</code> returns one value, the data type of each
* matrix index in the matrix indices array. See
* <code>glMatrixIndexPointer</code>.
*
* <li><code>GL_MATRIX_MODE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, a symbolic constant
* indicating which matrix stack is currently the target of all
* matrix operations. See <code>glMatrixMode</code>.
*
* <li><code>GL_MAX_CLIP_PLANES</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the maximum number of
* application defined clipping planes. The value must be at least
* 6. See <code>glClipPlane</code>.
*
* <li><code>GL_MAX_ELEMENTS_INDICES</code></li>
*
* <p><code>params</code> returns one value, the recommended maximum
* number of vertex array indices. See <code>glDrawElements</code>.
*
* <li><code>GL_MAX_ELEMENTS_VERTICES</code></li>
*
* <p><code>params</code> returns one value, the recommended maximum
* number of vertex array vertices. See <code>glDrawArrays</code>
* and <code>glDrawElements</code>.
*
* <li><code>GL_MAX_LIGHTS</code></li>
*
* <p><code>params</code> returns one value, the maximum number of
* lights. The value must be at least 8. See <code>glLight</code>.
*
* <li><code>GL_MAX_MODELVIEW_STACK_DEPTH</code></li>
*
* <p><code>params</code> returns one value, the maximum supported
* depth of the modelview matrix stack. The value must be at least
* 16. See <code>glPushMatrix</code>.
*
* <li><code>GL_MAX_PALETTE_MATRICES_OES</code>
* (<code>OES_matrix_palette</code> extension)</li>
*
* <p><code>params</code> returns the size of the matrix
* palette. The initial value is 9.
*
* <li><code>GL_MAX_PROJECTION_STACK_DEPTH</code></li>
*
* <p><code>params</code> returns one value, the maximum supported
* depth of the projection matrix stack. The value must be at least
* 2. See <code>glPushMatrix</code>.
*
* <li><code>GL_MAX_TEXTURE_SIZE</code></li>
*
* <p><code>params</code> returns one value. The value gives a rough
* estimate of the largest texture that the GL can handle. The value
* must be at least 64. See <code>glTexImage2D</code>,
* <code>glCompressedTexImage2D</code>, and
* <code>glCopyTexImage2D</code>.
*
* <li><code>GL_MAX_TEXTURE_STACK_DEPTH</code></li>
*
* <p><code>params</code> returns one value, the maximum supported
* depth of the texture matrix stack. The value must be at least
* 2. See <code>glPushMatrix</code>.
*
* <li><code>GL_MAX_TEXTURE_UNITS</code></li>
*
* <p><code>params</code> returns a single value indicating the number
* of texture units supported. The value must be at least 1. See
* <code>glActiveTexture</code>, <code>glClientActiveTexture</code>
* and <code>glMultiTexCoord</code>.
*
* <li><code>GL_MAX_VERTEX_UNITS_OES</code>
*
* <p><code>params</code> returns the number of matrices per
* vertex. The initial value is 3.
*
* <li><code>GL_MAX_VIEWPORT_DIMS</code></li>
*
* <p><code>params</code> returns two values: the maximum supported
* width and height of the viewport. These must be at least as large
* as the visible dimensions of the display being rendered to. See
* <code>glViewport</code>.
*
* <li><code>GL_MODELVIEW_MATRIX</code> (1.1 only)</li>
*
* <p><code>params</code> returns sixteen values: the modelview
* matrix on the top of the modelview matrix stack. See
* <code>glPushMatrix</code>.
*
* <li><code>GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES</code>
* (<code>OES_matrix_get</code> extension)</li>
*
* <p><code>params</code> returns a representation of the floating
* point Model View matrix elements as as an array of integers,
* according to the IEEE 754 floating point "single format" bit
* layout. See <code>glMatrixMode</code>.
*
* <li><code>GL_MODELVIEW_STACK_DEPTH</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the number of matrices
* on the modelview matrix stack. See <code>glPushMatrix</code>.
*
* <li><code>GL_NORMAL_ARRAY_BUFFER_BINDING</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the normal array buffer
* binding. See <code>glNormalPointer</code>.
*
* <li><code>GL_NORMAL_ARRAY_STRIDE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the byte offset between
* consective normals in the normal array. See
* <code>glNormalPointer</code>.
*
* <li><code>GL_NORMAL_ARRAY_TYPE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the data type of each
* normal in the normal array. See <code>glNormalPointer</code>.
*
* <li><code>GL_NUM_COMPRESSED_TEXTURE_FORMATS</code></li>
*
* <p><code>params</code> returns one value, the number of supported
* compressed texture formats. The value must be at least 10. See
* <code>glCompressedTexImage2D</code> and
* <code>glCompressedTexSubImage2D</code>.
*
* <li><code>GL_PACK_ALIGNMENT</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the byte alignment used
* for writing pixel data to memory. See <code>glPixelStore</code>.
*
* <li><code>GL_PERSPECTIVE_CORRECTION_HINT</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, a symbolic constant
* indicating the mode of the perspective correction hint. See
* <code>glHint</code>.
*
* <li><code>GL_POINT_SIZE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the point size as
* specified by <code>glPointSize</code>.
*
* <li><code>GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES</code>
* (<code>OES_point_size_array</code> extension)</li>
*
* <p><code>params</code> returns one value, the point size array
* buffer binding. See <code>glPointSizePointer</code>.
*
* <li><code>GL_POINT_SIZE_ARRAY_STRIDE_OES</code>
* (<code>OES_point_size_array</code> extension)</li>
*
* <p><code>params</code> returns one value, the byte offset between
* consecutive point sizes in the point size array. See
* <code>glPointSizePointer</code>.
*
* <li><code>GL_POINT_SIZE_ARRAY_TYPE_OES</code>
* (<code>OES_point_size_array</code> extension)</li>
*
* <p><code>params</code> returns one value, the data type of each
* point size in the point array. See
* <code>glPointSizePointer</code>.
*
* <li><code>GL_POINT_SMOOTH_HINT</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, a symbolic constant
* indicating the mode of the point antialiasing hint. See
* <code>glHint</code>.
*
* <li><code>GL_POLYGON_OFFSET_FACTOR</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the scaling factor used
* to determine the variable offset that is added to the depth value
* of each fragment generated when a polygon is rasterized. See
* <code>glPolygonOffset</code>.
*
* <li><code>GL_POLYGON_OFFSET_UNITS</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value. This value is
* multiplied by an implementation-specific value and then added to
* the depth value of each fragment generated when a polygon is
* rasterized. See <code>glPolygonOffset</code>.
*
* <li><code>GL_PROJECTION_MATRIX</code> (1.1 only)</li>
*
* <p><code>params</code> returns sixteen values: the projection
* matrix on the top of the projection matrix stack. See
* <code>glPushMatrix</code>.
*
* <li><code>GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES</code>
* (<code>OES_matrix_get</code> extension)</li>
*
* <p><code>params</code> returns a representation of the floating
* point Projection matrix elements as as an array of integers,
* according to the IEEE 754 floating point "single format" bit
* layout. See <code>glMatrixMode</code>.
*
* <li><code>GL_PROJECTION_STACK_DEPTH</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the number of matrices
* on the projection matrix stack. See <code>glPushMatrix</code>.
*
* <li><code>GL_RED_BITS</code></li>
*
* <p><code>params</code> returns one value, the number of red
* bitplanes in each color buffer.
*
* <li><code>GL_SCISSOR_BOX</code> (1.1 only)</li>
*
* <p><code>params</code> returns four values: the x and y window
* coordinates of the scissor box, followed by its width and
* height. See <code>glScissor</code>.
*
* <li><code>GL_SHADE_MODEL</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, a symbolic constant
* indicating whether the shading mode is flat or smooth. See
* <code>glShadeModel</code>.
*
* <li><code>GL_SMOOTH_LINE_WIDTH_RANGE</code></li>
*
* <p><code>params</code> returns two values, the smallest and largest
* supported widths for antialiased lines. The range must include
* 1. See <code>glLineWidth</code>.
*
* <li><code>GL_SMOOTH_POINT_SIZE_RANGE</code></li>
*
* <p><code>params</code> returns two values, the smallest and largest
* supported widths for antialiased points. The range must include
* 1. See <code>glPointSize</code>.
*
* <li><code>GL_STENCIL_BITS</code></li>
*
* <p><code>params</code> returns one value, the number of bitplanes in
* the stencil buffer.
*
* <li><code>GL_STENCIL_CLEAR_VALUE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the index to which the
* stencil bitplanes are cleared. See <code>glClearStencil</code>.
*
* <li><code>GL_STENCIL_FAIL</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, a symbolic constant
* indicating what action is taken when the stencil test fails. See
* <code>glStencilOp</code>.
*
* <li><code>GL_STENCIL_FUNC</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, a symbolic constant
* indicating what function is used to compare the stencil reference
* value with the stencil buffer value. See
* <code>glStencilFunc</code>.
*
* <li><code>GL_STENCIL_PASS_DEPTH_FAIL</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, a symbolic constant
* indicating what action is taken when the stencil test passes, but
* the depth test fails. See <code>glStencilOp</code>.
*
* <li><code>GL_STENCIL_PASS_DEPTH_PASS</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, a symbolic constant
* indicating what action is taken when the stencil test passes, and
* the depth test passes. See <code>glStencilOp</code>.
*
* <li><code>GL_STENCIL_REF</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the reference value
* that is compared with the contents of the stencil buffer. See
* <code>glStencilFunc</code>.
*
* <li><code>GL_STENCIL_VALUE_MASK</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the mask that is used
* to mask both the stencil reference value and the stencil buffer
* value before they are compared. See <code>glStencilFunc</code>.
*
* <li><code>GL_STENCIL_WRITEMASK</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the mask that controls
* writing of the stencil bitplanes. See <code>glStencilMask</code>.
*
* <li><code>GL_SUBPIXEL_BITS</code></li>
*
* <p><code>params</code> returns one value, an estimate of the number
* of bits of subpixel resolution that are used to position
* rasterized geometry in window coordinates. The value must be at
* least 4.
*
* <li><code>GL_TEXTURE_BINDING_2D</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the name of the texture
* currently bound to the target <code>GL_TEXTURE_2D</code>. See
* <code>glBindTexture</code>.
*
* <li><code>GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the texture coordinate
* array buffer binding. See <code>glTexCoordPointer</code>.
*
* <li><code>GL_TEXTURE_COORD_ARRAY_SIZE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the number of
* coordinates per element in the texture coordinate array. See
* <code>glTexCoordPointer</code>.
*
* <li><code>GL_TEXTURE_COORD_ARRAY_STRIDE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the byte offset between
* consecutive elements in the texture coordinate array. See
* <code>glTexCoordPointer</code>.
*
* <li><code>GL_TEXTURE_COORD_ARRAY_TYPE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, returns the data type
* of each coordinate in the texture coordinate array. See
* <code>glTexCoordPointer</code>.
*
* <li><code>GL_TEXTURE_MATRIX</code> (1.1 only)</li>
*
* <p><code>params</code> returns sixteen values: the texture matrix
* on the top of the texture matrix stack. See
* <code>glPushMatrix</code>.
*
* <li><code>GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES</code>
* (<code>OES_matrix_get</code> extension)</li>
*
* <p><code>params</code> returns a representation of the floating
* point Texture matrix elements as as an array of integers,
* according to the IEEE 754 floating point "single format" bit
* layout. See <code>glMatrixMode</code>.
*
* <li><code>GL_TEXTURE_STACK_DEPTH</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the number of matrices
* on the texture matrix stack. See <code>glBindTexture</code>.
*
* <li><code>GL_UNPACK_ALIGNMENT</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the byte alignment used
* for reading pixel data from memory. See
* <code>glPixelStore</code>.
*
* <li><code>GL_VIEWPORT</code> (1.1 only)</li>
*
* <p><code>params</code> returns four values:, the x and y window
* coordinates of the viewport, followed by its width and
* height. See <code>glViewport</code>.
*
* <li><code>GL_VERTEX_ARRAY_BUFFER_BINDING</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the vertex array buffer
* binding. See <code>glVertexPointer</code>.
*
* <li><code>GL_VERTEX_ARRAY_SIZE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, number of coordinates
* per vertex in the vertex array. See <code>glVertexPointer</code>.
*
* <li><code>GL_VERTEX_ARRAY_STRIDE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, the byte offset between
* consecutive vertexes in the vertex array. See
* <code>glVertexPointer</code>.
*
* <li><code>GL_VERTEX_ARRAY_TYPE</code> (1.1 only)</li>
*
* <p><code>params</code> returns one value, returns the data type
* of each coordinate in the vertex array. See
* <code>glVertexPointer</code>.
*
* <li><code>GL_WEIGHT_ARRAY_BUFFER_BINDING_OES</code>
* (<code>OES_matrix_palette</code> extension)</li>
*
* <p><code>params</code> returns one value, the weight array buffer
* binding. See <code>glWeightPointer</code>.
*
* <li><code>GL_WEIGHT_ARRAY_SIZE_OES</code>
* (<code>OES_matrix_palette</code> extension)</li>
*
* <p><code>params</code> returns one value, the number of weights
* per vertex. See <code>glWeightPointer</code>.
*
* <li><code>GL_WEIGHT_ARRAY_STRIDE_OES</code>
* (<code>OES_matrix_palette</code> extension)</li>
*
* <p><code>params</code> returns one value, the byte offset between
* weights per vertex. See <code>glWeightPointer</code>.
*
* <li><code>GL_WEIGHT_ARRAY_TYPE_OES</code>
* (<code>OES_matrix_palette</code> extension)</li>
*
* <p><code>params</code> returns one value, the data type of each
* weight in the weight array. See <code>glWeightPointer</code>.
*
* </ul>
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if <code>pname</code>
* is not an accepted value.
*
* @param pname Specifies the parameter value to be returned. The
* symbolic constants in the list above are accepted.
* @param params Returns the value or values of the specified
* parameter.
* @param offset the starting offset within the
* <code>params</code> array.
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>params.length -
* offset</code> is smaller than the number of values required by
* the parameter.
*/
void glGetIntegerv(int pname, int[] params, int offset);
/**
* Integer <code>Buffer</code> version of <code>glGetIntegerv</code>.
*
* @see #glGetIntegerv(int pname, int[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>params.remaining()</code> is smaller than the number of
* values required by the parameter.
*/
void glGetIntegerv(int pname, IntBuffer params);
/**
* Return a string describing the underlying GL implementation. The
* GL string is converted to UTF8 format to produce a standard Java
* <code>String</code> object.
*
* <p><code>glGetString</code> returns a <code>String</code>
* describing some aspect of the current GL
* implementation. <code>name</code> can be one of the following:
*
* <ul>
*
* <li><code>GL_VENDOR</code></li>
*
* <p>Returns the company responsible for this GL implementation. This
* name does not change from release to release.
*
* <li><code>GL_RENDERER</code></li>
*
* <p>Returns the name of the renderer. This name is typically specific
* to a particular configuration of a hardware platform. It does not
* change from release to release.
*
* <li><code>GL_VERSION</code></li>
*
* <p>Returns the particular OpenGL ES profile as well as the
* version of that profile.
*
* <li><code>GL_EXTENSIONS</code></li>
*
* <p>Returns a space-separated list of supported extensions to GL.
*
* </ul>
*
* <p>Because the GL does not include queries for the performance
* characteristics of an implementation, some applications are
* written to recognize known platforms and modify their GL usage
* based on known performance characteristics of these
* platforms. Strings <code>GL_VENDOR</code> and
* <code>GL_RENDERER</code> together uniquely specify a
* platform. They do not change from release to release and should
* be used by platform-recognition algorithms.
*
* <p>Some applications want to make use of features that are not part
* of the standard GL. These features may be implemented as
* extensions to the standard GL. The <code>GL_EXTENSIONS</code>
* string is a space-separated list of supported GL
* extensions. (Extension names never contain a space character.)
*
* <p>The <code>GL_VERSION</code> string begins with a version
* number. The version number uses one of these forms:
*
* <p><i>major_number.minor_number</i> (1.0 only)
* <p><i>major_number.minor_number.release_number</i> (1.0 only)
* <p><i>OpenGL ES-CM</i> followed by
* <i>major_number.minor_number</i> for the common profile (1.1 only).
* <p><i>OpenGL ES-CL</i> followed by <i>major_number.minor_number</i> for
* the common-lite profile (1.1 only).
*
* <p>On 1.0 implementations, vendor-specific information may
* follow the version number. A space always separates the version
* number and the vendor-specific information.
*
* <h4>Notes</h4>
*
* <p>If an error is generated, <code>glGetString</code> returns NULL.
*
* <p>The client and server may support different versions or
* extensions. <code>glGetString</code> always returns a compatible
* version number or list of extensions. The release number always
* describes the server.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if <code>name</code>
* is not an accepted value.
*
* @param name Specifies a symbolic constant, one of
* <code>GL_VENDOR</code>, <code>GL_RENDERER</code>,
* <code>GL_VERSION</code>, or <code>GL_EXTENSIONS</code>.
*
* @return A <code>String</code> formatted as described above.
*/
String glGetString(int name);
/**
* Specify implementation-specific hints.
*
* <p>Certain aspects of GL behavior, when there is room for
* interpretation, can be controlled with hints. A hint is specified
* with two arguments. <code>target</code> is a symbolic constant
* indicating the behavior to be controlled, and <code>mode</code>
* is another symbolic constant indicating the desired behavior. The
* initial value for each <code>target</code> is
* <code>GL_DONT_CARE</code>. <code>mode</code> can be one of the
* following:
*
* <ul>
*
* <li><code>GL_FASTEST</code></li>
*
* <p>The most efficient option should be chosen.
*
* <li><code>GL_NICEST</code></li>
*
* <p>The most correct, or highest quality, option should be chosen.
*
* <li><code>GL_DONT_CARE</code></li>
*
* <p>No preference.
*
* </ul>
*
* <p>Though the implementation aspects that can be hinted are well
* defined, the interpretation of the hints depends on the
* implementation. The hint aspects that can be specified with
* <code>target</code>, along with suggested semantics, are as follows:
*
* <ul>
*
* <li><code>GL_FOG_HINT</code></li>
*
* <p>Indicates the accuracy of fog calculation. If per-pixel fog
* calculation is not efficiently supported by the GL
* implementation, hinting <code>GL_DONT_CARE</code> or
* <code>GL_FASTEST</code> can result in per-vertex calculation of
* fog effects.
*
* <li><code>GL_LINE_SMOOTH_HINT</code></li>
*
* <p>Indicates the sampling quality of antialiased lines. If a larger
* filter function is applied, hinting <code>GL_NICEST</code> can
* result in more pixel fragments being generated during
* rasterization,
*
* <li><code>GL_PERSPECTIVE_CORRECTION_HINT</code></li>
*
* <p>Indicates the quality of color and texture coordinate
* interpolation. If perspective-corrected parameter interpolation
* is not efficiently supported by the GL implementation, hinting
* <code>GL_DONT_CARE</code> or <code>GL_FASTEST</code> can result
* in simple linear interpolation of colors and/or texture
* coordinates.
*
* <li><code>GL_POINT_SMOOTH_HINT</code></li>
*
* <p>Indicates the sampling quality of antialiased points. If a larger
* filter function is applied, hinting <code>GL_NICEST</code> can
* result in more pixel fragments being generated during
* rasterization.
*
* <li><code>GL_GENERATE_MIPMAP_HINT</code> (1.1 only)</li>
*
* <p>Indicates the desired quality and performance of automatic
* mipmap level generation.
*
* </ul>
*
* <h4>Notes</h4>
*
* <p>The interpretation of hints depends on the implementation. Some
* implementations ignore <code>glHint</code> settings.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if either
* <code>target</code> or <code>mode</code> is not an accepted
* value.
*
* @param target Specifies a symbolic constant indicating the
* behavior to be controlled. <code>GL_FOG_HINT</code> ,
* <code>GL_LINE_SMOOTH_HINT</code> ,
* <code>GL_PERSPECTIVE_CORRECTION_HINT</code>, and
* <code>GL_POINT_SMOOTH_HINT</code> are accepted. On 1.1,
* <code>GL_GENERATE_MIPMAP_HINT</code> is additionally accepted.
* @param mode Specifies a symbolic constant indicating the desired
* behavior. <code>GL_FASTEST</code>, <code>GL_NICEST</code>, and
* <code>GL_DONT_CARE</code> are accepted.
*/
void glHint(int target, int mode);
/**
* Set the lighting model parameters.
*
* <p><code>glLightModel</code> sets the lighting model
* parameter. <code>pname</code> names a parameter and param gives
* the new value. There is one single-valued lighting model parameter:
*
* <ul>
*
* <li><code>GL_LIGHT_MODEL_TWO_SIDE</code></li>
*
* <p><code>param</code> specifies whether one- or two-sided lighting
* calculations are done for polygons. It has no effect on the
* lighting calculations for points, lines, or bitmaps. If
* <code>param</code> is 0, one-sided lighting is specified, and
* only the front material parameters are used in the lighting
* equation. Otherwise, two-sided lighting is specified. In this
* case, vertices of back-facing polygons are lighted using the back
* material parameters, and have their normals reversed before the
* lighting equation is evaluated. Vertices of front-facing polygons
* are always lighted using the front material parameters, with no
* change to their normals. The initial value is 0.
*
* </ul>
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if
* <code>pname</code> is not an accepted value.
*
* @param pname Specifies a single-valued lighting model
* parameter. Must be <code>GL_LIGHT_MODEL_TWO_SIDE</code>.
* @param param Specifies the value that <code>param</code> will be
* set to.
*/
void glLightModelf(int pname, float param);
/**
* Set the lighting model parameters (array version).
*
* <p><code>glLightModel</code> sets the lighting model
* parameter. <code>pname</code> names a parameter and
* <code>params</code> gives the new value. There are two lighting
* model parameters:
*
* <ul>
*
* <li><code>GL_LIGHT_MODEL_AMBIENT</code></li>
*
* <p><code>params</code> contains four values that specify the ambient
* intensity of the entire scene. The values are not clamped. The
* initial value is (0.2, 0.2, 0.2, 1.0).
*
* <li><code>GL_LIGHT_MODEL_TWO_SIDE</code></li>
*
* <p><code>params</code> contains a single value that specifies
* whether one- or two-sided lighting calculations are done for
* polygons. It has no effect on the lighting calculations for
* points, lines, or bitmaps. If <code>params</code> contains 0,
* one-sided lighting is specified, and only the front material
* parameters are used in the lighting equation. Otherwise,
* two-sided lighting is specified. In this case, vertices of
* back-facing polygons are lighted using the back material
* parameters, and have their normals reversed before the lighting
* equation is evaluated. Vertices of front-facing polygons are
* always lighted using the front material parameters, with no
* change to their normals. The initial value is 0.
*
* </ul>
*
* <p>The lighted color of a vertex is the sum of the material
* emission intensity, the product of the material ambient
* reflectance and the lighting model full-scene ambient intensity,
* and the contribution of each enabled light source. Each light
* source contributes the sum of three terms: ambient, diffuse, and
* specular. The ambient light source contribution is the product of
* the material ambient reflectance and the light's ambient
* intensity. The diffuse light source contribution is the product
* of the material diffuse reflectance, the light's diffuse
* intensity, and the dot product of the vertex's normal with the
* normalized vector from the vertex to the light source. The
* specular light source contribution is the product of the material
* specular reflectance, the light's specular intensity, and the dot
* product of the normalized vertex-to-eye and vertex-to-light
* vectors, raised to the power of the shininess of the
* material. All three light source contributions are attenuated
* equally based on the distance from the vertex to the light source
* and on light source direction, spread exponent, and spread cutoff
* angle. All dot products are replaced with 0 if they evaluate to a
* negative value.
*
* <p>The alpha component of the resulting lighted color is set to the
* alpha value of the material diffuse reflectance.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if
* <code>pname</code> is not an accepted value.
*
* @param pname Specifies a lighting model
* parameter. <code>GL_LIGHT_MODEL_AMBIENT</code> and
* <code>GL_LIGHT_MODEL_TWO_SIDE</code> are accepted.
* @param params Specifies an array containing values that parameter
* <code>pname</code> will be set to.
* @param offset the starting offset within the
* <code>params</code> array.
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>params.length -
* offset</code> is smaller than the number of values required by
* the parameter.
*/
void glLightModelfv(int pname, float[] params, int offset);
/**
* Floating-point <code>Buffer</code> version of <code>glLightModel</code>.
*
* @see #glLightModelfv(int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>params.remaining()</code> is smaller than the number of
* values required by the parameter.
*/
void glLightModelfv(int pname, FloatBuffer params);
/**
* Fixed-point version of <code>glLightModel</code>.
*
* @see #glLightModelf(int pname, float param)
*/
void glLightModelx(int pname, int param);
/**
* Fixed-point array version of <code>glLightModel</code>.
*
* @see #glLightModelfv(int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>params.length -
* offset</code> is smaller than the number of values required by
* the parameter.
*/
void glLightModelxv(int pname, int[] params, int offset);
/**
* Fixed-point <code>Buffer</code> version of <code>glLightModel</code>.
*
* @see #glLightModelfv(int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>params.remaining()</code> is smaller than the number of
* values required by the parameter.
*/
void glLightModelxv(int pname, IntBuffer params);
/**
* Set light source parameters.
*
* <p><code>glLight</code> sets the values of individual light
* source parameters. <code>light</code> names the light and is a
* symbolic name of the form <code>GL_LIGHT</code><i>i</i>, where
* <code>0 <= <i>i</i> < GL_MAX_LIGHTS</code>. <code>pname</code>
* specifies one of ten light source parameters, again by symbolic
* name. <code>param</code> contains the new value.
*
* <p>To enable and disable lighting calculation, call
* <code>glEnable</code> and <code>glDisable</code> with argument
* <code>GL_LIGHTING</code>. Lighting is initially disabled. When it
* is enabled, light sources that are enabled contribute to the
* lighting calculation. Light source <i>i</i> is enabled and disabled
* using <code>glEnable</code> and <code>glDisable</code> with
* argument <code>GL_LIGHT</code><i>i</i>.
*
* <p>The light parameters are as follows:
*
* <ul>
*
* <li><code>GL_SPOT_EXPONENT</code></li>
*
* <p><code>param</code> is a single value that specifies the
* intensity distribution of the light. Fixed-point and
* floating-point values are mapped directly. Only values in the
* range [0, 128] are accepted.
*
* <p>Effective light intensity is attenuated by the cosine of the
* angle between the direction of the light and the direction from
* the light to the vertex being lighted, raised to the power of the
* spot exponent. Thus, higher spot exponents result in a more
* focused light source, regardless of the spot cutoff angle (see
* <code>GL_SPOT_CUTOFF</code>, next paragraph). The initial spot
* exponent is 0, resulting in uniform light distribution.
*
* <li><code>GL_SPOT_CUTOFF</code></li>
*
* <p><code>param</code> is a single value that specifies the maximum
* spread angle of a light source. Fixed-point and floating-point
* values are mapped directly. Only values in the range [0, 90] and
* the special value 180 are accepted. If the angle between the
* direction of the light and the direction from the light to the
* vertex being lighted is greater than the spot cutoff angle, the
* light is completely masked. Otherwise, its intensity is
* controlled by the spot exponent and the attenuation factors. The
* initial spot cutoff is 180, resulting in uniform light
* distribution.
*
* <li><code>GL_CONSTANT_ATTENUATION</code>,
* <code>GL_LINEAR_ATTENUATION</code>,
* <code>GL_QUADRATIC_ATTENUATION</code></li>
*
* <p><code>param</code> is a single value that specifies one of the
* three light attenuation factors. Fixed-point and floating-point
* values are mapped directly. Only nonnegative values are
* accepted. If the light is positional, rather than directional,
* its intensity is attenuated by the reciprocal of the sum of the
* constant factor, the linear factor times the distance between the
* light and the vertex being lighted, and the quadratic factor
* times the square of the same distance. The initial attenuation
* factors are (1, 0, 0), resulting in no attenuation.
*
* </ul>
*
* <h4>Notes</h4>
*
* <p>It is always the case that <code>GL_LIGHT</code><i>i</i> =
* <code>GL_LIGHT0</code> + <i>i</i>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if either
* <code>light</code> or <code>pname</code> is not an accepted
* value.
*
* <p><code>GL_INVALID_VALUE</code> is generated if a spot exponent
* value is specified outside the range [0, 128], or if spot cutoff
* is specified outside the range [0, 90] (except for the special
* value 180), or if a negative attenuation factor is specified.
*
* @param light Specifies a light. The number of lights depends on
* the implementation, but at least eight lights are supported. They
* are identified by symbolic names of the form
* <code>GL_LIGHT</code><i>i</i> where <code>0 <= <i>i</i> <
* GL_MAX_LIGHTS</code>.
* @param pname Specifies a single-valued light source parameter for
* light. <code>GL_SPOT_EXPONENT</code>,
* <code>GL_SPOT_CUTOFF</code>,
* <code>GL_CONSTANT_ATTENUATION</code>,
* <code>GL_LINEAR_ATTENUATION</code>, and
* <code>GL_QUADRATIC_ATTENUATION</code> are accepted.
* @param param Specifies the value that parameter
* <code>pname</code> of light source light will be set to.
*/
void glLightf(int light, int pname, float param);
/**
* Set light source parameters (array version).
*
* <p><code>glLight</code> sets the values of individual light
* source parameters. <code>light</code> names the light and is a
* symbolic name of the form <code>GL_LIGHT</code><i>i</i>, where
* <code>0 <= <i>i</i> < GL_MAX_LIGHTS</code>. <code>pname</code>
* specifies one of ten light source parameters, again by symbolic
* name. <code>params</code> is an array that contains the new
* values.
*
* <p>To enable and disable lighting calculation, call
* <code>glEnable</code> and <code>glDisable</code> with argument
* <code>GL_LIGHTING</code>. Lighting is initially disabled. When it
* is enabled, light sources that are enabled contribute to the
* lighting calculation. Light source <i>i</i> is enabled and disabled
* using <code>glEnable</code> and <code>glDisable</code> with
* argument <code>GL_LIGHT</code><i>i</i>.
*
* <p>The light parameters are as follows:
*
* <ul>
*
* <li><code>GL_AMBIENT</code></li>
*
* <p><code>params</code> contains four values that specify the ambient
* RGBA intensity of the light. Both fixed-point and floating-point
* values are mapped directly. Neither fixed-point nor
* floating-point values are clamped. The initial ambient light
* intensity is (0, 0, 0, 1).
*
* <li><code>GL_DIFFUSE</code></li>
*
* <p><code>params</code> contains four values that specify the diffuse
* RGBA intensity of the light. Both fixed-point and floating-point
* values are mapped directly. Neither fixed-point nor
* floating-point values are clamped. The initial value for
* <code>GL_LIGHT0</code> is (1, 1, 1, 1). For other lights, the
* initial value is (0, 0, 0, 0).
*
* <li><code>GL_SPECULAR</code></li>
*
* <p><code>params</code> contains four values that specify the
* specular RGBA intensity of the light. Both fixed-point and
* floating-point values are mapped directly. Neither fixed-point
* nor floating-point values are clamped. The initial value for
* <code>GL_LIGHT0</code> is (1, 1, 1, 1). For other lights, the
* initial value is (0, 0, 0, 0).
*
* <li><code>GL_POSITION</code> (1.0 only)</li>
*
* <p><code>params</code> contains four values that specify the
* position of the light in homogeneous object coordinates. Both
* fixed-point and floating-point values are mapped
* directly. Neither fixed-point nor floating-point values are
* clamped.
*
* <p>The position is transformed by the modelview matrix when
* <code>glLight</code> is called (just as if it were a point), and
* it is stored in eye coordinates. If the w component of the
* position is 0, the light is treated as a directional
* source. Diffuse and specular lighting calculations take the
* light's direction, but not its actual position, into account, and
* attenuation is disabled. Otherwise, diffuse and specular lighting
* calculations are based on the actual location of the light in eye
* coordinates, and attenuation is enabled. The initial position is
* (0, 0, 1, 0). Thus, the initial light source is directional,
* parallel to, and in the direction of the -z axis.
*
* <li><code>GL_SPOT_DIRECTION</code></li>
*
* <p><code>params</code> contains three values that specify the
* direction of the light in homogeneous object coordinates. Both
* fixed-point and floating-point values are mapped
* directly. Neither fixed-point nor floating-point values are
* clamped.
*
* <p>The spot direction is transformed by the inverse of the modelview
* matrix when <code>glLight</code> is called (just as if it were a
* normal), and it is stored in eye coordinates. It is significant
* only when <code>GL_SPOT_CUTOFF</code> is not 180, which it is
* initially. The initial direction is (0, 0, -1).
*
* <li><code>GL_SPOT_EXPONENT</code></li>
*
* <p><code>params</code> is a single value that specifies the
* intensity distribution of the light. Fixed-point and
* floating-point values are mapped directly. Only values in the
* range [0, 128] are accepted.
*
* <p>Effective light intensity is attenuated by the cosine of the
* angle between the direction of the light and the direction from
* the light to the vertex being lighted, raised to the power of the
* spot exponent. Thus, higher spot exponents result in a more
* focused light source, regardless of the spot cutoff angle (see
* <code>GL_SPOT_CUTOFF</code>, next paragraph). The initial spot
* exponent is 0, resulting in uniform light distribution.
*
* <li><code>GL_SPOT_CUTOFF</code></li>
*
* <p><code>params</code> is a single value that specifies the maximum
* spread angle of a light source. Fixed-point and floating-point
* values are mapped directly. Only values in the range [0, 90] and
* the special value 180 are accepted. If the angle between the
* direction of the light and the direction from the light to the
* vertex being lighted is greater than the spot cutoff angle, the
* light is completely masked. Otherwise, its intensity is
* controlled by the spot exponent and the attenuation factors. The
* initial spot cutoff is 180, resulting in uniform light
* distribution.
*
* <li><code>GL_CONSTANT_ATTENUATION</code>,
* <code>GL_LINEAR_ATTENUATION</code>,
* <code>GL_QUADRATIC_ATTENUATION</code></li>
*
* <p><code>params</code> is a single value that specifies one of the
* three light attenuation factors. Fixed-point and floating-point
* values are mapped directly. Only nonnegative values are
* accepted. If the light is positional, rather than directional,
* its intensity is attenuated by the reciprocal of the sum of the
* constant factor, the linear factor times the distance between the
* light and the vertex being lighted, and the quadratic factor
* times the square of the same distance. The initial attenuation
* factors are (1, 0, 0), resulting in no attenuation.
*
* </ul>
*
* <h4>Notes</h4>
*
* <p>It is always the case that <code>GL_LIGHT</code><i>i</i> =
* <code>GL_LIGHT0</code> + <i>i</i>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if either
* <code>light</code> or <code>pname</code> is not an accepted
* value.
*
* <p><code>GL_INVALID_VALUE</code> is generated if a spot exponent
* value is specified outside the range [0, 128], or if spot cutoff
* is specified outside the range [0, 90] (except for the special
* value 180), or if a negative attenuation factor is specified.
*
* @param light Specifies a light. The number of lights depends on
* the implementation, but at least eight lights are supported. They
* are identified by symbolic names of the form
* <code>GL_LIGHT</code><i>i</i> where <code>0 <= <i>i</i> <
* GL_MAX_LIGHTS</code>.
* @param pname Specifies a light source parameter for
* light. <code>GL_AMBIENT</code>, <code>GL_DIFFUSE</code>,
* <code>GL_SPECULAR</code>, <code>GL_POSITION</code> (1.0 only),
* <code>GL_SPOT_CUTOFF</code>, <code>GL_SPOT_DIRECTION</code>,
* <code>GL_SPOT_EXPONENT</code>,
* <code>GL_CONSTANT_ATTENUATION</code>,
* <code>GL_LINEAR_ATTENUATION</code>, and
* <code>GL_QUADRATIC_ATTENUATION</code> are accepted.
* @param params Specifies an array containing values that parameter
* <code>pname</code> of light source light will be set to.
* @param offset the starting offset within the
* <code>params</code> array.
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>params.length -
* offset</code> is smaller than the number of values required by
* the parameter.
*/
void glLightfv(int light, int pname, float[] params, int offset);
/**
* Floating-point <code>Buffer</code> version of <code>glLight</code>.
*
* @see #glLightfv(int light, int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>params.remaining()</code> is smaller than the number of
* values required by the parameter.
*/
void glLightfv(int light, int pname, FloatBuffer params);
/**
* Fixed-point version of <code>glLight</code>.
*
* @see #glLightf(int light, int pname, float param)
*/
void glLightx(int light, int pname, int param);
/**
* Fixed-point array version of <code>glLight</code>.
*
* @see #glLightfv(int light, int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>params.length -
* offset</code> is smaller than the number of values required by
* the parameter.
*/
void glLightxv(int light, int pname, int[] params, int offset);
/**
* Fixed-point <code>Buffer</code> version of <code>glLight</code>.
*
* @see #glLightfv(int light, int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>params.remaining()</code> is smaller than the number of
* values required by the parameter.
*/
void glLightxv(int light, int pname, IntBuffer params);
/**
* Specify the width of rasterized lines.
*
* <p><code>glLineWidth</code> specifies the rasterized width of
* both aliased and antialiased lines. Using a line width other than
* 1 has different effects, depending on whether line antialiasing
* is enabled. To enable and disable line antialiasing, call
* <code>glEnable</code> and <code>glDisable</code> with argument
* <code>GL_LINE_SMOOTH</code>. Line antialiasing is initially
* disabled.
*
* <p>If line antialiasing is disabled, the actual width is
* determined by rounding the supplied width to the nearest
* integer. (If the rounding results in the value 0, it is as if the
* line width were 1.) If <code>|delta x| >= |delta y|</code>,
* <i>i</i> pixels are filled in each column that is rasterized,
* where <i>i</i> is the rounded value of
* <code>width</code>. Otherwise, <i>i</i> pixels are filled in each
* row that is rasterized.
*
* <p>If antialiasing is enabled, line rasterization produces a
* fragment for each pixel square that intersects the region lying
* within the rectangle having width equal to the current line
* width, length equal to the actual length of the line, and
* centered on the mathematical line segment. The coverage value for
* each fragment is the window coordinate area of the intersection
* of the rectangular region with the corresponding pixel
* square. This value is saved and used in the final rasterization
* step.
*
* <p>Not all widths can be supported when line antialiasing is
* enabled. If an unsupported width is requested, the nearest
* supported width is used. Only width 1 is guaranteed to be
* supported; others depend on the implementation. Likewise, there
* is a range for aliased line widths as well. To query the range of
* supported widths and the size difference between supported widths
* within the range, call <code>glGetIntegerv</code> with arguments
* <code>GL_ALIASED_LINE_WIDTH_RANGE</code>,
* <code>GL_SMOOTH_LINE_WIDTH_RANGE</code>,
* <code>GL_SMOOTH_LINE_WIDTH_GRANULARITY</code>.
*
* <h4>Notes</h4>
*
* <p>Nonantialiased line width may be clamped to an
* implementation-dependent maximum. Call <code>glGetIntegerv</code>
* with <code>GL_ALIASED_LINE_WIDTH_RANGE</code> to determine the
* maximum width.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_VALUE</code> is generated if width is less
* than or equal to 0.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_ALIASED_LINE_WIDTH_RANGE</code>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_SMOOTH_LINE_WIDTH_RANGE</code>
*
* @param width Specifies the width of rasterized lines. The initial
* value is 1.
*/
void glLineWidth(float width);
/**
* Fixed-point version of <code>glLineWidth</code>.
*
* @see #glLineWidth
*/
void glLineWidthx(int width);
/**
* Replace the current matrix with the identity matrix.
*
* <p><code>glLoadIdentity</code> replaces the current matrix with
* the identity matrix. It is semantically equivalent to calling
* glLoadMatrix with the identity matrix
*
* <pre>
* ( 1 0 0 0 )
* ( 0 1 0 0 )
* ( 0 0 1 0 )
* ( 0 0 0 1 )
* </pre>
*
* but in some cases it is more efficient.
*/
void glLoadIdentity();
/**
* Replace the current matrix with the specified matrix.
*
* <p><code>glLoadMatrix</code> replaces the current matrix with the
* one whose elements are specified by <code>m</code>. The current
* matrix is the projection matrix, modelview matrix, or texture
* matrix, depending on the current matrix mode (see glMatrixMode).
*
* <p>The current matrix, <code>M</code>, defines a transformation
* of coordinates. For instance, assume <code>M</code> refers to the
* modelview matrix. If <code>v = (v[0], v[1], v[2], v[3])</code> is
* the set of object coordinates of a vertex, and <code>m</code> is
* an array of 16 fixed-point or single-precision floating-point
* values <code>m[0]</code>, <code>m[1]</code>, ...,
* <code>m[15]</code>, then the modelview transformation
* <code>M(v)</code> does the following:
*
* <pre>
* ( m[0] m[4] m[8] m[12] ) ( v[0] )
* M(v) = ( m[1] m[5] m[9] m[13] ) x ( v[1] )
* ( m[2] m[6] m[10] m[14] ) ( v[2] )
* ( m[3] m[7] m[11] m[15] ) ( v[3] )
* </pre>
*
* where "x" denotes matrix multiplication.
*
* <p>Projection and texture transformations are similarly defined.
*
* <h4>Notes</h4>
*
* <p>While the elements of the matrix may be specified with single or
* double precision, the GL implementation may store or operate on
* these values in less than single precision.
*
* @param m Specifies an array of at least 16 consecutive values,
* the first 16 of which are used as the elements of a 4 × 4
* column-major matrix.
* @param offset the starting offset within the
* <code>m</code> array.
*
* @exception IllegalArgumentException if <code>m</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>m.length -
* offset</code> is less than 16.
*/
void glLoadMatrixf(float[] m, int offset);
/**
* Floating-point <code>Buffer</code> version of <code>glLoadMatrix</code>.
*
* @see #glLoadMatrixf(float[] m, int offset)
*
* @exception IllegalArgumentException if <code>m</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>m.remaining()</code>
* is less than 16.
*/
void glLoadMatrixf(FloatBuffer m);
/**
* Fixed-point array version of <code>glLoadMatrix</code>.
*
* @see #glLoadMatrixf(float[] m, int offset)
*
* @exception IllegalArgumentException if <code>m</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>m.length -
* offset</code> is less than 16.
*/
void glLoadMatrixx(int[] m, int offset);
/**
* Fixed-point <code>Buffer</code> version of <code>glLoadMatrix</code>.
*
* @see #glLoadMatrixf(float[] m, int offset)
*
* @exception IllegalArgumentException if <code>m</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>m.remaining()</code>
* is less than 16.
*/
void glLoadMatrixx(IntBuffer m);
/**
* Specify a logical pixel operation.
*
* <p><code>glLogicOp</code> specifies a logical operation that,
* when enabled, is applied between the incoming color and the color
* at the corresponding location in the frame buffer. To enable or
* disable the logical operation, call <code>glEnable</code> and
* <code>glDisable</code> with argument
* <code>GL_COLOR_LOGIC_OP</code>. Logical operation is initially
* disabled.
*
* <pre>
* Opcode Resulting Operation
*
* GL_CLEAR 0
* GL_SET 1
* GL_COPY s
* GL_COPY_INVERTED ~ s
* GL_NOOP d
* GL_INVERT ~ d
* GL_AND s & d
* GL_NAND ~ (s & d)
* GL_OR s | d
* GL_NOR ~ (s | d)
* GL_XOR s ^ d
* GL_EQUIV ~ (s ^ d)
* GL_AND_REVERSE s & ~ d
* GL_AND_INVERTED ~ s & d
* GL_OR_REVERSE s | ~ d
* GL_OR_INVERTED ~ s | d
* </pre>
*
* <p><code>opcode</code> is a symbolic constant chosen from the
* list above. In the explanation of the logical operations,
* <i>s</i> represents the incoming color and <i>d</i> represents
* the color in the frame buffer. As in the Java language, "~"
* represents bitwise negation, "&" represents bitwise AND, "|"
* represents bitwise OR, and "^" represents bitwise XOR. As these
* bitwise operators suggest, the logical operation is applied
* independently to each bit pair of the source and destination
* indices or colors.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if opcode is not an
* accepted value.
*
* @param opcode Specifies a symbolic constant that selects a
* logical operation. The following symbols are accepted:
* <code>GL_CLEAR</code>, <code>GL_SET</code>, <code>GL_COPY</code>,
* <code>GL_COPY_INVERTED</code>, <code>GL_NOOP</code>,
* <code>GL_INVERT</code>, <code>GL_AND</code>,
* <code>GL_NAND</code>, <code>GL_OR</code>, <code>GL_NOR</code>,
* <code>GL_XOR</code>, <code>GL_EQUIV</code>,
* <code>GL_AND_REVERSE</code>, <code>GL_AND_INVERTED</code>,
* <code>GL_OR_REVERSE</code>, and <code>GL_OR_INVERTED</code>. The
* initial value is <code>GL_COPY</code>.
*/
void glLogicOp(int opcode);
/**
* Specify material parameters for the lighting model.
*
* <p><code>glMaterial</code> assigns values to material
* parameters. There are two matched sets of material
* parameters. One, the front-facing set, is used to shade points,
* lines, and all polygons (when two-sided lighting is disabled), or
* just front-facing polygons (when two-sided lighting is
* enabled). The other set, back-facing, is used to shade
* back-facing polygons only when two-sided lighting is
* enabled. Refer to the <code>glLightModel</code> reference page
* for details concerning one- and two-sided lighting calculations.
*
* <p><code>glMaterial</code> takes three arguments. The first,
* face, must be <code>GL_FRONT_AND_BACK</code> and specifies that
* both front and back materials will be modified. The second,
* pname, specifies which of several parameters in one or both sets
* will be modified. The third, params, specifies what value or
* values will be assigned to the specified parameter.
*
* <p>Material parameters are used in the lighting equation that is
* optionally applied to each vertex. The equation is discussed in
* the <code>glLightModel</code> reference page. The parameters that
* can be specified using <code>glMaterial</code>, and their
* interpretations by the lighting equation, are as follows:
*
* <ul>
*
* <li><code>GL_AMBIENT</code></li>
*
* <p><code>params</code> contains four fixed-point or
* floating-point values that specify the ambient RGBA reflectance
* of the material. The values are not clamped. The initial ambient
* reflectance is (0.2, 0.2, 0.2, 1.0).
*
* <li><code>GL_DIFFUSE</code></li>
*
* <p><code>params</code> contains four fixed-point or
* floating-point values that specify the diffuse RGBA reflectance
* of the material. The values are not clamped. The initial diffuse
* reflectance is (0.8, 0.8, 0.8, 1.0).
*
* <li><code>GL_SPECULAR</code></li>
*
* <p><code>params</code> contains four fixed-point or
* floating-point values that specify the specular RGBA reflectance
* of the material. The values are not clamped. The initial specular
* reflectance is (0, 0, 0, 1).
*
* <li><code>GL_EMISSION</code></li>
*
* <p><code>params</code> contains four fixed-point or
* floating-point values that specify the RGBA emitted light
* intensity of the material. The values are not clamped. The
* initial emission intensity is (0, 0, 0, 1).
*
* <li><code>GL_SHININESS</code></li>
*
* <p><code>params</code> is a single fixed-point or floating-point
* value that specifies the RGBA specular exponent of the
* material. Only values in the range [0, 128] are accepted. The
* initial specular exponent is 0.
*
* <li><code>GL_AMBIENT_AND_DIFFUSE</code></li>
*
* <p>Equivalent to calling <code>glMaterial</code> twice with the same
* parameter values, once with <code>GL_AMBIENT</code> and once with
* <code>GL_DIFFUSE</code>.
*
* </ul>
*
* <h4>Notes</h4>
*
* <p>To change the diffuse and ambient material per vertex, color
* material can be used. To enable and disable
* <code>GL_COLOR_MATERIAL</code>, call <code>glEnable</code> and
* <code>glDisable</code> with argument
* <code>GL_COLOR_MATERIAL</code>. Color material is initially
* disabled.
*
* <p>While the ambient, diffuse, specular and emission material
* parameters all have alpha components, only the diffuse alpha
* component is used in the lighting computation.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if either face or
* <code>pname</code> is not an accepted value.
*
* <p><code>GL_INVALID_VALUE</code> is generated if a specular
* exponent outside the range [0, 128] is specified.
*
* @param face Specifies which face or faces are being updated. Must
* be <code>GL_FRONT_AND_BACK</code>.
* @param pname Specifies the single-valued material parameter of
* the face or faces that is being updated. Must be
* <code>GL_SHININESS</code>.
* @param param Specifies the value that parameter
* <code>GL_SHININESS</code> will be set to.
*/
void glMaterialf(int face, int pname, float param);
/**
* Specify material parameters for the lighting model (array
* version).
*
* <p><code>glMaterial</code> assigns values to material
* parameters. There are two matched sets of material
* parameters. One, the front-facing set, is used to shade points,
* lines, and all polygons (when two-sided lighting is disabled), or
* just front-facing polygons (when two-sided lighting is
* enabled). The other set, back-facing, is used to shade
* back-facing polygons only when two-sided lighting is
* enabled. Refer to the <code>glLightModel</code> reference page
* for details concerning one- and two-sided lighting calculations.
*
* <p><code>glMaterial</code> takes three arguments. The first,
* face, must be <code>GL_FRONT_AND_BACK</code> and specifies that
* both front and back materials will be modified. The second,
* pname, specifies which of several parameters in one or both sets
* will be modified. The third, params, specifies what value or
* values will be assigned to the specified parameter.
*
* <p>Material parameters are used in the lighting equation that is
* optionally applied to each vertex. The equation is discussed in
* the <code>glLightModel</code> reference page. The parameters that
* can be specified using <code>glMaterial</code>, and their
* interpretations by the lighting equation, are as follows:
*
* <ul>
*
* <li><code>GL_AMBIENT</code></li>
*
* <p><code>params</code> contains four fixed-point or
* floating-point values that specify the ambient RGBA reflectance
* of the material. The values are not clamped. The initial ambient
* reflectance is (0.2, 0.2, 0.2, 1.0).
*
* <li><code>GL_DIFFUSE</code></li>
*
* <p><code>params</code> contains four fixed-point or
* floating-point values that specify the diffuse RGBA reflectance
* of the material. The values are not clamped. The initial diffuse
* reflectance is (0.8, 0.8, 0.8, 1.0).
*
* <li><code>GL_SPECULAR</code></li>
*
* <p><code>params</code> contains four fixed-point or
* floating-point values that specify the specular RGBA reflectance
* of the material. The values are not clamped. The initial specular
* reflectance is (0, 0, 0, 1).
*
* <li><code>GL_EMISSION</code></li>
*
* <p><code>params</code> contains four fixed-point or
* floating-point values that specify the RGBA emitted light
* intensity of the material. The values are not clamped. The
* initial emission intensity is (0, 0, 0, 1).
*
* <li><code>GL_SHININESS</code></li>
*
* <p><code>params</code> is a single fixed-point or floating-point
* value that specifies the RGBA specular exponent of the
* material. Only values in the range [0, 128] are accepted. The
* initial specular exponent is 0.
*
* <li><code>GL_AMBIENT_AND_DIFFUSE</code></li>
*
* <p>Equivalent to calling <code>glMaterial</code> twice with the same
* parameter values, once with <code>GL_AMBIENT</code> and once with
* <code>GL_DIFFUSE</code>.
*
* </ul>
*
* <h4>Notes</h4>
*
* <p>To change the diffuse and ambient material per vertex, color
* material can be used. To enable and disable
* <code>GL_COLOR_MATERIAL</code>, call <code>glEnable</code> and
* <code>glDisable</code> with argument
* <code>GL_COLOR_MATERIAL</code>. Color material is initially
* disabled.
*
* <p>While the ambient, diffuse, specular and emission material
* parameters all have alpha components, only the diffuse alpha
* component is used in the lighting computation.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if either face or
* <code>pname</code> is not an accepted value.
*
* <p><code>GL_INVALID_VALUE</code> is generated if a specular
* exponent outside the range [0, 128] is specified.
*
* @param face Specifies which face or faces are being updated. Must
* be <code>GL_FRONT_AND_BACK</code>.
* @param pname Specifies the material parameter of the face or
* faces that is being updated. Must be one of
* <code>GL_AMBIENT</code>, <code>GL_DIFFUSE</code>,
* <code>GL_SPECULAR</code>, <code>GL_EMISSION</code>,
* <code>GL_SHININESS</code>, or
* <code>GL_AMBIENT_AND_DIFFUSE</code>.
* @param params Specifies a pointer to the value or values that
* <code>pname</code> will be set to.
* @param offset the starting offset within the
* <code>params</code> array.
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>params.length -
* offset</code> is smaller than the number of values required by
* the parameter.
*/
void glMaterialfv(int face, int pname, float[] params, int offset);
/**
* Floating-point <code>Buffer</code> version of <code>glMaterial</code>.
*
* @see #glMaterialfv(int face, int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>params.remaining()</code> is smaller than the number of
* values required by the parameter.
*/
void glMaterialfv(int face, int pname, FloatBuffer params);
/**
* Fixed-point version of <code>glMaterial</code>.
*
* @see #glMaterialf(int face, int pname, float param)
*/
void glMaterialx(int face, int pname, int param);
/**
* Fixed-point array version of <code>glMaterial</code>.
*
* @see #glMaterialfv(int face, int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>params.length -
* offset</code> is smaller than the number of values required by
* the parameter.
*/
void glMaterialxv(int face, int pname, int[] params, int offset);
/**
* Fixed-point <code>Buffer</code> version of <code>glMaterial</code>.
*
* @see #glMaterialfv(int face, int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>params.remaining()</code> is smaller than the number of
* values required by the parameter.
*/
void glMaterialxv(int face, int pname, IntBuffer params);
/**
* Specify which matrix is the current matrix.
*
* <p><code>glMatrixMode</code> sets the current matrix mode. mode
* can assume one of three values:
*
* <ul>
*
* <li><code>GL_MODELVIEW</code></li>
*
* <p>Applies subsequent matrix operations to the modelview matrix
* stack.
*
* <li><code>GL_PROJECTION</code></li>
*
* <p>Applies subsequent matrix operations to the projection matrix
* stack.
*
* <li><code>GL_TEXTURE</code></li>
*
* <p>Applies subsequent matrix operations to the texture matrix stack.
*
* <li><code>GL_MATRIX_PALETTE_OES</code>
* (<code>OES_matrix_palette</code> extension)</li>
*
* <p>Enables the matrix palette stack extension, and applies
* subsequent matrix operations to the matrix palette stack.
*
* </ul>
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if mode is not an
* accepted value.
*
* @param mode Specifies which matrix stack is the target for
* subsequent matrix operations. These values are accepted:
* <code>GL_MODELVIEW</code>, <code>GL_PROJECTION</code>, and
* <code>GL_TEXTURE</code>. In the <code>OES_matrix_palette</code>
* extension is available, <code>GL_MATRIX_PALETTE_OES</code> is
* additionally accepted. The initial value is
* <code>GL_MODELVIEW</code>.
*/
void glMatrixMode(int mode);
/**
* Multiply the current matrix with the specified matrix.
*
* <p><code>glMultMatrix</code> multiplies the current matrix with
* the one specified using m, and replaces the current matrix with
* the product.
*
* <p>The current matrix is determined by the current matrix mode (see
* glMatrixMode). It is either the projection matrix, modelview
* matrix, or the texture matrix.
*
* <h4>Examples</h4>
*
* <p>If the current matrix is <code>C</code>, and the coordinates
* to be transformed are, <code>v</code> = (<code>v[0]</code>,
* <code>v[1]</code>, <code>v[2]</code>, <code>v[3]</code>), then
* the current transformation is <code>C x v</code>, or
*
* <pre>
* ( c[0] c[4] c[8] c[12] ) ( v[0] )
* ( c[1] c[5] c[9] c[13] ) x ( v[1] )
* ( c[2] c[6] c[10] c[14] ) ( v[2] )
* ( c[3] c[7] c[11] c[15] ) ( v[3] )
* </pre>
*
* <p>Calling <code>glMultMatrix</code> with an argument of
* <code>m</code> = <code>m[0]</code>, <code>m[1]</code>, ...,
* <code>m[15]</code> replaces the current transformation with
* <code>(C x M) x v</code>, or
*
* <pre>
* ( c[0] c[4] c[8] c[12] ) ( m[0] m[4] m[8] m[12] ) ( v[0] )
* ( c[1] c[5] c[9] c[13] ) x ( m[1] m[5] m[9] m[13] ) x ( v[1] )
* ( c[2] c[6] c[10] c[14] ) ( m[2] m[6] m[10] m[14] ) ( v[2] )
* ( c[3] c[7] c[11] c[15] ) ( m[3] m[7] m[11] m[15] ) ( v[3] )
* </pre>
*
* <p>where "x" denotes matrix multiplication, and <code>v</code> is
* represented as a 4 × 1 matrix.
*
* <h4>Notes</h4>
*
* <p>While the elements of the matrix may be specified with single or
* double precision, the GL may store or operate on these values in
* less than single precision.
*
* <p>The array elements are passed in as a one-dimensional
* array in column-major order. The order of the multiplication
* is important. For example, if the current transformation is a
* rotation, and <code>glMultMatrix</code> is called with a
* translation matrix, the translation is done directly on the
* coordinates to be transformed, while the rotation is done on the
* results of that translation.
*
* @param m Specifies an array of at least 16 consecutive values,
* the first 16 of which are used as the elements of a 4 × 4
* column-major matrix.
* @param offset the starting offset within the
* <code>m</code> array.
*
* @exception IllegalArgumentException if <code>m</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>m.length -
* offset</code> is less than 16.
*/
void glMultMatrixf(float[] m, int offset);
/**
* Floating-point <code>Buffer</code> version of <code>glMultMatrix</code>.
*
* @see #glMultMatrixf(float[] m, int offset)
*
* @exception IllegalArgumentException if <code>m</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>m.remaining()</code>
* is less than 16.
*/
void glMultMatrixf(FloatBuffer m);
/**
* Fixed-point array version of <code>glMultMatrix</code>.
*
* @see #glMultMatrixf(float[] m, int offset)
*
* @exception IllegalArgumentException if <code>m</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>m.length -
* offset</code> is less than 16.
*/
void glMultMatrixx(int[] m, int offset);
/** Fixed-point <code>Buffer</code> version of <code>glMultMatrix</code>.
*
* @see #glMultMatrixf(float[] m, int offset)
*
* @exception IllegalArgumentException if <code>m</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>m.remaining()</code>
* is less than 16.
*/
void glMultMatrixx(IntBuffer m);
/**
* Set the current texture coordinates.
*
* <p><code>glMultiTexCoord</code> specifies the four texture
* coordinates as <code>(s, t, r, q)</code>.
*
* <p>The current texture coordinates are part of the data that is
* associated with each vertex.
*
* <h4>Notes</h4>
*
* <p>It is always the case that <code>GL_TEXTURE</code><i>i</i> =
* <code>GL_TEXTURE0</code> + <i>i</i>.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_MAX_TEXTURE_UNITS</code>.
*
* @param target Specifies texture unit whose coordinates should be
* modified. The number of texture units is implementation
* dependent, but must be at least one. Must be one of
* <code>GL_TEXTURE</code><i>i</i>, where <code>0 <= <i>i</i> <
* GL_MAX_TEXTURE_UNITS</code>, which is an implementation-dependent
* value.
* @param s Specifies an s texture coordinate for target texture
* unit. The initial value is 0.
* @param t Specifies a t texture coordinate for
* target texture unit. The initial value is 0.
* @param r Specifies an r texture coordinate for
* target texture unit. The initial value is 0.
* @param q Specifies a q texture coordinate for
* target texture unit. The initial value is 1.
*/
void glMultiTexCoord4f(int target, float s, float t, float r, float q);
/**
* Fixed-point version of <code>glMultiTexCoord</code>.
*
* @see #glMultiTexCoord4f
*/
void glMultiTexCoord4x(int target, int s, int t, int r, int q);
/**
* Set the current normal vector.
*
* <p>The current normal is set to the given coordinates whenever
* <code>glNormal</code> is issued. Byte, short, or integer arguments are
* converted to floating-point with a linear mapping that maps the
* most positive representable integer value to 1.0, and the most
* negative representable integer value to -1.0.
*
* <p>Normals specified with <code>glNormal</code> need not have
* unit length. If <code>GL_NORMALIZE</code> is enabled, then
* normals of any length specified with <code>glNormal</code> are
* normalized after transformation. If
* <code>GL_RESCALE_NORMAL</code> is enabled, normals are scaled by
* a scaling factor derived from the modelview
* matrix. <code>GL_RESCALE_NORMAL</code> requires that the
* originally specified normals were of unit length, and that the
* modelview matrix contain only uniform scales for proper
* results. To enable and disable normalization, call
* <code>glEnable</code> and <code>glDisable</code> with either
* <code>GL_NORMALIZE</code> or
* <code>GL_RESCALE_NORMAL</code>. Normalization is initially
* disabled.
*
* @param nx Specifies the x coordinate of the new
* current normal. The initial value is 0.
* @param ny Specifies the y coordinate of the new
* current normal. The initial value is 0.
* @param nz Specifies the z coordinate of the new
* current normal. The initial value is 1.
*/
void glNormal3f(float nx, float ny, float nz);
/**
* Fixed-point version of <code>glNormal</code>.
*
* @see #glNormal3f
*/
void glNormal3x(int nx, int ny, int nz);
/**
* Define an array of normals.
*
* <p><code>glNormalPointer</code> specifies the location and data
* of an array of normals to use when rendering. type specifies the
* data type of the normal coordinates and stride gives the byte
* stride from one normal to the next, allowing vertices and
* attributes to be packed into a single array or stored in separate
* arrays. (Single-array storage may be more efficient on some
* implementations.) When a normal array is specified, type , stride
* , and pointer are saved as client-side state.
*
* <p>If the normal array is enabled, it is used when
* <code>glDrawArrays</code> or <code>glDrawElements</code> is
* called. To enable and disable the normal array, call
* <code>glEnableClientState</code> and
* <code>glDisableClientState</code> with the argument
* <code>GL_NORMAL_ARRAY</code>. The normal array is initially
* disabled and isn't accessed when <code>glDrawArrays</code> or
* <code>glDrawElements</code> is called.
*
* <p>Use <code>glDrawArrays</code> to construct a sequence of
* primitives (all of the same type) from prespecified vertex and
* vertex attribute arrays. Use <code>glDrawElements</code> to
* construct a sequence of primitives by indexing vertices and
* vertex attributes.
*
* <h4>Notes</h4>
*
* <p><code>glNormalPointer</code> is typically implemented on the
* client side.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if type is not an
* accepted value.
*
* <p><code>GL_INVALID_VALUE</code> is generated if stride is
* negative.
*
* <p> The <code>pointer</code> argument must be a direct buffer
* with a type matching that specified by the <code>type</code>
* argument.
*
* @param type Specifies the data type of each coordinate in the
* array. Symbolic constants <code>GL_BYTE</code>,
* <code>GL_SHORT</code>, <code>GL_FIXED</code>, and
* <code>GL_FLOAT</code> are accepted. The initial value is
* <code>GL_FLOAT</code>.
* @param stride Specifies the byte offset between consecutive
* normals. If stride is 0, the normals are understood to be tightly
* packed in the array. The initial value is 0.
* @param pointer Specifies a pointer to the first coordinate of the
* first normal in the array. The initial value is 0.
*
* @exception IllegalStateException if OpenGL ES 1.1 is being used and
* VBOs are enabled.
* @exception IllegalArgumentException if <code>pointer</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>pointer</code> is not direct.
*/
void glNormalPointer(int type, int stride, Buffer pointer);
/**
* Multiply the current matrix with an orthographic matrix.
*
* <p><code>glOrtho</code> describes a transformation that produces
* a parallel projection. The current matrix (see glMatrixMode) is
* multiplied by this matrix and the result replaces the current
* matrix, as if <code>glMultMatrix</code> were called with the
* following matrix as its argument:
*
* <pre>
* ( 2/(right - left) 0 0 tx )
* ( 0 2/(top - bottom) 0 ty )
* ( 0 0 (-2)/(far - near) tz )
* ( 0 0 0 1 )
* </pre>
*
* <p>where
*
* <pre>
* tx = - (right + left)/(right - left)
* ty = - (top + bottom)/(top - bottom)
* tz = - (far + near) /(far - near)
* </pre>
*
* <p>Typically, the matrix mode is <code>GL_PROJECTION</code>, and
* (left, bottom, -near) and (right, top, -near) specify the points
* on the near clipping plane that are mapped to the lower left and
* upper right corners of the window, respectively, assuming that
* the eye is located at (0, 0, 0). -far specifies the location of
* the far clipping plane. Both near and far can be either positive
* or negative.
*
* <p>Use <code>glPushMatrix</code> and <code>glPopMatrix</code> to
* save and restore the current matrix stack.
*
* @param left Specifies the coordinate for the left
* vertical clipping plane.
* @param right Specifies the coordinate for the right
* vertical clipping plane.
* @param bottom Specifies the coordinate for the bottom
* horizontal clipping plane.
* @param top Specifies the coordinate for the top
* horizontal clipping plane.
* @param near Specifies the distance to the nearer
* depth clipping plane. This value is negative if the plane is
* to be behind the viewer.
* @param far Specifies the distance to the farther
* depth clipping plane. This value is negative if the plane is
* to be behind the viewer.
*/
void glOrthof(float left, float right,
float bottom, float top,
float near, float far);
/**
* Fixed-point version of <code>glOrtho</code>.
*
* @see #glOrthof
*/
void glOrthox(int left, int right,
int bottom, int top,
int near, int far);
/**
* Set pixel storage modes.
*
* <p><code>glPixelStore</code> sets pixel storage modes that affect
* the operation of subsequent <code>glReadPixels</code> as well as
* the unpacking of <code>glTexImage2D</code>, and
* <code>glTexSubImage2D</code>.
*
* <p><code>pname</code> is a symbolic constant indicating the
* parameter to be set, and <code>param</code> is the new value. The
* following storage parameter affects how pixel data is returned to
* client memory. This value is significant for
* <code>glReadPixels</code>:
*
* <ul>
*
* <li><code>GL_PACK_ALIGNMENT</code></li>
*
* <p>Specifies the alignment requirements for the start of each pixel
* row in memory. The allowable values are 1 (byte-alignment), 2
* (rows aligned to even-numbered bytes), 4 (word-alignment), and 8
* (rows start on double-word boundaries). The initial value is 4.
*
* <p>The following storage parameter affects how pixel data is read
* from client memory. This value is significant for
* <code>glTexImage2D</code> and <code>glTexSubImage2D</code>:
*
* <li><code>GL_UNPACK_ALIGNMENT</code></li>
*
* <p>Specifies the alignment requirements for the start of each pixel
* row in memory. The allowable values are 1 (byte-alignment), 2
* (rows aligned to even-numbered bytes), 4 (word-alignment), and 8
* (rows start on double-word boundaries). The initial value is 4.
*
* </ul>
*
* <h4>Notes</h4>
*
* <p>Pixel storage modes are client states.
*
* <p><code>glCompressedTexImage2D</code> and
* <code>glCompressedTexSubImage2D</code> are not affected by
* <code>glPixelStore</code>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if
* <code>pname</code> is not an accepted value.
*
* <p><code>GL_INVALID_VALUE</code> is generated if alignment is
* specified as other than 1, 2, 4, or 8.
*
* @param pname Specifies the symbolic name of the parameter to be
* set. <code>GL_PACK_ALIGNMENT</code> affects the packing of pixel
* data into memory. <code>GL_UNPACK_ALIGNMENT</code> affects the
* unpacking of pixel data from memory.
* @param param Specifies the value that <code>pname</code> is set
* to.
*/
void glPixelStorei(int pname, int param);
/**
* Specify the diameter of rasterized points.
*
* <p><code>glPointSize</code> specifies the rasterized diameter of
* both aliased and antialiased points. Using a point size other
* than 1 has different effects, depending on whether point
* antialiasing is enabled. To enable and disable point
* antialiasing, call <code>glEnable</code> and
* <code>glDisable</code> with argument
* <code>GL_POINT_SMOOTH</code>. Point antialiasing is initially
* disabled.
*
* <p>If point antialiasing is disabled, the actual size is determined
* by rounding the supplied size to the nearest integer. (If the
* rounding results in the value 0, it is as if the point size were
* 1.) If the rounded size is odd, then the center point (x, y) of
* the pixel fragment that represents the point is computed as
*
* <pre>
* (floor(xw) + 1/2, floor(yw) + 1/2)
* </pre>
*
* <p>where w subscripts indicate window coordinates. All pixels that
* lie within the square grid of the rounded size centered at (x, y)
* make up the fragment. If the size is even, the center point is
*
* <pre>
* (floor(xw + 1/2), floor(yw + 1/2))
* </pre>
*
* <p>and the rasterized fragment's centers are the half-integer window
* coordinates within the square of the rounded size centered at (x,
* y). All pixel fragments produced in rasterizing a nonantialiased
* point are assigned the same associated data, that of the vertex
* corresponding to the point.
*
* <p>If antialiasing is enabled, then point rasterization produces a
* fragment for each pixel square that intersects the region lying
* within the circle having diameter equal to the current point size
* and centered at the point's (xw, yw) . The coverage value for
* each fragment is the window coordinate area of the intersection
* of the circular region with the corresponding pixel square. This
* value is saved and used in the final rasterization step. The data
* associated with each fragment is the data associated with the
* point being rasterized.
*
* <p>Not all sizes are supported when point antialiasing is
* enabled. If an unsupported size is requested, the nearest
* supported size is used. Only size 1 is guaranteed to be
* supported; others depend on the implementation. To query the
* range of supported sizes, call <code>glGetIntegerv</code> with the argument
* <code>GL_SMOOTH_POINT_SIZE_RANGE</code>. For aliased points, query the
* supported ranges <code>glGetIntegerv</code> with the argument
* <code>GL_ALIASED_POINT_SIZE_RANGE</code>.
*
* <h4>Notes</h4>
*
* <p>A non-antialiased point size may be clamped to an
* implementation-dependent maximum. Although this maximum cannot be
* queried, it must be no less than the maximum value for
* antialiased points, rounded to the nearest integer value.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_VALUE</code> is generated if size is less
* than or equal to 0.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_ALIASED_POINT_SIZE_RANGE</code>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_SMOOTH_POINT_SIZE_RANGE</code>
*
* @param size Specifies the diameter of rasterized points. The
* initial value is 1.
*/
void glPointSize(float size);
/**
* Fixed-point version of <code>glPointSize</code>.
*
* @see #glPointSize
*/
void glPointSizex(int size);
/**
* Set the scale and units used to calculate depth values.
*
* <p>When <code>GL_POLYGON_OFFSET_FILL</code> is enabled, each
* fragment's depth value will be offset after it is interpolated
* from the depth values of the appropriate vertices. The value of
* the offset is m * factor + r * units, where m is a measurement of
* the change in depth relative to the screen area of the polygon,
* and r is the smallest value that is guaranteed to produce a
* resolvable offset for a given implementation. The offset is added
* before the depth test is performed and before the value is
* written into the depth buffer.
*
* <p><code>glPolygonOffset</code> is useful for for applying decals
* to surfaces.
*
* @param factor Specifies a scale factor that is used to create a
* variable depth offset for each polygon. The initial value is 0.
* @param units Is multiplied by an implementation-specific value to
* create a constant depth offset. The initial value is 0.
*/
void glPolygonOffset(float factor, float units);
/**
* Fixed-point version of <code>glPolygonOffset</code>.
*
* @see #glPolygonOffset
*/
void glPolygonOffsetx(int factor, int units);
/**
* Pop the current matrix stack.
*
* @see #glPushMatrix
*/
void glPopMatrix();
/**
* Push the current matrix stack.
*
* <p>There is a stack of matrices for each of the matrix modes. In
* <code>GL_MODELVIEW</code> mode, the stack depth is at least
* 16. In the other modes, <code>GL_PROJECTION</code>, and
* <code>GL_TEXTURE</code>, the depth is at least 2. The current
* matrix in any mode is the matrix on the top of the stack for that
* mode.
*
* <p><code>glPushMatrix</code> pushes the current matrix stack down
* by one, duplicating the current matrix. That is, after a
* glPushMatrix call, the matrix on top of the stack is identical to
* the one below it.
*
* <p><code>glPopMatrix</code> pops the current matrix stack,
* replacing the current matrix with the one below it on the stack.
*
* <p>Initially, each of the stacks contains one matrix, an identity matrix.
*
* <p>It is an error to push a full matrix stack, or to pop a matrix
* stack that contains only a single matrix. In either case, the
* error flag is set and no other change is made to GL state.
*
* <h4>Notes</h4>
*
* <p>Each texture unit has its own texture matrix stack. Use
* <code>glActiveTexture</code> to select the desired texture matrix stack.
*
* <h4>Errors</h4>
*
* <p><code>GL_STACK_OVERFLOW</code> is generated if
* <code>glPushMatrix</code> is called while the current matrix
* stack is full.
*
* <p><code>GL_STACK_UNDERFLOW</code> is generated if
* <code>glPopMatrix</code> is called while the current matrix stack
* contains only a single matrix.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_MAX_MODELVIEW_STACK_DEPTH</code>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_MAX_PROJECTION_STACK_DEPTH</code>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_MAX_TEXTURE_STACK_DEPTH</code>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_MAX_TEXTURE_UNITS</code>
*/
void glPushMatrix();
/**
* Read a block of pixels from the color buffer.
*
* <p><code>glReadPixels</code> returns pixel data from the color
* buffer, starting with the pixel whose lower left corner is at
* location (x, y), into client memory starting at location
* pixels. The processing of the pixel data before it is placed into
* client memory can be controlled with <code>glPixelStore</code>.
*
* <p><code>glReadPixels</code> returns values from each pixel with
* lower left corner at <code>(x + i, y + j)</code> for <code>0 <=
* <i>i</i> < width</code> and <code>0 <= j < height</code>. This
* pixel is said to be the ith pixel in the jth row. Pixels are
* returned in row order from the lowest to the highest row, left to
* right in each row.
*
* <p><code>format</code> specifies the format of the returned pixel
* values. <code>GL_RGBA</code> is always accepted, the value of
* <code>GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES</code> may allow
* another format:
*
* <ul>
*
* <li><code>GL_RGBA</code></li>
*
* <p>Each color component is converted to floating point such that
* zero intensity maps to 0 and full intensity maps to 1.
*
* <li><code>GL_RGB</code></li>
*
* <p>Each element is an RGB triple. The GL converts it to floating
* point and assembles it into an RGBA element by attaching 1 for
* alpha.
*
* <li><code>GL_LUMINANCE</code></li>
*
* <p>Each element is a single luminance value. The GL converts it to
* floating point and assembles it into an RGBA element by
* replicating the luminance value three times for red, green and
* blue and attaching 1 for alpha.
*
* <li><code>GL_LUMINANCE_ALPHA</code></li>
*
* <p>Each element is a luminance/alpha pair. The GL converts it to
* floating point and assembles it into an RGBA element by
* replicating the luminance value three times for red, green and
* blue.
*
* <li><code>GL_ALPHA</code></li>
*
* <p>Each element is a single alpha component. The GL converts it to
* floating point and assembles it into an RGBA element by attaching
* 0 for red, green and blue.
*
* </ul>
*
* <p>Unneeded data is then discarded. For example,
* <code>GL_ALPHA</code> discards the red, green, and blue
* components, while <code>GL_RGB</code> discards only the alpha
* component. <code>GL_LUMINANCE</code> computes a single-component
* value as the sum of the red, green, and blue components, and
* <code>GL_LUMINANCE_ALPHA</code> does the same, while keeping
* alpha as a second value. The final values are clamped to the
* range <code>[0, 1]</code>.
*
* <p>Finally, the components are converted to the proper, as specified
* by type where each component is multiplied by 2^n - 1, where n is
* the number of bits per component.
*
* <p>Return values are placed in memory as follows. If format is
* <code>GL_ALPHA</code>, or <code>GL_LUMINANCE</code>, a single
* value is returned and the data for the ith pixel in the jth row
* is placed in location j * width + i. <code>GL_RGB</code> returns
* three values, <code>GL_RGBA</code> returns four values, and
* <code>GL_LUMINANCE_ALPHA</code> returns two values for each
* pixel, with all values corresponding to a single pixel occupying
* contiguous space in pixels. Storage parameter
* <code>GL_PACK_ALIGNMENT</code> set by <code>glPixelStore</code>,
* affects the way that data is written into memory. See
* <code>glPixelStore</code> for a description.
*
* <h4>Notes</h4>
*
* <p>Values for pixels that lie outside the window connected to the
* current GL context are undefined.
*
* <p>If an error is generated, no change is made to the contents of pixels.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if format is not
* <code>GL_RGBA</code> or the value of
* <code>GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES</code>.
*
* <p><code>GL_INVALID_ENUM</code> is generated if type is not
* <code>GL_UNSIGNED_BYTE</code> or the value of
* <code>GL_IMPLEMENTATION_COLOR_READ_TYPE_OES</code>.
*
* <p><code>GL_INVALID_VALUE</code> is generated if either width or
* height is negative.
*
* <p><code>GL_INVALID_OPERATION</code> is generated if format and
* type are neither (<code>GL_RGBA</code>,
* <code>GL_UNSIGNED_BYTE)</code> nor the values of
* (<code>GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES</code>,
* <code>GL_IMPLEMENTATION_COLOR_READ_TYPE_OES)</code>.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES</code>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_IMPLEMENTATION_COLOR_READ_TYPE_OES</code>
*
* @param x Specifies the window x coordinate of the first pixel
* that is read from the color buffer. This location is the lower
* left corner of a rectangular block of pixels.
* @param y Specifies the window y coordinate of the first pixel
* that is read from the color buffer. This location is the lower
* left corner of a rectangular block of pixels.
* @param width Specifies the width of the pixel
* rectangle. width and height of one correspond to a single pixel.
* @param height Specifies the height of the pixel
* rectangle. width and height of one correspond to a single pixel.
* @param format Specifies the format of the pixel data. Must be
* either <code>GL_RGBA</code> or the value of
* <code>GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES</code>.
* @param type Specifies the data type of the pixel data. Must be
* either <code>GL_UNSIGNED_BYTE</code> or the value of
* <code>GL_IMPLEMENTATION_COLOR_READ_TYPE_OES</code>.
* @param pixels Returns the pixel data.
*
* @exception IllegalArgumentException if <code>pixels</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>pixels</code> does
* not contain enough room for the pixel data.
*/
void glReadPixels(int x, int y,
int width, int height,
int format, int type,
Buffer pixels);
/**
* Multiply the current matrix by a rotation matrix.
*
* <p><code>glRotate</code> produces a rotation of angle degrees
* around the vector (x, y, z) . The current matrix (see
* glMatrixMode) is multiplied by a rotation matrix with the product
* replacing the current matrix, as if <code>glMultMatrix</code>
* were called with the following matrix as its argument:
*
* <pre>
* ( x^2(1 - c) + c xy (1 - c) - zs xz (1 - c) + ys 0 )
* ( xy (1 - c) + zs y^2(1 - c) + c yz (1 - c) - xs 0 )
* ( xz (1 - c) - ys yz (1 - c) + xs z^2(1 - c) + c 0 )
* ( 0 0 0 1 )
* </pre>
*
* <p>Where c = cos (angle), s = sin (angle), and ||(x, y, z)|| = 1,
* (if not, the GL will normalize this vector).
*
* <p>If the matrix mode is either <code>GL_MODELVIEW</code> or
* <code>GL_PROJECTION</code>, all objects drawn after
* <code>glRotate</code> is called are rotated. Use
* <code>glPushMatrix</code> and <code>glPopMatrix</code> to save
* and restore the unrotated coordinate system.
*
* <h4>Notes</h4>
*
* <p>This rotation follows the right-hand rule, so if the vector (x,
* y, z) points toward the user, the rotation will be
* counterclockwise.
*
* @param angle Specifies the angle of rotation, in degrees.
* @param x Specifies the x coordinate of a vector.
* @param y Specifies the y coordinate of a vector.
* @param z Specifies the z coordinate of a vector.
*/
void glRotatef(float angle, float x, float y, float z);
/**
* Fixed-point version of <code>glRotate</code>.
*
* @see #glRotatef
*/
void glRotatex(int angle, int x, int y, int z);
/**
* Specify mask to modify multisampled pixel fragments.
*
* <p><code>glSampleCoverage</code> defines a mask to modify the coverage of
* multisampled pixel fragments. This capability is used for
* antialiased screen-door transparency and smooth transitions
* between two renderings of an object (often for level-of-detail
* management in simulation systems).
*
* <p>When multisampling is enabled (see <code>glEnable</code> with
* argument <code>GL_MULTISAMPLE)</code> a ``fragment mask'' is
* computed for each fragment generated by a primitive. This mask
* reflects the amount of the pixel covered by the fragment, and
* determines the frame buffer samples that may be affected by the
* fragment.
*
* <p>If conversion of alpha values to masks is enabled
* (<code>glEnable</code> with argument
* <code>GL_SAMPLE_ALPHA_TO_MASK)</code>, the fragment alpha value
* is used to generate a temporary modification mask which is then
* ANDed with the fragment mask. One way to interpret this is as a
* form of dithering: a multivalued alpha (coverage or opacity) for
* the whole fragment is converted to simple binary values of
* coverage at many locations (the samples).
*
* <p>After conversion of alpha values to masks, if replacement of
* alpha values is enabled (<code>glEnable</code> with argument
* <code>GL_SAMPLE_ALPHA_TO_ONE)</code>, the fragment's alpha is set
* to the maximum allowable value.
*
* <p>Finally, if fragment mask modification is enabled
* (<code>glEnable</code> with argument
* <code>GL_SAMPLE_MASK)</code>, <code>glSampleCoverage</code>
* defines an additional modification mask. value is used to
* generate a modification mask in much the same way alpha was used
* above. If invert is <code>GL_TRUE</code>, then the modification
* mask specified by value will be inverted. The final modification
* mask will then be ANDed with the fragment mask resulting from the
* previous steps. This can be viewed as an ``override'' control
* that selectively fades the effects of multisampled fragments.
*
* <p>Note that <code>glSampleCoverage(value, GL_TRUE)</code> is not
* necessarily equivalent to <code>glSampleCoverage(1.0 - value,
* GL_FALSE)</code>; due to round-off and other issues, complementing
* the coverage will not necessarily yield an inverted modification
* mask.
*
* @param value Specifies the coverage of the modification mask. The
* value is clamped to the range <code>[0, 1]</code>, where 0
* represents no coverage and 1 full coverage. The initial value is
* 1.
* @param invert Specifies whether the modification mask implied by
* value is inverted or not. The initial value is <code>GL_FALSE</code>.
*/
void glSampleCoverage(float value, boolean invert);
/**
* Fixed-point version of <code>glSampleCoverage</code>.
*
* @see #glSampleCoverage
*/
void glSampleCoveragex(int value, boolean invert);
/**
* Multiply the current matrix by a general scaling matrix.
*
* <p><code>glScale</code> produces a nonuniform scaling along the
* x, y, and z axes. The three parameters indicate the desired scale
* factor along each of the three axes.
*
* <p>The current matrix (see glMatrixMode) is multiplied by this scale
* matrix, and the product replaces the current matrix as if glScale
* were called with the following matrix as its argument:
*
* <pre>
* ( x 0 0 0 )
* ( 0 y 0 0 )
* ( 0 0 z 0 )
* ( 0 0 0 1 )
* </pre>
*
* <p>If the matrix mode is either <code>GL_MODELVIEW</code> or
* <code>GL_PROJECTION</code>, all objects drawn after
* <code>glScale</code> is called are scaled.
*
* <p>Use <code>glPushMatrix</code> and <code>glPopMatrix</code> to
* save and restore the unscaled coordinate system.
*
* <h4>Notes</h4>
*
* <p>If scale factors other than 1 are applied to the modelview matrix
* and lighting is enabled, lighting often appears wrong. In that
* case, enable automatic normalization of normals by calling
* <code>glEnable</code> with the argument <code>GL_NORMALIZE</code>.
*
* @param x Specifies the scale factor along the x axis.
* @param y Specifies the scale factor along the y axis.
* @param z Specifies the scale factor along the z axis.
*/
void glScalef(float x, float y, float z);
/**
* Fixed-point version of <code>glScale</code>.
*
* @see #glScalef
*/
void glScalex(int x, int y, int z);
/**
* Define the scissor box.
*
* <p><code>glScissor</code> defines a rectangle, called the scissor
* box, in window coordinates. The first two arguments, x and y,
* specify the lower left corner of the box. width and height
* specify the width and height of the box.
*
* <p>To enable and disable the scissor test, call
* <code>glEnable</code> and <code>glDisable</code> with argument
* <code>GL_SCISSOR_TEST</code>. The scissor test is initially
* disabled. While scissor test is enabled, only pixels that lie
* within the scissor box can be modified by drawing
* commands. Window coordinates have integer values at the shared
* corners of frame buffer pixels. glScissor(0, 0, 1, 1) allows
* modification of only the lower left pixel in the window, and
* glScissor(0, 0, 0, 0) doesn't allow modification of any pixels in
* the window.
*
* <p>When the scissor test is disabled, it is as though the scissor
* box includes the entire window.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_VALUE</code> is generated if either width or
* height is negative.
*
* @param x Specifies the x coordinate of the lower left corner
* of the scissor box, in pixels. The initial value is 0.
* @param y Specifies the y coordinate of the lower left corner
* of the scissor box, in pixels. The initial value is 0.
* @param width Specifies the width of the scissor box. When a GL
* context is first attached to a surface (e.g. window), width and
* height are set to the dimensions of that surface.
* @param height Specifies the height of the scissor box. When a GL
* context is first attached to a surface (e.g. window), width and
* height are set to the dimensions of that surface.
*/
void glScissor(int x, int y, int width, int height);
/**
* Select flat or smooth shading.
*
* <p>GL primitives can have either flat or smooth shading. Smooth
* shading, the default, causes the computed colors of vertices to
* be interpolated as the primitive is rasterized, typically
* assigning different colors to each resulting pixel fragment. Flat
* shading selects the computed color of just one vertex and assigns
* it to all the pixel fragments generated by rasterizing a single
* primitive. In either case, the computed color of a vertex is the
* result of lighting if lighting is enabled, or it is the current
* color at the time the vertex was specified if lighting is
* disabled.
*
* <p>Flat and smooth shading are indistinguishable for
* points. Starting at the beginning of the vertex array and
* counting vertices and primitives from 1, the GL gives each
* flat-shaded line segment <i>i</i> the computed color of
* vertex <i>i</i> + 1, its second vertex. Counting similarly from 1,
* the GL gives each flat-shaded polygon the computed color of
* vertex <i>i</i> + 2, which is the last vertex to specify the
* polygon.
*
* <p>Flat and smooth shading are specified by
* <code>glShadeModel</code> with mode set to <code>GL_FLAT</code>
* and <code>GL_SMOOTH</code>, respectively.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if mode is any value
* other than <code>GL_FLAT</code> or <code>GL_SMOOTH</code>.
*
* @param mode Specifies a symbolic value representing a shading
* technique. Accepted values are <code>GL_FLAT</code> and
* <code>GL_SMOOTH</code>. The initial value is
* <code>GL_SMOOTH</code>.
*/
void glShadeModel(int mode);
/**
* Set function and reference value for stencil testing.
*
* <p>Stenciling, like depth-buffering, enables and disables drawing on
* a per-pixel basis. You draw into the stencil planes using GL
* drawing primitives, then render geometry and images, using the
* stencil planes to mask out portions of the screen. Stenciling is
* typically used in multipass rendering algorithms to achieve
* special effects, such as decals, outlining, and constructive
* solid geometry rendering.
*
* <p>The stencil test conditionally eliminates a pixel based on the
* outcome of a comparison between the reference value and the value
* in the stencil buffer. To enable and disable stencil test, call
* <code>glEnable</code> and <code>glDisable</code> with argument
* <code>GL_STENCIL_TEST</code>. Stencil test is initially
* disabled. To specify actions based on the outcome of the stencil
* test, call <code>glStencilOp</code>.
*
* <p><code>func</code> is a symbolic constant that determines the
* stencil comparison function. It accepts one of eight values,
* shown in the following list. <code>ref</code> is an integer
* reference value that is used in the stencil comparison. It is
* clamped to the range <code>[0, 2^n - 1]</code>, where <i>n</i> is
* the number of bitplanes in the stencil buffer. <code>mask</code>
* is bitwise ANDed with both the reference value and the stored
* stencil value, with the ANDed values participating in the
* comparison.
*
* <p>If <code>stencil</code> represents the value stored in the
* corresponding stencil buffer location, the following list shows
* the effect of each comparison function that can be specified by
* func. Only if the comparison succeeds is the pixel passed through
* to the next stage in the rasterization process (see
* glStencilOp). All tests treat stencil values as unsigned integers
* in the range <code>[0, 2^n - 1]</code>, where <i>n</i> is the
* number of bitplanes in the stencil buffer.
*
* <p>The following values are accepted by <code>func</code>:
*
* <ul>
*
* <li><code>GL_NEVER</code></li>
*
* <p>Always fails.
*
* <li><code>GL_LESS</code></li>
*
* <p>Passes if (ref & mask) < (stencil & mask) .
*
* <li><code>GL_LEQUAL</code></li>
*
* <p>Passes if (ref & mask) <= (stencil & mask) .
*
* <li><code>GL_GREATER</code></li>
*
* <p>Passes if (ref & mask) > (stencil & mask) .
*
* <li><code>GL_GEQUAL</code></li>
*
* <p>Passes if (ref & mask) >= (stencil & mask) .
*
* <li><code>GL_EQUAL</code></li>
*
* <p>Passes if (ref & mask) == (stencil & mask) .
*
* <li><code>GL_NOTEQUAL</code></li>
*
* <p>Passes if (ref & mask) != (stencil & mask) .
*
* <li><code>GL_ALWAYS</code></li>
*
* <p>Always passes.
*
* </ul>
*
* <h4>Notes</h4>
*
* <p>Initially, the stencil test is disabled. If there is no stencil
* buffer, no stencil modification can occur and it is as if the
* stencil test always passes.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if func is not one
* of the eight accepted values.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument <code>GL_STENCIL_BITS</code>
*
* @param func Specifies the test function. Eight tokens are valid:
* <code>GL_NEVER</code>, <code>GL_LESS</code>,
* <code>GL_LEQUAL</code>, <code>GL_GREATER</code>,
* <code>GL_GEQUAL</code>, <code>GL_EQUAL</code>,
* <code>GL_NOTEQUAL</code>, and <code>GL_ALWAYS</code>. The initial
* value is <code>GL_ALWAYS</code>.
* @param ref Specifies the reference value for the stencil
* test. <code>ref</code> is clamped to the range <code>[0, 2^n -
* 1]</code>, where <i>n</i> is the number of bitplanes in the
* stencil buffer. The initial value is 0.
* @param mask Specifies a mask that is ANDed with both the
* reference value and the stored stencil value when the test is
* done. The initial value is all 1's.
*/
void glStencilFunc(int func, int ref, int mask);
/**
* Control the writing of individual bits in the stencil planes.
*
* <p><code>glStencilMask</code> controls the writing of individual
* bits in the stencil planes. The least significant n bits of mask,
* where n is the number of bits in the stencil buffer, specify a
* mask. Where a 1 appears in the mask, it's possible to write to
* the corresponding bit in the stencil buffer. Where a 0 appears,
* the corresponding bit is write-protected. Initially, all bits are
* enabled for writing.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument <code>GL_STENCIL_BITS</code>
*
* @param mask Specifies a bit mask to enable and disable writing of
* individual bits in the stencil planes. The initial value is all
* 1's.
*/
void glStencilMask(int mask);
/**
* Set stencil test actions.
*
* <p>Stenciling, like depth-buffering, enables and disables drawing on
* a per-pixel basis. You draw into the stencil planes using GL
* drawing primitives, then render geometry and images, using the
* stencil planes to mask out portions of the screen. Stenciling is
* typically used in multipass rendering algorithms to achieve
* special effects, such as decals, outlining, and constructive
* solid geometry rendering.
*
* <p>The stencil test conditionally eliminates a pixel based on the
* outcome of a comparison between the value in the stencil buffer
* and a reference value. To enable and disable stencil test, call
* <code>glEnable</code> and <code>glDisable</code> with argument
* <code>GL_STENCIL_TEST</code>. To control it, call
* <code>glStencilFunc</code>. Stenciling is initially disabled.
*
* <p><code>glStencilOp</code> takes three arguments that indicate
* what happens to the stored stencil value while stenciling is
* enabled. If the stencil test fails, no change is made to the
* pixel's color or depth buffers, and fail specifies what happens
* to the stencil buffer contents. The following six actions are
* possible.
*
* <ul>
*
* <li><code>GL_KEEP</code></li>
*
* <p>Keeps the current value.
*
* <li><code>GL_ZERO</code></li>
*
* <p>Sets the stencil buffer value to 0.
*
* <li><code>GL_REPLACE</code></li>
*
* <p>Sets the stencil buffer value to ref, as specified by
* <code>glStencilFunc</code>.
*
* <li><code>GL_INCR</code></li>
*
* <p>Increments the current stencil buffer value. Clamps to the
* maximum representable unsigned value.
*
* <li><code>GL_DECR</code></li>
*
* <p>Decrements the current stencil buffer value. Clamps to 0.
*
* <li><code>GL_INVERT</code></li>
*
* <p>Bitwise inverts the current stencil buffer value.
*
* <--
* <li>(<code>OES_stencil_wrap</code> extension)
* <code>GL_DECR_WRAP</code></li>
*
* <p>Decrements the current stencil buffer value, wrapping around
* to the maximum representable unsigned value if less than 0.
*
* <li>(<code>OES_stencil_wrap</code> extension)
* <code>GL_INCR</code></li>
*
* <p>Increments the current stencil buffer value, wrapping around
* to 0 if greater than the maximum representable unsigned value.
* -->
*
* </ul>
*
* <p>Stencil buffer values are treated as unsigned integers. When
* incremented and decremented, values are clamped to 0 and 2^n - 1,
* where n is the value returned by querying <code>GL_STENCIL_BITS</code>.
*
* <p>The other two arguments to <code>glStencilOp</code> specify
* stencil buffer actions that depend on whether subsequent depth
* buffer tests succeed (<code>zpass</code>) or fail
* (<code>zfail</code>) (see <code>glDepthFunc</code>). The actions
* are specified using the same six symbolic constants as
* <code>fail</code>. Note that <code>zfail</code> is ignored when
* there is no depth buffer, or when the depth buffer is not
* enabled. In these cases, <code>fail</code> and <code>zpass</code>
* specify stencil action when the stencil test fails and passes,
* respectively.
*
* <h4>Notes</h4>
*
* <p>If there is no stencil buffer, no stencil modification can occur
* and it is as if the stencil tests always pass, regardless of any
* call to <code>glStencilOp</code>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if fail, zfail, or
* zpass is any value other than the six defined constant values.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument <code>GL_STENCIL_BITS</code>
*
* @param fail Specifies the action to take when the stencil test
* fails. Six symbolic constants are accepted: <code>GL_KEEP</code>,
* <code>GL_ZERO</code>, <code>GL_REPLACE</code>,
* <code>GL_INCR</code>, <code>GL_DECR</code>, and
* <code>GL_INVERT</code> <!-- <code>GL_INCR_WRAP</code>
* (<code>OES_stencil_wrap</code> extension), and
* <code>GL_DECR_WRAP</code> (<code>OES_stencil_wrap</code>
* extension) -->. The initial value is <code>GL_KEEP</code>.
* @param zfail Specifies the stencil action when the stencil test
* passes, but the depth test fails. <code>zfail</code> accepts the
* same symbolic constants as <code>fail</code>. The initial value
* is <code>GL_KEEP</code>.
* @param zpass Specifies the stencil action when both the stencil
* test and the depth test pass, or when the stencil test passes and
* either there is no depth buffer or depth testing is not
* enabled. <code>zpass</code> accepts the same symbolic constants
* as <code>fail</code>. The initial value is <code>GL_KEEP</code>.
*/
void glStencilOp(int fail, int zfail, int zpass);
/**
* Define an array of texture coordinates.
*
* <p><code>glTexCoordPointer</code> specifies the location and data
* of an array of texture coordinates to use when rendering. size
* specifies the number of coordinates per element, and must be 2,
* 3, or 4. type specifies the data type of each texture coordinate
* and stride specifies the byte stride from one array element to
* the next allowing vertices and attributes to be packed into a
* single array or stored in separate arrays. (Single-array storage
* may be more efficient on some implementations.)
*
* <p>When a texture coordinate array is specified, size, type, stride,
* and pointer are saved as client-side state.
*
* <p>If the texture coordinate array is enabled, it is used when
* <code>glDrawArrays</code>, or <code>glDrawElements</code> is
* called. To enable and disable the texture coordinate array for
* the client-side active texture unit, call
* <code>glEnableClientState</code> and
* <code>glDisableClientState</code> with the argument
* <code>GL_TEXTURE_COORD_ARRAY</code>. The texture coordinate array
* is initially disabled for all client-side active texture units
* and isn't accessed when <code>glDrawArrays</code> or
* <code>glDrawElements</code> is called.
*
* <p>Use <code>glDrawArrays</code> to construct a sequence of
* primitives (all of the same type) from prespecified vertex and
* vertex attribute arrays. Use <code>glDrawElements</code> to
* construct a sequence of primitives by indexing vertices and
* vertex attributes.
*
* <h4>Notes</h4>
*
* <p><code>glTexCoordPointer</code> is typically implemented on the
* client side.
*
* <p><code>glTexCoordPointer</code> updates the texture coordinate
* array state of the client-side active texture unit, specified
* with <code>glClientActiveTexture</code>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_VALUE</code> is generated if size is not 2, 3, or 4.
*
* <p><code>GL_INVALID_ENUM</code> is generated if type is not an
* accepted value.
*
* <p><code>GL_INVALID_VALUE</code> is generated if stride is negative.
*
* <p> The <code>pointer</code> argument must be a direct buffer
* with a type matching that specified by the <code>type</code>
* argument.
*
* @param size Specifies the number of coordinates per array
* element. Must be 2, 3 or 4. The initial value is 4.
* @param type Specifies the data type of each texture
* coordinate. Symbolic constants <code>GL_BYTE</code>,
* <code>GL_SHORT</code>, <code>GL_FIXED</code>,and
* <code>GL_FLOAT</code> are accepted. The initial value is
* <code>GL_FLOAT</code>.
* @param stride Specifies the byte offset between consecutive array
* elements. If stride is 0, the array elements are understood to be
* tightly packed. The initial value is 0.
* @param pointer Specifies a pointer to the first coordinate of the
* first element in the array. The initial value is 0.
*
* @exception IllegalStateException if OpenGL ES 1.1 is being used and
* VBOs are enabled.
* @exception IllegalArgumentException if <code>pointer</code> is
* <code>null</code> or is not direct.
*/
void glTexCoordPointer(int size, int type, int stride, Buffer pointer);
/**
* Set texture environment parameters.
*
* <p>If <code>target</code> is <code>GL_TEXTURE_ENV</code>, then
* the following applies:
*
* <p>A texture environment specifies how texture values are
* interpreted when a fragment is textured. <code>target</code> must
* be <code>GL_TEXTURE_ENV</code>. <code>pname</code> can be either
* <code>GL_TEXTURE_ENV_MODE</code> or
* <code>GL_TEXTURE_ENV_COLOR</code>.
*
* <p>If <code>pname</code> is <code>GL_TEXTURE_ENV_MODE</code>,
* then <code>params</code> contains the symbolic name of a texture
* function. Four texture functions may be specified:
* <code>GL_MODULATE</code>, <code>GL_DECAL</code>,
* <code>GL_BLEND</code>, and <code>GL_REPLACE</code>.
*
* <p>A texture function acts on the fragment to be textured using
* the texture image value that applies to the fragment (see
* <code>glTexParameter</code>) and produces an RGBA color for that
* fragment. The following table shows how the RGBA color is
* produced for each of the three texture functions that can be
* chosen. <i>C</i> is a triple of color values (RGB) and <i>A</i>
* is the associated alpha value. RGBA values extracted from a
* texture image are in the range <code>[0, 1]</code>. The subscript
* <i>f</i> refers to the incoming fragment, the subscript <i>t</i>
* to the texture image, the subscript <i>c</i> to the texture
* environment color, and subscript <i>v</i> indicates a value
* produced by the texture function.
*
* <p>A texture image can have up to four components per texture
* element (see <code>glTexImage2D</code>, and
* <code>glCopyTexImage2D</code>). In a one-component image,
* <i>Lt</i> indicates that single component. A two-component image
* uses <i>Lt</i> and <i>At</i>. A three-component image has only a
* color value, <i>Ct</i>. A four-component image has both a color
* value <i>Ct</i> and an alpha value <i>At</i>.
*
* <p>For texture functions: <code>GL_REPLACE</code>,
* <code>GL_MODULATE</code>, <code>GL_DECAL</code>,
* <code>GL_BLEND</code>, or <code>GL_ADD</code>:
*
* <pre>
* Base internal Texture functions
* format GL_MODULATE GL_DECAL
*
* <p>GL_ALPHA Cv = Cf undefined
* Av = Af*At
*
* <p>GL_LUMINANCE Cv = Cf*Lt undefined
* Av = Af
*
* <p>GL_LUMINANCE_ALPHA Cv = Cf*Lt undefined
* Av = Af*At
*
* <p>GL_RGB Cv = Cf*Ct Cv = Ct
* Av = Af Av = Af
*
* <p>GL_RGBA Cv = Cf*Ct Cv = Cf*(1 - At) + Ct*At
* Av = Af*At Av = Af
*
* <p>Base internal Texture functions
* format GL_BLEND GL_REPLACE
*
* <p>GL_ALPHA Cv = Cf Cv = Cf
* Av = Af*At Av = At
*
* <p>GL_LUMINANCE Cv = Cf*(1 - Lt) + Cc*Lt Cv = Lt
* Av = Af Av = Af
*
* <p>GL_LUMINANCE_ALPHA Cv = Cf*(1 - Lt) + Cc*Lt Cv = Lt
* Av = Af*At Av = At
*
* <p>GL_RGB Cv = Cf*(1 - Ct) + Cc*Ct Cv = Ct
* Av = Af Av = Af
*
* <p>GL_RGBA Cv = Cf*(1 - Ct) + Cc*Ct Cv = Ct
* Av = Af*At Av = At
*
* <p>Base internal Texture functions
* format GL_ADD
*
* <p>GL_ALPHA Cv = Cf
* Av = Af*At
*
* <p>GL_LUMINANCE Cv = Cf + Lt
* Av = Af
*
* <p>GL_LUMINANCE_ALPHA Cv = Cf + Lt
* Av = Af*At
*
* <p>GL_RGB Cv = Cf + Ct
* Av = Af
*
* <p>GL_RGBA Cv = Cf + Ct
* Av = Af*At
* </pre>
*
* <p>If <code>pname</code> is <code>GL_TEXTURE_ENV_COLOR</code>,
* <code>params</code> is a pointer to an array that holds an RGBA
* color consisting of four values. The values are clamped to the
* range <code>[0, 1]</code> when they are specified. <i>Cc</i>
* takes these four values.
*
* <p>The initial value of <code>GL_TEXTURE_ENV_MODE</code> is
* <code>GL_MODULATE</code>. The initial value of
* <code>GL_TEXTURE_ENV_COLOR</code> is (0, 0, 0, 0).
*
* <h4>1.1 Notes</h4>
*
* <p> If the value of <code>GL_TEXTURE_ENV_MODE</code> is
* <code>GL_COMBINE</code>, then the form of the texture function
* depends on the values of <code>GL_COMBINE_RGB</code> and
* <code>GL_COMBINE_ALPHA</code>.
*
* <p>The RGB and ALPHA results of the texture function are then
* multiplied by the values of <code>GL_RGB_SCALE</code> and
* <code>GL_ALPHA_SCALE</code>, respectively.
*
* <p>The results are clamped to <code>[0, 1]</code>.
*
* <p>The arguments <i>Arg0</i>, <i>Arg1</i>, <i>Arg2</i> are
* determined by the values of
* <code>GL_SRC</code><i>n</i><code>_RGB</code>,
* <code>GL_SRC</code><i>n</i><code>_ALPHA</code>,
* <code>GL_OPERAND</code><i>n</i><code>_RGB</code>,
* <code>GL_OPERAND</code><i>n</i><code>_ALPHA</code>, where
* <i>n</i> = 0, 1, or 2, <i>Cs</i> and <i>As</i> denote the texture
* source color and alpha from the texture image bound to texture
* unit <i>n</i>.
*
* <p>The state required for the current texture environment, for
* each texture unit, consists of a six-valued integer indicating
* the texture function, an eight-valued integer indicating the RGB
* combiner function and a six-valued integer indicating the ALPHA
* combiner function, six four-valued integers indicating the
* combiner RGB and ALPHA source arguments, three four-valued
* integers indicating the combiner RGB operands, three two-valued
* integers indicating the combiner ALPHA operands, and four
* floating-point environment color values. In the initial state,
* the texture and combiner functions are each
* <code>GL_MODULATE</code>, the combiner RGB and ALPHA sources are
* each <code>GL_TEXTURE</code>, <code>GL_PREVIOUS</code>, and
* <code>GL_CONSTANT</code> for sources 0, 1, and 2 respectively,
* the combiner RGB operands for sources 0 and 1 are each
* <code>SRC_COLOR</code>, the combiner RGB operand for source 2, as
* well as for the combiner ALPHA operands, are each
* <code>GL_SRC_ALPHA</code>, and the environment color is (0, 0, 0,
* 0).
*
* <p>The state required for the texture filtering parameters, for
* each texture unit, consists of a single floating-point level of
* detail bias. The initial value of the bias is 0.0.
*
* <p>If <code>pname</code> is <code>GL_TEXTURE_ENV_COLOR</code>,
* then <code>params</code> is an array that holds an RGBA color
* consisting of four values. The values are clamped to the range
* <code>[0, 1]</code> when they are specified. <i>Cc</i> takes
* these four values.
*
* <p>The initial value of <code>GL_TEXTURE_ENV_MODE</code> is
* <code>GL_MODULATE</code>. The initial value of
* <code>GL_TEXTURE_ENV_COLOR</code> is (0, 0, 0, 0).
*
* <p>If <code>target</code> is <code>GL_POINT_SPRITE_OES</code>
* then the following applies:
*
* <p>If <code>pname</code> is <code>GL_COORD_REPLACE_OES</code>,
* then the point sprite texture coordinate replacement mode is set
* from the value given by param, which may either be
* <code>GL_FALSE</code> or <code>GL_TRUE</code>. The default value
* for each texture unit is for point sprite texture coordinate
* replacement to be disabled.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated when target or pname
* is not one of the accepted values, or when <code>params</code>
* should have a defined constant value (based on the value of
* <code>pname</code>) and does not.
*
* <h4>Associated Gets (1.1 only)</h4>
*
* <p><code>glGetTexEnv</code>
*
* @param target Specifies a texture environment. Can be either
* <code>GL_TEXTURE_ENV</code> or <code>GL_POINT_SPRITE_OES</code>
* (<code>OES_point_sprite</code> extension).
* @param pname Specifies the symbolic name of a single-valued
* texture environment parameter. Must be one of
* <code>GL_TEXTURE_ENV_MODE</code>,
* <code>GL_TEXTURE_ENV_COLOR</code> (1.1 only),
* <code>GL_COMBINE_RGB</code> (1.1 only),
* <code>GL_COMBINE_ALPHA</code> (1.1 only), or
* <code>GL_COORD_REPLACE_OES</code> (<code>OES_point_sprite</code>
* extension).
* @param param Specifies a single symbolic constant, one of
* <code>GL_REPLACE</code>, <code>GL_MODULATE</code>,
* <code>GL_DECAL</code>, <code>GL_BLEND</code>, or
* <code>GL_ADD</code> (1.1 only).
*/
void glTexEnvf(int target, int pname, float param);
/**
* Set texture environment parameters (array version).
*
* <p>A texture environment specifies how texture values are
* interpreted when a fragment is textured. <code>target</code> must
* be <code>GL_TEXTURE_ENV</code>. <code>pname</code> can be either
* <code>GL_TEXTURE_ENV_MODE</code> or
* <code>GL_TEXTURE_ENV_COLOR</code>.
*
* <p>If <code>pname</code> is <code>GL_TEXTURE_ENV_MODE</code>,
* then <code>params</code> contains the symbolic name of a texture
* function. Four texture functions may be specified:
* <code>GL_MODULATE</code>, <code>GL_DECAL</code>,
* <code>GL_BLEND</code>, and <code>GL_REPLACE</code>.
*
* <p>A texture function acts on the fragment to be textured using
* the texture image value that applies to the fragment (see
* <code>glTexParameter</code>) and produces an RGBA color for that
* fragment. The following table shows how the RGBA color is
* produced for each of the three texture functions that can be
* chosen. C is a triple of color values (RGB) and A is the
* associated alpha value. RGBA values extracted from a texture
* image are in the range <code>[0, 1]</code>. The subscript
* <i>f</i> refers to the incoming fragment, the subscript <i>t</i>
* to the texture image, the subscript <i>c</i> to the texture
* environment color, and subscript <i>v</i> indicates a value
* produced by the texture function.
*
* <p>A texture image can have up to four components per texture
* element (see <code>glTexImage2D</code>, and
* <code>glCopyTexImage2D</code>). In a one-component image,
* <i>Lt</i> indicates that single component. A two-component image
* uses <i>Lt</i> and <i>At</i>. A three-component image has only a
* color value, <i>Ct</i>. A four-component image has both a color
* value <i>Ct</i> and an alpha value <i>At</i>.
*
* <pre>
* Base internal Texture functions
* format GL_MODULATE GL_DECAL
*
* <p>GL_ALPHA Cv = Cf undefined
* Av = At Af
*
* <p>GL_LUMINANCE Cv = Lt Cf undefined
* Av = Af
*
* <p>GL_LUMINANCE_ALPHA Cv = Lt Cf undefined
* Av = At Af
*
* <p>GL_RGB Cv = Ct Cf Cv = Ct
* Av = Af Av = Af
*
* <p>GL_RGBA Cv = Ct Cf Cv = (1 - At) Cf + At Ct
* Av = At Af Av = Af
*
* <p>Base internal Texture functions
* format GL_BLEND GL_REPLACE
*
* <p>GL_ALPHA Cv = Cf Cv = Cf
* Av = At Af Av = At
*
* <p>GL_LUMINANCE Cv = (1 - Lt) Cf + Lt Cc Cv = Lt
* Av = Af Av = Af
*
* <p>GL_LUMINANCE_ALPHA Cv = (1 - Lt) Cf + Lt Cc Cv = Lt
* Av = At Af Av = At
*
* <p>GL_RGB Cv = (1 - Ct) Cf + Ct Cc Cv = Ct
* Av = Af Av = Af
*
* <p>GL_RGBA Cv = (1 - Ct) Cf + Ct Cc Cv = Ct
* Av = At Af Av = At
* </pre>
*
* <p>If <code>pname</code> is <code>GL_TEXTURE_ENV_COLOR</code>,
* <code>params</code> holds an RGBA color consisting of four
* values. The values are clamped to the range <code>[0, 1]</code>
* when they are specified. <i>Cc</i> takes these four values.
*
* <p>The initial value of <code>GL_TEXTURE_ENV_MODE</code> is
* <code>GL_MODULATE</code>. The initial value of
* <code>GL_TEXTURE_ENV_COLOR</code> is (0, 0, 0, 0).
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated when target or pname
* is not one of the accepted values, or when <code>params</code>
* should have a defined constant value (based on the value of
* <code>pname</code>) and does not.
*
* @param target Specifies a texture environment. Must be
* <code>GL_TEXTURE_ENV</code>.
* @param pname Specifies the symbolic name of a texture environment
* parameter. Accepted values are <code>GL_TEXTURE_ENV_MODE</code> and
* <code>GL_TEXTURE_ENV_COLOR</code>.
* @param params Specifies a parameter array that contains either a
* single symbolic constant or an RGBA color.
* @param offset the starting offset within the
* <code>params</code> array.
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>params.length -
* offset</code> is smaller than the number of values required by
* the parameter.
*/
void glTexEnvfv(int target, int pname, float[] params, int offset);
/**
* Floating-point <code>Buffer</code> version of <code>glTexEnv</code>.
*
* @see #glTexEnvfv(int target, int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>params.remaining()</code> is smaller than the number of
* values required by the parameter.
*/
void glTexEnvfv(int target, int pname, FloatBuffer params);
/**
* Fixed-point version of <code>glTexEnv</code>.
*
* @see #glTexEnvf(int target, int pname, float param)
*/
void glTexEnvx(int target, int pname, int param);
/**
* Fixed-point array version of <code>glTexEnv</code>.
*
* @see #glTexEnvfv(int target, int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>offset</code> is
* less than 0.
* @exception IllegalArgumentException if <code>params.length -
* offset</code> is smaller than the number of values required by
* the parameter.
*/
void glTexEnvxv(int target, int pname, int[] params, int offset);
/**
* Fixed-point <code>Buffer</code> version of <code>glTexEnv</code>.
*
* @see #glTexEnvfv(int target, int pname, float[] params, int offset)
*
* @exception IllegalArgumentException if <code>params</code> is
* <code>null</code>.
* @exception IllegalArgumentException if
* <code>params.remaining()</code> is smaller than the number of
* values required by the parameter.
*/
void glTexEnvxv(int target, int pname, IntBuffer params);
/**
* Specify a two-dimensional texture image.
*
* <p>Texturing maps a portion of a specified texture image onto
* each graphical primitive for which texturing is enabled. To
* enable and disable two-dimensional texturing, call
* <code>glEnable</code> and glDisable with argument
* <code>GL_TEXTURE_2D</code>. Two-dimensional texturing is
* initially disabled.
*
* <p>To define texture images, call <code>glTexImage2D</code>. The arguments
* describe the parameters of the texture image, such as height,
* width, width of the border, level-of-detail number (see
* glTexParameter), and number of color components provided. The
* last three arguments describe how the image is represented in
* memory.
*
* <p>Data is read from pixels as a sequence of unsigned bytes or
* shorts, depending on type. These values are grouped into sets of
* one, two, three, or four values, depending on format, to form
* elements.
*
* <p>When type is <code>GL_UNSIGNED_BYTE</code>, each of these
* bytes is interpreted as one color component, depending on
* format. When type is one of <code>GL_UNSIGNED_SHORT_5_6_5</code>,
* <code>GL_UNSIGNED_SHORT_4_4_4_4</code>,
* <code>GL_UNSIGNED_SHORT_5_5_5_1</code>, each unsigned value is
* interpreted as containing all the components for a single pixel,
* with the color components arranged according to format.
*
* <p>The first element corresponds to the lower left corner of the
* texture image. Subsequent elements progress left-to-right through
* the remaining texels in the lowest row of the texture image, and
* then in successively higher rows of the texture image. The final
* element corresponds to the upper right corner of the texture
* image.
*
* <p>By default, adjacent pixels are taken from adjacent memory
* locations, except that after all width pixels are read, the read
* pointer is advanced to the next four-byte boundary. The four-byte
* row alignment is specified by <code>glPixelStore</code> with argument
* <code>GL_UNPACK_ALIGNMENT</code>, and it can be set to one, two, four, or
* eight bytes.
*
* <p>format determines the composition of each element in pixels. It
* can assume one of the following symbolic values:
*
* <ul>
*
* <li><code>GL_ALPHA</code></li>
*
* <p>Each element is a single alpha component. The GL converts it to
* floating point and assembles it into an RGBA element by attaching
* 0 for red, green, and blue.
*
* <li><code>GL_RGB</code></li>
*
* <p>Each element is an RGB triple. The GL converts it to fixed-point
* or floating-point and assembles it into an RGBA element by
* attaching 1 for alpha.
*
* <li><code>GL_RGBA</code></li>
*
* <p>Each element contains all four components. The GL converts it to
* fixed-point or floating-point.
*
* <li><code>GL_LUMINANCE</code></li>
*
* <p>Each element is a single luminance value. The GL converts it to
* fixed-point or floating-point, then assembles it into an RGBA
* element by replicating the luminance value three times for red,
* green, and blue and attaching 1 for alpha.
*
* <li><code>GL_LUMINANCE_ALPHA</code></li>
*
* <p>Each element is a luminance/alpha pair. The GL converts it to
* fixed-point or floating point, then assembles it into an RGBA
* element by replicating the luminance value three times for red,
* green, and blue.
*
* </ul>
*
* <h4>Notes</h4>
*
* <p>pixels may be NULL. In this case texture memory is allocated to
* accommodate a texture of width width and height height. You can
* then download subtextures to initialize this texture memory. The
* image is undefined if the user tries to apply an uninitialized
* portion of the texture image to a primitive.
*
* <p><code>glTexImage2D</code> specifies the two-dimensional texture for the
* currently bound texture specified with <code>glBindTexture</code>, and the
* current texture unit, specified with <code>glActiveTexture</code>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if target is not
* <code>GL_TEXTURE_2D</code>.
*
* <p><code>GL_INVALID_ENUM</code> is generated if format is not an
* accepted constant.
*
* <p><code>GL_INVALID_ENUM</code> is generated if type is not a
* type constant.
*
* <p><code>GL_INVALID_VALUE</code> is generated if level is less
* than 0.
*
* <p><code>GL_INVALID_VALUE</code> may be generated if level is
* greater than log2max, where max is the returned value of
* <code>GL_MAX_TEXTURE_SIZE</code>.
*
* <p><code>GL_INVALID_VALUE</code> is generated if internalformat
* is not an accepted constant.
*
* <p><code>GL_INVALID_VALUE</code> is generated if width or height
* is less than 0 or greater than <code>GL_MAX_TEXTURE_SIZE</code>,
* or if either cannot be represented as 2^k + 2*border for some
* integer k.
*
* <p><code>GL_INVALID_VALUE</code> is generated if border is not 0.
*
* <p><code>GL_INVALID_OPERATION</code> is generated if
* internalformat and format are not the same.
*
* <p><code>GL_INVALID_OPERATION</code> is generated if type is
* <code>GL_UNSIGNED_SHORT_5_6_5</code> and format is not
* <code>GL_RGB</code>.
*
* <p><code>GL_INVALID_OPERATION</code> is generated if typeis one
* of <code>GL_UNSIGNED_SHORT_4_4_4_4</code>, or
* <code>GL_UNSIGNED_SHORT_5_5_5_1</code> and formatis not
* <code>GL_RGBA</code>.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_MAX_TEXTURE_SIZE</code>
*
* @param target Specifies the target texture. Must be
* <code>GL_TEXTURE_2D</code>.
* @param level Specifies the level-of-detail number. Level 0 is the
* base image level. Level n is the nth mipmap reduction image. Must
* be greater or equal 0.
* @param internalformat Specifies the color components in the
* texture. Must be same as format. The following symbolic values
* are accepted: <code>GL_ALPHA</code>, <code>GL_RGB</code>,
* <code>GL_RGBA</code>, <code>GL_LUMINANCE</code>, or
* <code>GL_LUMINANCE_ALPHA</code>.
* @param width Specifies the width of the texture image. Must be
* 2^n + 2*border for some integer n. All implementations support
* texture images that are at least 64 texels wide.
* @param height Specifies the height of the texture image. Must be
* 2^m + 2*border for some integer m. All implementations support
* texture images that are at least 64 texels high.
* @param border Specifies the width of the border. Must be 0.
* @param format Specifies the format of the pixel data. Must be
* same as internalformat. The following symbolic values are
* accepted: <code>GL_ALPHA</code>, <code>GL_RGB</code>,
* <code>GL_RGBA</code>, <code>GL_LUMINANCE</code>, and
* <code>GL_LUMINANCE_ALPHA</code>.
* @param type Specifies the data type of the pixel data. The
* following symbolic values are accepted:
* <code>GL_UNSIGNED_BYTE</code>,
* <code>GL_UNSIGNED_SHORT_5_6_5</code>,
* <code>GL_UNSIGNED_SHORT_4_4_4_4</code>, and
* <code>GL_UNSIGNED_SHORT_5_5_5_1</code>.
* @param pixels Specifies a pointer to the image data in memory.
*
* @exception IllegalArgumentException if <code>pixels</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>pixels</code> does
* not contain the desired number of pixels.
*/
void glTexImage2D(int target, int level,
int internalformat,
int width, int height,
int border, int format, int type,
Buffer pixels);
/**
* Set texture parameters.
*
* <p>Texture mapping is a technique that applies an image onto an
* object's surface as if the image were a decal or cellophane
* shrink-wrap. The image is created in texture space, with an (s,
* t) coordinate system. A texture is a one- or two-dimensional
* image and a set of parameters that determine how samples are
* derived from the image.
*
* <p><code>glTexParameter</code> assigns the value or values in
* <code>param</code> to the texture parameter specified as
* <code>pname</code>. <code>target</code> defines the target
* texture, which must be <code>GL_TEXTURE_2D</code>. The following
* symbols are accepted in <code>pname</code>:
*
* <ul>
*
* <li><code>GL_TEXTURE_MIN_FILTER</code></li>
*
* <p>The texture minifying function is used whenever the pixel being
* textured maps to an area greater than one texture element. There
* are six defined minifying functions. Two of them use the nearest
* one or nearest four texture elements to compute the texture
* value. The other four use mipmaps.
*
* <p>A mipmap is an ordered set of arrays representing the same image
* at progressively lower resolutions. If the texture has dimensions
* 2^n × 2^m, there are max (n, m) + 1 mipmaps. The first mipmap is
* the original texture, with dimensions 2^n × 2^m. Each subsequent
* mipmap has dimensions 2^(k - 1) × 2^(l - 1), where 2^k × 2^l are
* the dimensions of the previous mipmap, until either k = 0 or l =
* 0. At that point, subsequent mipmaps have dimension 1 × 2^(l - 1)
* or 2^(k - 1) × 1 until the final mipmap, which has dimension 1 ×
* 1. To define the mipmaps, call <code>glTexImage2D</code> or
* glCopyTexImage2D with the level argument indicating the order of
* the mipmaps. Level 0 is the original texture. Level max (n, m) is
* the final 1 × 1 mipmap.
*
* <p><code>param</code> supplies a function for minifying the
* texture as one of the following:
*
* <ul>
* <li><code>GL_NEAREST</code></li>
*
* <p>Returns the value of the texture element that is nearest (in
* Manhattan distance) to the center of the pixel being textured.
*
* <li><code>GL_LINEAR</code></li>
*
* <p>Returns the weighted average of the four texture elements that
* are closest to the center of the pixel being textured. These can
* include border texture elements, depending on the values of
* <code>GL_TEXTURE_WRAP_S</code> and
* <code>GL_TEXTURE_WRAP_T</code>, and on the exact mapping.
*
* <li><code>GL_NEAREST_MIPMAP_NEAREST</code></li>
*
* <p>Chooses the mipmap that most closely matches the size of the
* pixel being textured and uses the <code>GL_NEAREST</code>
* criterion (the texture element nearest to the center of the
* pixel) to produce a texture value.
*
* <li><code>GL_LINEAR_MIPMAP_NEAREST</code></li>
*
* <p>Chooses the mipmap that most closely matches the size of the
* pixel being textured and uses the <code>GL_LINEAR</code>
* criterion (a weighted average of the four texture elements that
* are closest to the center of the pixel) to produce a texture
* value.
*
* <li><code>GL_NEAREST_MIPMAP_LINEAR</code></li>
*
* <p>Chooses the two mipmaps that most closely match the size of the
* pixel being textured and uses the <code>GL_NEAREST</code> criterion (the
* texture element nearest to the center of the pixel) to produce a
* texture value from each mipmap. The final texture value is a
* weighted average of those two values.
*
* <li><code>GL_LINEAR_MIPMAP_LINEAR</code></li>
*
* <p>Chooses the two mipmaps that most closely match the size of the
* pixel being textured and uses the <code>GL_LINEAR</code>
* criterion (a weighted average of the four texture elements that
* are closest to the center of the pixel) to produce a texture
* value from each mipmap. The final texture value is a weighted
* average of those two values.
*
* </ul>
*
* <p>As more texture elements are sampled in the minification process,
* fewer aliasing artifacts will be apparent. While the
* <code>GL_NEAREST</code> and <code>GL_LINEAR</code> minification
* functions can be faster than the other four, they sample only one
* or four texture elements to determine the texture value of the
* pixel being rendered and can produce moire patterns or ragged
* transitions.
*
* <p>The initial value of <code>GL_TEXTURE_MIN_FILTER</code> is
* <code>GL_NEAREST_MIPMAP_LINEAR</code>.
*
* <li><code>GL_TEXTURE_MAG_FILTER</code></li>
*
* <p>The texture magnification function is used when the pixel being
* textured maps to an area less than or equal to one texture
* element. It sets the texture magnification function to either
* <code>GL_NEAREST</code> or <code>GL_LINEAR</code> (see
* below). <code>GL_NEAREST</code> is generally faster than
* <code>GL_LINEAR</code>, but it can produce textured images with
* sharper edges because the transition between texture elements is
* not as smooth.
*
* <p>The initial value of <code>GL_TEXTURE_MAG_FILTER</code> is
* <code>GL_LINEAR</code>.
*
* <li><code>GL_NEAREST</code></li>
*
* <p>Returns the value of the texture element that is nearest (in
* Manhattan distance) to the center of the pixel being textured.
*
* <li><code>GL_LINEAR</code></li>
*
* <p>Returns the weighted average of the four texture elements that
* are closest to the center of the pixel being textured. These can
* include border texture elements, depending on the values of
* <code>GL_TEXTURE_WRAP_S</code> and
* <code>GL_TEXTURE_WRAP_T</code>, and on the exact mapping.
*
* <li><code>GL_TEXTURE_WRAP_S</code></li>
*
* <p>Sets the wrap parameter for texture coordinate <i>s</i> to
* either <code>GL_CLAMP</code>, <code>GL_CLAMP_TO_EDGE</code>, or
* <code>GL_REPEAT</code> <!-- , or <code>GL_MIRRORED_REPEAT</code>
* (<code>OES_texture_mirrored_repeat</code>
* extension) -->. <code>GL_CLAMP</code> causes <i>s</i> coordinates to
* be clamped to the range <code>[0, 1]</code> and is useful for
* preventing wrapping artifacts when mapping a single image onto an
* object. <code>GL_CLAMP_TO_EDGE</code> causes <i>s</i> coordinates
* to be clamped to the range <code>[1/(2<i>N</i>), 1 -
* 1/(2<i>N</i>)]</code>, where <i>N</i> is the size of the texture
* in the direction of clamping. <code>GL_REPEAT</code> causes the
* integer part of the <i>s</i> coordinate to be ignored; the GL
* uses only the fractional part, thereby creating a repeating
* pattern. Border texture elements are accessed only if wrapping is
* set to <code>GL_CLAMP</code>.
*
* <p>Initially, <code>GL_TEXTURE_WRAP_S</code> is set to
* <code>GL_REPEAT</code>.
*
* <li><code>GL_TEXTURE_WRAP_T</code></li>
*
* <p>Sets the wrap parameter for texture coordinate <i>t</i> to
* either <code>GL_CLAMP</code>, <code>GL_CLAMP_TO_EDGE</code>, or
* <code>GL_REPEAT</code> <!-- , or <code>GL_MIRRORED_REPEAT</code>
* (<code>OES_texture_mirrored_repeat</code> extension) -->. See the
* discussion under <code>GL_TEXTURE_WRAP_S</code>.
*
* <p>Initially, <code>GL_TEXTURE_WRAP_T</code> is set to
* <code>GL_REPEAT</code>.
*
* <li><code>GL_GENERATE_MIPMAP</code> (1.1 only)</li>
*
* <p>Sets the automatic mipmap generation parameter. If set to
* <code>GL_TRUE</code>, making any change to the interior or border
* texels of the levelbase array of a mipmap will also compute a
* complete set of mipmap arrays derived from the modified levelbase
* array. Array levels <i>levelbase + 1</i> through <i>p</i> are
* replaced with the derived arrays, regardless of their previous
* contents. All other mipmap arrays, including the levelbase array,
* are left unchanged by this computation.
*
* <p>The initial value of <code>GL_GENERATE_MIPMAP</code> is
* <code>GL_FALSE</code>.
*
* </ul>
*
* <h4>Notes</h4>
*
* <p>Suppose that a program has enabled texturing (by calling
* glEnable with argument <code>GL_TEXTURE_2D</code> and has set
* <code>GL_TEXTURE_MIN_FILTER</code> to one of the functions that
* requires a mipmap. If either the dimensions of the texture images
* currently defined (with previous calls to
* <code>glTexImage2D</code>, or glCopyTexImage2D) do not follow the
* proper sequence for mipmaps (described above), or there are fewer
* texture images defined than are needed, or the set of texture
* images have differing numbers of texture components, then it is
* as if texture mapping were disabled.
*
* <p>Linear filtering accesses the four nearest texture elements.
*
* <p><code>glTexParameter</code> specifies the texture parameters
* for the active texture unit, specified by calling
* <code>glActiveTexture</code>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if target or pname
* is not one of the accepted defined values.
*
* <p><code>GL_INVALID_ENUM</code> is generated if param should have
* a defined constant value (based on the value of pname) and does
* not.
*
* @param target Specifies the target texture, which must be
* <code>GL_TEXTURE_2D</code>.
* @param pname Specifies the symbolic name of a single-valued
* texture parameter. <code>pname</code> can be one of the
* following: <code>GL_TEXTURE_MIN_FILTER</code>,
* <code>GL_TEXTURE_MAG_FILTER</code>,
* <code>GL_TEXTURE_WRAP_S</code>, <code>GL_TEXTURE_WRAP_T</code>, or
* <code>GL_GENERATE_MIPMAP</code> (1.1 only) <!--, or
* <code>GL_TEXTURE_CROP_RECT_OES</code>
* (<code>OES_draw_texture</code> extension) -->.
* @param param Specifies the value of <code>pname</code>.
*/
void glTexParameterf(int target, int pname, float param);
/**
* Fixed-point version of <code>glTexParameter</code>.
*
* @see #glTexParameterf(int target, int pname, float param)
*/
void glTexParameterx(int target, int pname, int param);
/**
* Specify a two-dimensional texture subimage.
*
* <p>Texturing maps a portion of a specified texture image onto
* each graphical primitive for which texturing is enabled. To
* enable and disable two-dimensional texturing, call
* <code>glEnable</code> and glDisable with argument
* <code>GL_TEXTURE_2D</code>. Two-dimensional texturing is
* initially disabled.
*
* <p><code>glTexSubImage2D</code> redefines a contiguous subregion
* of an existing two-dimensional texture image. The texels
* referenced by pixels replace the portion of the existing texture
* array with x indices xoffset and xoffset + width - 1, inclusive,
* and y indices yoffset and yoffset + height - 1, inclusive. This
* region may not include any texels outside the range of the
* texture array as it was originally specified. It is not an error
* to specify a subtexture with zero width or height, but such a
* specification has no effect.
*
* <h4>Notes</h4>
*
* <p><code>glPixelStore</code> affects texture images in exactly
* the way it affects <code>glTexImage2D</code>.
*
* <p><code>glTexSubImage2D</code> specifies a two-dimensional sub
* texture for the currently bound texture, specified with
* <code>glBindTexture</code> and current texture unit, specified
* with <code>glActiveTexture</code>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_ENUM</code> is generated if target is not
* <code>GL_TEXTURE_2D</code>.
*
* <p><code>GL_INVALID_OPERATION</code> is generated if the texture
* array has not been defined by a previous
* <code>glTexImage2D</code> or glCopyTexImage2D operation.
*
* <p><code>GL_INVALID_VALUE</code> is generated if level is less
* than 0.
*
* <p><code>GL_INVALID_VALUE</code> may be generated if level is
* greater than log2max, where max is the returned value of
* <code>GL_MAX_TEXTURE_SIZE</code>.
*
* <p><code>GL_INVALID_VALUE</code> is generated if xoffset < - b,
* xoffset + width > (w - b) , yoffset < - b, or yoffset + height >
* (h - b) , where w is the texture width, h is the texture height,
* and b is the border of the texture image being modified. Note
* that w and h include twice the border width.
*
* <p><code>GL_INVALID_VALUE</code> is generated if width or height
* is less than 0.
*
* <p><code>GL_INVALID_ENUM</code> is generated if format is not an
* accepted constant.
*
* <p><code>GL_INVALID_ENUM</code> is generated if type is not a
* type constant.
*
* <p><code>GL_INVALID_OPERATION</code> is generated if type is
* <code>GL_UNSIGNED_SHORT_5_6_5</code> and format is not
* <code>GL_RGB</code>.
*
* <p><code>GL_INVALID_OPERATION</code> is generated if type is one
* of <code>GL_UNSIGNED_SHORT_4_4_4_4</code>, or
* <code>GL_UNSIGNED_SHORT_5_5_5_1</code> and format is not
* <code>GL_RGBA</code>.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_MAX_TEXTURE_SIZE</code>
*
* @param target Specifies the target texture. Must be
* <code>GL_TEXTURE_2D</code>.
* @param level Specifies the level-of-detail number. Level 0 is the
* base image level. Level n is the nth mipmap reduction image.
* @param xoffset Specifies a texel offset in the x direction within
* the texture array.
* @param yoffset Specifies a texel offset in the y direction within
* the texture array.
* @param width Specifies the width of the texture subimage.
* @param height Specifies the height of the texture subimage.
* @param format Specifies the of the pixel data. The following
* symbolic values are accepted: <code>GL_ALPHA</code>,
* <code>GL_RGB</code>, <code>GL_RGBA</code>,
* <code>GL_LUMINANCE</code>, and <code>GL_LUMINANCE_ALPHA</code>.
* @param type Specifies the data type of the pixel data. The
* following symbolic values are accepted:
* <code>GL_UNSIGNED_BYTE</code>,
* <code>GL_UNSIGNED_SHORT_5_6_5</code>,
* <code>GL_UNSIGNED_SHORT_4_4_4_4</code>, and
* <code>GL_UNSIGNED_SHORT_5_5_5_1</code>.
* @param pixels Specifies the image data.
*
* @exception IllegalArgumentException if <code>pixels</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>pixels</code> does
* not contain the desired number of pixels.
*/
void glTexSubImage2D(int target, int level,
int xoffset, int yoffset,
int width, int height,
int format, int type,
Buffer pixels);
/**
* Multiply the current matrix by a translation matrix.
*
* <p><code>glTranslate</code> produces a translation by (x, y, z).
* The current matrix (see glMatrixMode) is multiplied by this
* translation matrix, with the product replacing the current
* matrix, as if <code>glMultMatrix</code> were called with the
* following matrix for its argument:
*
* <pre>
* ( 1 0 0 x )
* ( 0 1 0 y )
* ( 0 0 1 z )
* ( 0 0 0 1 )
* </pre>
*
* <p>If the matrix mode is either <code>GL_MODELVIEW</code> or
* <code>GL_PROJECTION</code>, all objects drawn after a call to
* <code>glTranslate</code> are translated.
*
* <p>Use <code>glPushMatrix</code> and <code>glPopMatrix</code> to
* save and restore the untranslated coordinate system.
*
* @param x Specifies the x coordinate of a translation vector.
* @param y Specifies the y coordinate of a translation vector.
* @param z Specifies the z coordinate of a translation vector.
*/
void glTranslatef(float x, float y, float z);
/**
* Fixed-point version of <code>glTranslate</code>.
*
* @see #glTranslatef
*/
void glTranslatex(int x, int y, int z);
// Need revisit - pointer == null
/**
* Define an array of vertex coordinates.
*
* <p><code>glVertexPointer</code> specifies the location and data
* of an array of vertex coordinates to use when
* rendering. <code>size</code> specifies the number of coordinates
* per vertex and type the data type of the
* coordinates. <code>stride</code> specifies the byte stride from
* one vertex to the next allowing vertices and attributes to be
* packed into a single array or stored in separate
* arrays. (Single-array storage may be more efficient on some
* implementations.)
*
* <p>When a vertex array is specified, <code>size</code>,
* <code>type</code>, <code>stride</code>, and <code>pointer</code>
* are saved as client-side state.
*
* <p>If the vertex array is enabled, it is used when
* <code>glDrawArrays</code>, or <code>glDrawElements</code> is
* called. To enable and disable the vertex array, call
* <code>glEnableClientState</code> and
* <code>glDisableClientState</code> with the argument
* <code>GL_VERTEX_ARRAY</code>. The vertex array is initially
* disabled and isn't accessed when <code>glDrawArrays</code> or
* <code>glDrawElements</code> is called.
*
* <p>Use <code>glDrawArrays</code> to construct a sequence of
* primitives (all of the same type) from prespecified vertex and
* vertex attribute arrays. Use <code>glDrawElements</code> to
* construct a sequence of primitives by indexing vertices and
* vertex attributes.
*
* <h4>Notes</h4>
*
* <p><code>glVertexPointer</code> is typically implemented on the
* client side.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_VALUE</code> is generated if size is not 2,
* 3, or 4.
*
* <p><code>GL_INVALID_ENUM</code> is generated if type is is not an
* accepted value.
*
* <p><code>GL_INVALID_VALUE</code> is generated if stride is
* negative.
*
* <p> The <code>pointer</code> argument must be a direct buffer
* with a type matching that specified by the <code>type</code>
* argument.
*
* @param size Specifies the number of coordinates per vertex. Must
* be 2, 3, or 4. The initial value is 4.
* @param type Specifies the data type of each vertex coordinate in
* the array. Symbolic constants <code>GL_BYTE</code>,
* <code>GL_SHORT</code>, <code>GL_FIXED</code>, and
* <code>GL_FLOAT</code> are accepted. The initial value is
* <code>GL_FLOAT</code>.
* @param stride Specifies the byte offset between consecutive
* vertices. If stride is 0, the vertices are understood to be
* tightly packed in the array. The initial value is 0.
* @param pointer Specifies a Buffer containing the coordinates of
* the vertices.
*
* @exception IllegalStateException if OpenGL ES 1.1 is being used and
* VBOs are enabled.
* @exception IllegalArgumentException if <code>pointer</code>
* is not direct.
*/
void glVertexPointer(int size, int type, int stride, Buffer pointer);
/**
* Set the viewport.
*
* <p><code>glViewport</code> specifies the affine transformation of
* x and y from normalized device coordinates to window
* coordinates. Let (xnd, ynd) be normalized device
* coordinates. Then the window coordinates (xw, yw) are computed as
* follows:
*
* <pre>
* xw = ( xnd + 1 ) width/2 + x
* yw = ( ynd + 1 ) height/2 + y
* </pre>
*
* <p>Viewport width and height are silently clamped to a range that
* depends on the implementation. To query this range, call
* <code>glGetIntegerv</code> with argument
* <code>GL_MAX_VIEWPORT_DIMS</code>.
*
* <h4>Errors</h4>
*
* <p><code>GL_INVALID_VALUE</code> is generated if either width or
* height is negative.
*
* <h4>Associated Gets</h4>
*
* <p><code>glGetIntegerv</code> with argument
* <code>GL_MAX_VIEWPORT_DIMS</code>
*
* @param x Specifies the x coordinate of the lower left corner of
* the viewport rectangle, in pixels. The initial value is 0.
* @param y Specifies the y coordinate of the lower left corner of
* the viewport rectangle, in pixels. The initial value is 0.
* @param width Specifies the width of the viewport. When a GL
* context is first attached to a surface (e.g. window), width and
* height are set to the dimensions of that surface.
* @param height Specifies the height of the viewport. When a GL
* context is first attached to a surface (e.g. window), width and
* height are set to the dimensions of that surface.
*/
void glViewport(int x, int y, int width, int height);
}
|
