0001: /*
0002: * Copyright 1990-2007 Sun Microsystems, Inc. All Rights Reserved.
0003: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
0004: *
0005: * This program is free software; you can redistribute it and/or
0006: * modify it under the terms of the GNU General Public License version
0007: * 2 only, as published by the Free Software Foundation.
0008: *
0009: * This program is distributed in the hope that it will be useful, but
0010: * WITHOUT ANY WARRANTY; without even the implied warranty of
0011: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0012: * General Public License version 2 for more details (a copy is
0013: * included at /legal/license.txt).
0014: *
0015: * You should have received a copy of the GNU General Public License
0016: * version 2 along with this work; if not, write to the Free Software
0017: * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
0018: * 02110-1301 USA
0019: *
0020: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
0021: * Clara, CA 95054 or visit www.sun.com if you need additional
0022: * information or have any questions.
0023: */
0024:
0025: package javax.microedition.khronos.opengles;
0026:
0027: import java.nio.*;
0028:
0029: /**
0030: * The <code>GL10</code> interface contains the Java(TM) programming
0031: * language bindings for OpenGL(R) ES 1.0 core functionality.
0032: *
0033: * <p> The <code>OES_byte_coordinates</code>,
0034: * <code>OES_single_precision</code>, <code>OES_fixed_point</code>,
0035: * <code>OES_read_format</code>, and
0036: * <code>OES_compressed_paletted_texture</code> extensions are
0037: * included as part of this interface.
0038: *
0039: * <p> Methods with an <code>x</code> or <code>xv</code> suffix belong
0040: * to the <code>OES_fixed_point</code> extension and take one or more
0041: * fixed-point arguments. Fixed-point arguments may be derived from
0042: * floating-point values by multiplying by 65536 (2^16) and rounding
0043: * to the nearest integer.
0044: *
0045: * <p> For ease of use, this interface documents method behavior for
0046: * all versions of OpenGL ES including version 1.1 and extensions.
0047: * When running on an OpenGL ES 1.0 implementation, sections marked
0048: * "(1.1 only)" should be disregarded.
0049: *
0050: * <p> See the <code>GL</code> interface for a description of how to
0051: * obtain an instance of this interface.
0052: */
0053: public interface GL10 extends GL {
0054:
0055: // ClearBufferMask
0056: /** OpenGL ES 1.0 constant. */
0057: int GL_DEPTH_BUFFER_BIT = 0x00000100;
0058: /** OpenGL ES 1.0 constant. */
0059: int GL_STENCIL_BUFFER_BIT = 0x00000400;
0060: /** OpenGL ES 1.0 constant. */
0061: int GL_COLOR_BUFFER_BIT = 0x00004000;
0062:
0063: // Boolean
0064: /** OpenGL ES 1.0 constant. */
0065: int GL_FALSE = 0;
0066: /** OpenGL ES 1.0 constant. */
0067: int GL_TRUE = 1;
0068:
0069: // BeginMode
0070: /** OpenGL ES 1.0 constant. */
0071: int GL_POINTS = 0x0000;
0072: /** OpenGL ES 1.0 constant. */
0073: int GL_LINES = 0x0001;
0074: /** OpenGL ES 1.0 constant. */
0075: int GL_LINE_LOOP = 0x0002;
0076: /** OpenGL ES 1.0 constant. */
0077: int GL_LINE_STRIP = 0x0003;
0078: /** OpenGL ES 1.0 constant. */
0079: int GL_TRIANGLES = 0x0004;
0080: /** OpenGL ES 1.0 constant. */
0081: int GL_TRIANGLE_STRIP = 0x0005;
0082: /** OpenGL ES 1.0 constant. */
0083: int GL_TRIANGLE_FAN = 0x0006;
0084:
0085: // AlphaFunction
0086: /** OpenGL ES 1.0 constant. */
0087: int GL_NEVER = 0x0200;
0088: /** OpenGL ES 1.0 constant. */
0089: int GL_LESS = 0x0201;
0090: /** OpenGL ES 1.0 constant. */
0091: int GL_EQUAL = 0x0202;
0092: /** OpenGL ES 1.0 constant. */
0093: int GL_LEQUAL = 0x0203;
0094: /** OpenGL ES 1.0 constant. */
0095: int GL_GREATER = 0x0204;
0096: /** OpenGL ES 1.0 constant. */
0097: int GL_NOTEQUAL = 0x0205;
0098: /** OpenGL ES 1.0 constant. */
0099: int GL_GEQUAL = 0x0206;
0100: /** OpenGL ES 1.0 constant. */
0101: int GL_ALWAYS = 0x0207;
0102:
0103: // BlendingFactorDest
0104: /** OpenGL ES 1.0 constant. */
0105: int GL_ZERO = 0;
0106: /** OpenGL ES 1.0 constant. */
0107: int GL_ONE = 1;
0108: /** OpenGL ES 1.0 constant. */
0109: int GL_SRC_COLOR = 0x0300;
0110: /** OpenGL ES 1.0 constant. */
0111: int GL_ONE_MINUS_SRC_COLOR = 0x0301;
0112: /** OpenGL ES 1.0 constant. */
0113: int GL_SRC_ALPHA = 0x0302;
0114: /** OpenGL ES 1.0 constant. */
0115: int GL_ONE_MINUS_SRC_ALPHA = 0x0303;
0116: /** OpenGL ES 1.0 constant. */
0117: int GL_DST_ALPHA = 0x0304;
0118: /** OpenGL ES 1.0 constant. */
0119: int GL_ONE_MINUS_DST_ALPHA = 0x0305;
0120:
0121: // BlendingFactorSrc
0122: /** OpenGL ES 1.0 constant. */
0123: int GL_DST_COLOR = 0x0306;
0124: /** OpenGL ES 1.0 constant. */
0125: int GL_ONE_MINUS_DST_COLOR = 0x0307;
0126: /** OpenGL ES 1.0 constant. */
0127: int GL_SRC_ALPHA_SATURATE = 0x0308;
0128:
0129: // CullFaceMode
0130: /** OpenGL ES 1.0 constant. */
0131: int GL_FRONT = 0x0404;
0132: /** OpenGL ES 1.0 constant. */
0133: int GL_BACK = 0x0405;
0134: /** OpenGL ES 1.0 constant. */
0135: int GL_FRONT_AND_BACK = 0x0408;
0136:
0137: // EnableCap
0138: /** OpenGL ES 1.0 constant. */
0139: int GL_FOG = 0x0B60;
0140: /** OpenGL ES 1.0 constant. */
0141: int GL_LIGHTING = 0x0B50;
0142: /** OpenGL ES 1.0 constant. */
0143: int GL_TEXTURE_2D = 0x0DE1;
0144: /** OpenGL ES 1.0 constant. */
0145: int GL_CULL_FACE = 0x0B44;
0146: /** OpenGL ES 1.0 constant. */
0147: int GL_ALPHA_TEST = 0x0BC0;
0148: /** OpenGL ES 1.0 constant. */
0149: int GL_BLEND = 0x0BE2;
0150: /** OpenGL ES 1.0 constant. */
0151: int GL_COLOR_LOGIC_OP = 0x0BF2;
0152: /** OpenGL ES 1.0 constant. */
0153: int GL_DITHER = 0x0BD0;
0154: /** OpenGL ES 1.0 constant. */
0155: int GL_STENCIL_TEST = 0x0B90;
0156: /** OpenGL ES 1.0 constant. */
0157: int GL_DEPTH_TEST = 0x0B71;
0158: /** OpenGL ES 1.0 constant. */
0159: int GL_POINT_SMOOTH = 0x0B10;
0160: /** OpenGL ES 1.0 constant. */
0161: int GL_LINE_SMOOTH = 0x0B20;
0162: /** OpenGL ES 1.0 constant. */
0163: int GL_SCISSOR_TEST = 0x0C11;
0164: /** OpenGL ES 1.0 constant. */
0165: int GL_COLOR_MATERIAL = 0x0B57;
0166: /** OpenGL ES 1.0 constant. */
0167: int GL_NORMALIZE = 0x0BA1;
0168: /** OpenGL ES 1.0 constant. */
0169: int GL_RESCALE_NORMAL = 0x803A;
0170: /** OpenGL ES 1.0 constant. */
0171: int GL_POLYGON_OFFSET_FILL = 0x8037;
0172: /** OpenGL ES 1.0 constant. */
0173: int GL_VERTEX_ARRAY = 0x8074;
0174: /** OpenGL ES 1.0 constant. */
0175: int GL_NORMAL_ARRAY = 0x8075;
0176: /** OpenGL ES 1.0 constant. */
0177: int GL_COLOR_ARRAY = 0x8076;
0178: /** OpenGL ES 1.0 constant. */
0179: int GL_TEXTURE_COORD_ARRAY = 0x8078;
0180: /** OpenGL ES 1.0 constant. */
0181: int GL_MULTISAMPLE = 0x809D;
0182: /** OpenGL ES 1.0 constant. */
0183: int GL_SAMPLE_ALPHA_TO_COVERAGE = 0x809E;
0184: /** OpenGL ES 1.0 constant. */
0185: int GL_SAMPLE_ALPHA_TO_ONE = 0x809F;
0186: /** OpenGL ES 1.0 constant. */
0187: int GL_SAMPLE_COVERAGE = 0x80A0;
0188:
0189: // ErrorCode
0190: /** OpenGL ES 1.0 constant. */
0191: int GL_NO_ERROR = 0;
0192: /** OpenGL ES 1.0 constant. */
0193: int GL_INVALID_ENUM = 0x0500;
0194: /** OpenGL ES 1.0 constant. */
0195: int GL_INVALID_VALUE = 0x0501;
0196: /** OpenGL ES 1.0 constant. */
0197: int GL_INVALID_OPERATION = 0x0502;
0198: /** OpenGL ES 1.0 constant. */
0199: int GL_STACK_OVERFLOW = 0x0503;
0200: /** OpenGL ES 1.0 constant. */
0201: int GL_STACK_UNDERFLOW = 0x0504;
0202: /** OpenGL ES 1.0 constant. */
0203: int GL_OUT_OF_MEMORY = 0x0505;
0204:
0205: // FogMode
0206: /** OpenGL ES 1.0 constant. */
0207: int GL_EXP = 0x0800;
0208: /** OpenGL ES 1.0 constant. */
0209: int GL_EXP2 = 0x0801;
0210:
0211: // FogParameter
0212: /** OpenGL ES 1.0 constant. */
0213: int GL_FOG_DENSITY = 0x0B62;
0214: /** OpenGL ES 1.0 constant. */
0215: int GL_FOG_START = 0x0B63;
0216: /** OpenGL ES 1.0 constant. */
0217: int GL_FOG_END = 0x0B64;
0218: /** OpenGL ES 1.0 constant. */
0219: int GL_FOG_MODE = 0x0B65;
0220: /** OpenGL ES 1.0 constant. */
0221: int GL_FOG_COLOR = 0x0B66;
0222:
0223: // FrontFaceDirection
0224: /** OpenGL ES 1.0 constant. */
0225: int GL_CW = 0x0900;
0226: /** OpenGL ES 1.0 constant. */
0227: int GL_CCW = 0x0901;
0228:
0229: // GetPName
0230: /** OpenGL ES 1.0 constant. */
0231: int GL_SMOOTH_POINT_SIZE_RANGE = 0x0B12;
0232: /** OpenGL ES 1.0 constant. */
0233: int GL_SMOOTH_LINE_WIDTH_RANGE = 0x0B22;
0234: /** OpenGL ES 1.0 constant. */
0235: int GL_ALIASED_POINT_SIZE_RANGE = 0x846D;
0236: /** OpenGL ES 1.0 constant. */
0237: int GL_ALIASED_LINE_WIDTH_RANGE = 0x846E;
0238: /** OpenGL ES 1.0 constant. */
0239: int GL_IMPLEMENTATION_COLOR_READ_TYPE_OES = 0x8B9A;
0240: /** OpenGL ES 1.0 constant. */
0241: int GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES = 0x8B9B;
0242: /** OpenGL ES 1.0 constant. */
0243: int GL_MAX_LIGHTS = 0x0D31;
0244: /** OpenGL ES 1.0 constant. */
0245: int GL_MAX_TEXTURE_SIZE = 0x0D33;
0246: /** OpenGL ES 1.0 constant. */
0247: int GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36;
0248: /** OpenGL ES 1.0 constant. */
0249: int GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38;
0250: /** OpenGL ES 1.0 constant. */
0251: int GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39;
0252: /** OpenGL ES 1.0 constant. */
0253: int GL_MAX_VIEWPORT_DIMS = 0x0D3A;
0254: /** OpenGL ES 1.0 constant. */
0255: int GL_MAX_ELEMENTS_VERTICES = 0x80E8;
0256: /** OpenGL ES 1.0 constant. */
0257: int GL_MAX_ELEMENTS_INDICES = 0x80E9;
0258: /** OpenGL ES 1.0 constant. */
0259: int GL_MAX_TEXTURE_UNITS = 0x84E2;
0260: /** OpenGL ES 1.0 constant. */
0261: int GL_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2;
0262: /** OpenGL ES 1.0 constant. */
0263: int GL_COMPRESSED_TEXTURE_FORMATS = 0x86A3;
0264: /** OpenGL ES 1.0 constant. */
0265: int GL_SUBPIXEL_BITS = 0x0D50;
0266: /** OpenGL ES 1.0 constant. */
0267: int GL_RED_BITS = 0x0D52;
0268: /** OpenGL ES 1.0 constant. */
0269: int GL_GREEN_BITS = 0x0D53;
0270: /** OpenGL ES 1.0 constant. */
0271: int GL_BLUE_BITS = 0x0D54;
0272: /** OpenGL ES 1.0 constant. */
0273: int GL_ALPHA_BITS = 0x0D55;
0274: /** OpenGL ES 1.0 constant. */
0275: int GL_DEPTH_BITS = 0x0D56;
0276: /** OpenGL ES 1.0 constant. */
0277: int GL_STENCIL_BITS = 0x0D57;
0278:
0279: // HintMode
0280: /** OpenGL ES 1.0 constant. */
0281: int GL_DONT_CARE = 0x1100;
0282: /** OpenGL ES 1.0 constant. */
0283: int GL_FASTEST = 0x1101;
0284: /** OpenGL ES 1.0 constant. */
0285: int GL_NICEST = 0x1102;
0286:
0287: // HintTarget
0288: /** OpenGL ES 1.0 constant. */
0289: int GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50;
0290: /** OpenGL ES 1.0 constant. */
0291: int GL_POINT_SMOOTH_HINT = 0x0C51;
0292: /** OpenGL ES 1.0 constant. */
0293: int GL_LINE_SMOOTH_HINT = 0x0C52;
0294: /** OpenGL ES 1.0 constant. */
0295: int GL_POLYGON_SMOOTH_HINT = 0x0C53;
0296: /** OpenGL ES 1.0 constant. */
0297: int GL_FOG_HINT = 0x0C54;
0298:
0299: // LightModelParameter
0300: /** OpenGL ES 1.0 constant. */
0301: int GL_LIGHT_MODEL_AMBIENT = 0x0B53;
0302: /** OpenGL ES 1.0 constant. */
0303: int GL_LIGHT_MODEL_TWO_SIDE = 0x0B52;
0304: /** OpenGL ES 1.0 constant. */
0305:
0306: // LightParameter
0307: /** OpenGL ES 1.0 constant. */
0308: int GL_AMBIENT = 0x1200;
0309: /** OpenGL ES 1.0 constant. */
0310: int GL_DIFFUSE = 0x1201;
0311: /** OpenGL ES 1.0 constant. */
0312: int GL_SPECULAR = 0x1202;
0313: /** OpenGL ES 1.0 constant. */
0314: int GL_POSITION = 0x1203;
0315: /** OpenGL ES 1.0 constant. */
0316: int GL_SPOT_DIRECTION = 0x1204;
0317: /** OpenGL ES 1.0 constant. */
0318: int GL_SPOT_EXPONENT = 0x1205;
0319: /** OpenGL ES 1.0 constant. */
0320: int GL_SPOT_CUTOFF = 0x1206;
0321: /** OpenGL ES 1.0 constant. */
0322: int GL_CONSTANT_ATTENUATION = 0x1207;
0323: /** OpenGL ES 1.0 constant. */
0324: int GL_LINEAR_ATTENUATION = 0x1208;
0325: /** OpenGL ES 1.0 constant. */
0326: int GL_QUADRATIC_ATTENUATION = 0x1209;
0327:
0328: // DataType
0329: /** OpenGL ES 1.0 constant. */
0330: int GL_BYTE = 0x1400;
0331: /** OpenGL ES 1.0 constant. */
0332: int GL_UNSIGNED_BYTE = 0x1401;
0333: /** OpenGL ES 1.0 constant. */
0334: int GL_SHORT = 0x1402;
0335: /** OpenGL ES 1.0 constant. */
0336: int GL_UNSIGNED_SHORT = 0x1403;
0337: /** OpenGL ES 1.0 constant. */
0338: int GL_FLOAT = 0x1406;
0339: /** OpenGL ES 1.0 constant. */
0340: int GL_FIXED = 0x140C;
0341:
0342: // LogicOp
0343: /** OpenGL ES 1.0 constant. */
0344: int GL_CLEAR = 0x1500;
0345: /** OpenGL ES 1.0 constant. */
0346: int GL_AND = 0x1501;
0347: /** OpenGL ES 1.0 constant. */
0348: int GL_AND_REVERSE = 0x1502;
0349: /** OpenGL ES 1.0 constant. */
0350: int GL_COPY = 0x1503;
0351: /** OpenGL ES 1.0 constant. */
0352: int GL_AND_INVERTED = 0x1504;
0353: /** OpenGL ES 1.0 constant. */
0354: int GL_NOOP = 0x1505;
0355: /** OpenGL ES 1.0 constant. */
0356: int GL_XOR = 0x1506;
0357: /** OpenGL ES 1.0 constant. */
0358: int GL_OR = 0x1507;
0359: /** OpenGL ES 1.0 constant. */
0360: int GL_NOR = 0x1508;
0361: /** OpenGL ES 1.0 constant. */
0362: int GL_EQUIV = 0x1509;
0363: /** OpenGL ES 1.0 constant. */
0364: int GL_INVERT = 0x150A;
0365: /** OpenGL ES 1.0 constant. */
0366: int GL_OR_REVERSE = 0x150B;
0367: /** OpenGL ES 1.0 constant. */
0368: int GL_COPY_INVERTED = 0x150C;
0369: /** OpenGL ES 1.0 constant. */
0370: int GL_OR_INVERTED = 0x150D;
0371: /** OpenGL ES 1.0 constant. */
0372: int GL_NAND = 0x150E;
0373: /** OpenGL ES 1.0 constant. */
0374: int GL_SET = 0x150F;
0375:
0376: // MaterialParameters
0377: /** OpenGL ES 1.0 constant. */
0378: int GL_EMISSION = 0x1600;
0379: /** OpenGL ES 1.0 constant. */
0380: int GL_SHININESS = 0x1601;
0381: /** OpenGL ES 1.0 constant. */
0382: int GL_AMBIENT_AND_DIFFUSE = 0x1602;
0383:
0384: // MatrixMode
0385: /** OpenGL ES 1.0 constant. */
0386: int GL_MODELVIEW = 0x1700;
0387: /** OpenGL ES 1.0 constant. */
0388: int GL_PROJECTION = 0x1701;
0389: /** OpenGL ES 1.0 constant. */
0390: int GL_TEXTURE = 0x1702;
0391:
0392: // PixelFormat
0393: /** OpenGL ES 1.0 constant. */
0394: int GL_ALPHA = 0x1906;
0395: /** OpenGL ES 1.0 constant. */
0396: int GL_RGB = 0x1907;
0397: /** OpenGL ES 1.0 constant. */
0398: int GL_RGBA = 0x1908;
0399: /** OpenGL ES 1.0 constant. */
0400: int GL_LUMINANCE = 0x1909;
0401: /** OpenGL ES 1.0 constant. */
0402: int GL_LUMINANCE_ALPHA = 0x190A;
0403:
0404: // PixelStoreParameter
0405: /** OpenGL ES 1.0 constant. */
0406: int GL_UNPACK_ALIGNMENT = 0x0CF5;
0407: /** OpenGL ES 1.0 constant. */
0408: int GL_PACK_ALIGNMENT = 0x0D05;
0409:
0410: // PixelType
0411: /** OpenGL ES 1.0 constant. */
0412: int GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033;
0413: /** OpenGL ES 1.0 constant. */
0414: int GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034;
0415: /** OpenGL ES 1.0 constant. */
0416: int GL_UNSIGNED_SHORT_5_6_5 = 0x8363;
0417:
0418: // ShadingModel
0419: /** OpenGL ES 1.0 constant. */
0420: int GL_FLAT = 0x1D00;
0421: /** OpenGL ES 1.0 constant. */
0422: int GL_SMOOTH = 0x1D01;
0423:
0424: // StencilOp
0425: /** OpenGL ES 1.0 constant. */
0426: int GL_KEEP = 0x1E00;
0427: /** OpenGL ES 1.0 constant. */
0428: int GL_REPLACE = 0x1E01;
0429: /** OpenGL ES 1.0 constant. */
0430: int GL_INCR = 0x1E02;
0431: /** OpenGL ES 1.0 constant. */
0432: int GL_DECR = 0x1E03;
0433:
0434: // StringName
0435: /** OpenGL ES 1.0 constant. */
0436: int GL_VENDOR = 0x1F00;
0437: /** OpenGL ES 1.0 constant. */
0438: int GL_RENDERER = 0x1F01;
0439: /** OpenGL ES 1.0 constant. */
0440: int GL_VERSION = 0x1F02;
0441: /** OpenGL ES 1.0 constant. */
0442: int GL_EXTENSIONS = 0x1F03;
0443:
0444: // TextureEnvMode
0445: /** OpenGL ES 1.0 constant. */
0446: int GL_MODULATE = 0x2100;
0447: /** OpenGL ES 1.0 constant. */
0448: int GL_DECAL = 0x2101;
0449: /** OpenGL ES 1.0 constant. */
0450: int GL_ADD = 0x0104;
0451:
0452: // TextureEnvParameter
0453: /** OpenGL ES 1.0 constant. */
0454: int GL_TEXTURE_ENV_MODE = 0x2200;
0455: /** OpenGL ES 1.0 constant. */
0456: int GL_TEXTURE_ENV_COLOR = 0x2201;
0457:
0458: // TextureEnvTarget
0459: /** OpenGL ES 1.0 constant. */
0460: int GL_TEXTURE_ENV = 0x2300;
0461:
0462: // TextureMagFilter
0463: /** OpenGL ES 1.0 constant. */
0464: int GL_NEAREST = 0x2600;
0465: /** OpenGL ES 1.0 constant. */
0466: int GL_LINEAR = 0x2601;
0467:
0468: // TextureMinFilter
0469: /** OpenGL ES 1.0 constant. */
0470: int GL_NEAREST_MIPMAP_NEAREST = 0x2700;
0471: /** OpenGL ES 1.0 constant. */
0472: int GL_LINEAR_MIPMAP_NEAREST = 0x2701;
0473: /** OpenGL ES 1.0 constant. */
0474: int GL_NEAREST_MIPMAP_LINEAR = 0x2702;
0475: /** OpenGL ES 1.0 constant. */
0476: int GL_LINEAR_MIPMAP_LINEAR = 0x2703;
0477:
0478: // TextureParameterName
0479: /** OpenGL ES 1.0 constant. */
0480: int GL_TEXTURE_MAG_FILTER = 0x2800;
0481: /** OpenGL ES 1.0 constant. */
0482: int GL_TEXTURE_MIN_FILTER = 0x2801;
0483: /** OpenGL ES 1.0 constant. */
0484: int GL_TEXTURE_WRAP_S = 0x2802;
0485: /** OpenGL ES 1.0 constant. */
0486: int GL_TEXTURE_WRAP_T = 0x2803;
0487:
0488: // TextureUnit
0489: /** OpenGL ES 1.0 constant. */
0490: int GL_TEXTURE0 = 0x84C0;
0491: /** OpenGL ES 1.0 constant. */
0492: int GL_TEXTURE1 = 0x84C1;
0493: /** OpenGL ES 1.0 constant. */
0494: int GL_TEXTURE2 = 0x84C2;
0495: /** OpenGL ES 1.0 constant. */
0496: int GL_TEXTURE3 = 0x84C3;
0497: /** OpenGL ES 1.0 constant. */
0498: int GL_TEXTURE4 = 0x84C4;
0499: /** OpenGL ES 1.0 constant. */
0500: int GL_TEXTURE5 = 0x84C5;
0501: /** OpenGL ES 1.0 constant. */
0502: int GL_TEXTURE6 = 0x84C6;
0503: /** OpenGL ES 1.0 constant. */
0504: int GL_TEXTURE7 = 0x84C7;
0505: /** OpenGL ES 1.0 constant. */
0506: int GL_TEXTURE8 = 0x84C8;
0507: /** OpenGL ES 1.0 constant. */
0508: int GL_TEXTURE9 = 0x84C9;
0509: /** OpenGL ES 1.0 constant. */
0510: int GL_TEXTURE10 = 0x84CA;
0511: /** OpenGL ES 1.0 constant. */
0512: int GL_TEXTURE11 = 0x84CB;
0513: /** OpenGL ES 1.0 constant. */
0514: int GL_TEXTURE12 = 0x84CC;
0515: /** OpenGL ES 1.0 constant. */
0516: int GL_TEXTURE13 = 0x84CD;
0517: /** OpenGL ES 1.0 constant. */
0518: int GL_TEXTURE14 = 0x84CE;
0519: /** OpenGL ES 1.0 constant. */
0520: int GL_TEXTURE15 = 0x84CF;
0521: /** OpenGL ES 1.0 constant. */
0522: int GL_TEXTURE16 = 0x84D0;
0523: /** OpenGL ES 1.0 constant. */
0524: int GL_TEXTURE17 = 0x84D1;
0525: /** OpenGL ES 1.0 constant. */
0526: int GL_TEXTURE18 = 0x84D2;
0527: /** OpenGL ES 1.0 constant. */
0528: int GL_TEXTURE19 = 0x84D3;
0529: /** OpenGL ES 1.0 constant. */
0530: int GL_TEXTURE20 = 0x84D4;
0531: /** OpenGL ES 1.0 constant. */
0532: int GL_TEXTURE21 = 0x84D5;
0533: /** OpenGL ES 1.0 constant. */
0534: int GL_TEXTURE22 = 0x84D6;
0535: /** OpenGL ES 1.0 constant. */
0536: int GL_TEXTURE23 = 0x84D7;
0537: /** OpenGL ES 1.0 constant. */
0538: int GL_TEXTURE24 = 0x84D8;
0539: /** OpenGL ES 1.0 constant. */
0540: int GL_TEXTURE25 = 0x84D9;
0541: /** OpenGL ES 1.0 constant. */
0542: int GL_TEXTURE26 = 0x84DA;
0543: /** OpenGL ES 1.0 constant. */
0544: int GL_TEXTURE27 = 0x84DB;
0545: /** OpenGL ES 1.0 constant. */
0546: int GL_TEXTURE28 = 0x84DC;
0547: /** OpenGL ES 1.0 constant. */
0548: int GL_TEXTURE29 = 0x84DD;
0549: /** OpenGL ES 1.0 constant. */
0550: int GL_TEXTURE30 = 0x84DE;
0551: /** OpenGL ES 1.0 constant. */
0552: int GL_TEXTURE31 = 0x84DF;
0553:
0554: // TextureWrapMode
0555: /** OpenGL ES 1.0 constant. */
0556: int GL_REPEAT = 0x2901;
0557: /** OpenGL ES 1.0 constant. */
0558: int GL_CLAMP_TO_EDGE = 0x812F;
0559:
0560: // PixelInternalFormat
0561: /** OpenGL ES 1.0 constant. */
0562: int GL_PALETTE4_RGB8_OES = 0x8B90;
0563: /** OpenGL ES 1.0 constant. */
0564: int GL_PALETTE4_RGBA8_OES = 0x8B91;
0565: /** OpenGL ES 1.0 constant. */
0566: int GL_PALETTE4_R5_G6_B5_OES = 0x8B92;
0567: /** OpenGL ES 1.0 constant. */
0568: int GL_PALETTE4_RGBA4_OES = 0x8B93;
0569: /** OpenGL ES 1.0 constant. */
0570: int GL_PALETTE4_RGB5_A1_OES = 0x8B94;
0571: /** OpenGL ES 1.0 constant. */
0572: int GL_PALETTE8_RGB8_OES = 0x8B95;
0573: /** OpenGL ES 1.0 constant. */
0574: int GL_PALETTE8_RGBA8_OES = 0x8B96;
0575: /** OpenGL ES 1.0 constant. */
0576: int GL_PALETTE8_R5_G6_B5_OES = 0x8B97;
0577: /** OpenGL ES 1.0 constant. */
0578: int GL_PALETTE8_RGBA4_OES = 0x8B98;
0579: /** OpenGL ES 1.0 constant. */
0580: int GL_PALETTE8_RGB5_A1_OES = 0x8B99;
0581:
0582: // LightName
0583: /** OpenGL ES 1.0 constant. */
0584: int GL_LIGHT0 = 0x4000;
0585: /** OpenGL ES 1.0 constant. */
0586: int GL_LIGHT1 = 0x4001;
0587: /** OpenGL ES 1.0 constant. */
0588: int GL_LIGHT2 = 0x4002;
0589: /** OpenGL ES 1.0 constant. */
0590: int GL_LIGHT3 = 0x4003;
0591: /** OpenGL ES 1.0 constant. */
0592: int GL_LIGHT4 = 0x4004;
0593: /** OpenGL ES 1.0 constant. */
0594: int GL_LIGHT5 = 0x4005;
0595: /** OpenGL ES 1.0 constant. */
0596: int GL_LIGHT6 = 0x4006;
0597: /** OpenGL ES 1.0 constant. */
0598: int GL_LIGHT7 = 0x4007;
0599:
0600: /**
0601: * Select server-side active texture unit.
0602: *
0603: * <p><code>glActiveTexture</code> selects which texture unit
0604: * subsequent texture state calls will affect. The number of texture
0605: * units an implementation supports is implementation dependent, it
0606: * must be at least 1 for OpenGL ES 1.0, or 2 for OpenGL ES 1.1.
0607: *
0608: * <h4>Notes</h4>
0609: *
0610: * <p>It is always the case that <code>GL_TEXTURE</code><i>i</i> =
0611: * <code>GL_TEXTURE0</code> + <i>i</i>.
0612: *
0613: * <p>A texture unit consists of the texture enable state, texture
0614: * matrix stack, texture environment and currently bound
0615: * texture. Modifying any of these states has an effect only on the
0616: * active texture unit.
0617: *
0618: * <p>Vertex arrays are client-side GL resources, which are selected by
0619: * the <code>glClientActiveTexture</code> routine.
0620: *
0621: * <h4>Errors</h4>
0622: *
0623: * <p><code>GL_INVALID_ENUM</code> is generated if
0624: * <code>texture</code> is not one of
0625: * <code>GL_TEXTURE</code><i>i</i>, where <code>0 <= <i>i</i> <
0626: * GL_MAX_TEXTURE_UNITS</code>.
0627: *
0628: * <h4>Associated Gets</h4>
0629: *
0630: * <p><code>glGetIntegerv</code> with argument
0631: * <code>GL_MAX_TEXTURE_UNITS</code>.
0632: *
0633: * @param texture Specifies which texture unit to make active. The
0634: * number of texture units is implementation dependent, but must be
0635: * at least one (for 1.0) or two (for 1.1). <code>texture</code>
0636: * must be one of <code>GL_TEXTURE</code><i>i</i>, where <code>0 <=
0637: * <i>i</i> < GL_MAX_TEXTURE_UNITS</code>, which is an
0638: * implementation-dependent value. The intial value is
0639: * <code>GL_TEXTURE0</code>.
0640: *
0641: */
0642: void glActiveTexture(int texture);
0643:
0644: /**
0645: * Specify the alpha test function.
0646: *
0647: * <p>The alpha test discards fragments depending on the outcome of a
0648: * comparison between an incoming fragment's alpha value and a
0649: * constant reference value. <code>glAlphaFunc</code> specifies the
0650: * reference value and the comparison function. The comparison is
0651: * performed only if alpha testing is enabled. To enable and disable
0652: * alpha testing, call <code>glEnable</code> and
0653: * <code>glDisable</code> with argument
0654: * <code>GL_ALPHA_TEST</code>. Alpha testing is initially disabled.
0655: *
0656: * <p><code>func</code> and <code>ref</code> specify the conditions
0657: * under which the pixel is drawn. The incoming alpha value is
0658: * compared to <code>ref</code> using the function specified by
0659: * <code>func</code>. If the value passes the comparison, the
0660: * incoming fragment is drawn if it also passes subsequent stencil
0661: * and depth buffer tests. If the value fails the comparison, no
0662: * change is made to the frame buffer at that pixel location. The
0663: * comparison functions are as follows:
0664: *
0665: * <ul>
0666: * <li><code>GL_NEVER</code></li>
0667: * Never passes.
0668: * <li><code>GL_LESS</code></li>
0669: * Passes if the incoming alpha value is less than the reference value.
0670: * <li><code>GL_EQUAL</code></li>
0671: * Passes if the incoming alpha value is equal to the reference value.
0672: * <li><code>GL_LEQUAL</code></li>
0673: * Passes if the incoming alpha value is less than or equal to the
0674: * reference value.
0675: * <li><code>GL_GREATER</code></li>
0676: * Passes if the incoming alpha value is greater than the reference value.
0677: * <li><code>GL_NOTEQUAL</code></li>
0678: * Passes if the incoming alpha value is not equal to the reference value.
0679: * <li><code>GL_GEQUAL</code></li>
0680: * Passes if the incoming alpha value is greater than or equal to
0681: * the reference value.
0682: * <li><code>GL_ALWAYS</code></li>
0683: * Always passes (initial value).
0684: * </ul>
0685: *
0686: * <p><code>glAlphaFunc</code> operates on all pixel write
0687: * operations, including those resulting from the scan conversion of
0688: * points, lines, and polygons. <code>glAlphaFunc</code> does not
0689: * affect <code>glClear</code>.
0690: *
0691: * <h4>Errors</h4>
0692: *
0693: * <p><code>GL_INVALID_ENUM</code> is generated if <code>func</code>
0694: * is not an accepted value.
0695: *
0696: * @param func Specifies the alpha comparison function. Symbolic
0697: * constants <code>GL_NEVER</code>, <code>GL_LESS</code>,
0698: * <code>GL_EQUAL</code>, <code>GL_LEQUAL</code>,
0699: * <code>GL_GREATER</code>, <code>GL_NOTEQUAL</code>,
0700: * <code>GL_GEQUAL</code>, and <code>GL_ALWAYS</code> are accepted. The
0701: * initial value is <code>GL_ALWAYS</code>.
0702: * @param ref Specifies the reference value that incoming alpha
0703: * values are compared to. This value is clamped to the range
0704: * <code>[0, 1]</code>, where 0 represents the lowest possible alpha
0705: * value and 1 the highest possible value. The initial reference
0706: * value is 0.
0707: */
0708: void glAlphaFunc(int func, float ref);
0709:
0710: /**
0711: * Fixed-point version of <code>glAlphaFunc</code>.
0712: *
0713: * @see #glAlphaFunc
0714: */
0715: void glAlphaFuncx(int func, int ref);
0716:
0717: /**
0718: * Bind a named texture to a texturing target.
0719: *
0720: * <p><code>glBindTexture</code> lets you create or use a named
0721: * texture. Calling <code>glBindTexture</code> with
0722: * <code>target</code> set to <code>GL_TEXTURE_2D</code>, and
0723: * <code>texture</code> set to the name of the new texture binds the
0724: * texture name to the target. When a texture is bound to a target,
0725: * the previous binding for that target is automatically broken.
0726: *
0727: * <p>Texture names are unsigned integers. The value 0 is reserved
0728: * to represent the default texture for each texture target. Texture
0729: * names and the corresponding texture contents are local to the
0730: * shared texture-object space (see <code>eglCreateContext</code>)
0731: * of the current GL rendering context.
0732: *
0733: * <p>You may use <code>glGenTextures</code> to generate a set of new
0734: * texture names.
0735: *
0736: * <p>While a texture is bound, GL operations on the target to which it
0737: * is bound affect the bound texture. If texture mapping of the
0738: * dimensionality of the target to which a texture is bound is
0739: * active, the bound texture is used. In effect, the texture targets
0740: * become aliases for the textures currently bound to them, and the
0741: * texture name 0 refers to the default textures that were bound to
0742: * them at initialization.
0743: *
0744: * <p>A texture binding created with <code>glBindTexture</code> remains
0745: * active until a different texture is bound to the same target, or
0746: * until the bound texture is deleted with
0747: * <code>glDeleteTextures</code>.
0748: *
0749: * <p>Once created, a named texture may be re-bound to the target of
0750: * the matching dimensionality as often as needed. It is usually
0751: * much faster to use <code>glBindTexture</code> to bind an existing named
0752: * texture to one of the texture targets than it is to reload the
0753: * texture image using <code>glTexImage2D</code>.
0754: *
0755: * <h4>Errors</h4>
0756: *
0757: * <p><code>GL_INVALID_ENUM</code> is generated if
0758: * <code>target</code> is not one of the allowable values.
0759: *
0760: * @param target Specifies the target to which the texture is
0761: * bound. Must be <code>GL_TEXTURE_2D</code>.
0762: * @param texture Specifies the name of a texture.
0763: */
0764: void glBindTexture(int target, int texture);
0765:
0766: /**
0767: * Specify pixel arithmetic.
0768: *
0769: * <p>Pixels can be drawn using a function that blends the incoming
0770: * (source) values with the values that are already in the color
0771: * buffer (the destination values). Use <code>glEnable</code> and
0772: * <code>glDisable</code> with argument <code>GL_BLEND</code> to
0773: * enable and disable blending. Blending is initially disabled.
0774: *
0775: * <p><code>glBlendFunc</code> defines the operation of blending
0776: * when it is enabled. <code>sfactor</code> specifies which of eleven
0777: * methods is used to scale the source color
0778: * components. <code>dfactor</code> specifies which of ten methods
0779: * is used to scale the destination color components. The eleven
0780: * possible methods are described in the following table. Each
0781: * method defines four scale factors, one each for red, green, blue,
0782: * and alpha.
0783: *
0784: * <p>In the table and in subsequent equations, source and
0785: * destination color components are referred to as <code>(Rs, Gs,
0786: * Bs, As)</code> and <code>(Rd, Gd, Bd, Ad)</code>. They are
0787: * understood to have integer values between 0 and <code>(kR, kG,
0788: * kB, kA)</code>, where
0789: *
0790: * <pre>
0791: * kc = 2mc - 1
0792: * </pre>
0793: *
0794: * and <code>(mR, mG, mB, mA)</code> is the number of red, green,
0795: * blue, and alpha bitplanes.
0796: *
0797: * <p>Source and destination scale factors are referred to as
0798: * <code>(sR, sG, sB, sA)</code> and <code>(dR, dG, dB,
0799: * dA)</code>. The scale factors described in the table, denoted
0800: * <code>(fR, fG, fB, fA)</code>, represent either source or
0801: * destination factors. All scale factors have range [0, 1].
0802: *
0803: * <pre>
0804: * Parameter (fR, fG, fB, fA)
0805: *
0806: * GL_ZERO (0, 0, 0, 0)
0807: * GL_ONE (1, 1, 1, 1)
0808: * GL_SRC_COLOR (Rs/kR, Gs/kG, Bs/kB, As/kA )
0809: * GL_ONE_MINUS_SRC_COLOR (1, 1, 1, 1) - (Rs/kR, Gs/kG, Bs/kB, As/kA)
0810: * GL_DST_COLOR (Rd/kR, Gd/kG, Bd/kB, Ad/kA )
0811: * GL_ONE_MINUS_DST_COLOR (1, 1, 1, 1) - (Rd/kR, Gd/kG, Bd/kB, Ad/kA)
0812: * GL_SRC_ALPHA (As/kA, As/kA, As/kA, As/kA )
0813: * GL_ONE_MINUS_SRC_ALPHA (1, 1, 1, 1) - (As/kA, As/kA, As/kA, As/kA)
0814: * GL_DST_ALPHA (Ad/kA, Ad/kA, Ad/kA, Ad/kA )
0815: * GL_ONE_MINUS_DST_ALPHA (1, 1, 1, 1) - (Ad/kA, Ad/kA, Ad/kA, Ad/kA)
0816: * GL_SRC_ALPHA_SATURATE (i, i, i, 1)
0817: * </pre>
0818: *
0819: * <p>In the table,
0820: *
0821: * <pre>
0822: * i = min(As, kA - Ad) / kA
0823: * </pre>
0824: *
0825: * <p>To determine the blended values of a pixel, the system uses the
0826: * following equations:
0827: *
0828: * <pre>
0829: * Rd = min( kR, Rs sR + Rd dR )
0830: * Gd = min( kG, Gs sG + Gd dG )
0831: * Bd = min( kB, Bs sB + Bd dB )
0832: * Ad = min( kA, As sA + Ad dA )
0833: * </pre>
0834: *
0835: * <p>Despite the apparent precision of the above equations,
0836: * blending arithmetic is not exactly specified, because blending
0837: * operates with imprecise integer color values. However, a blend
0838: * factor that should be equal to 1 is guaranteed not to modify its
0839: * multiplicand, and a blend factor equal to 0 reduces its
0840: * multiplicand to 0. For example, when <code>sfactor</code> is
0841: * <code>GL_SRC_ALPHA</code>, <code>dfactor</code> is
0842: * <code>GL_ONE_MINUS_SRC_ALPHA</code>, and <code>As</code> is equal
0843: * to <code>kA</code>, the equations reduce to simple replacement:
0844: *
0845: * <pre>
0846: * Rd = Rs
0847: * Gd = Gs
0848: * Bd = Bs
0849: * Ad = As
0850: * </pre>
0851: *
0852: * <p><code>glBlendFunc</code> operates on all pixel write
0853: * operations, including the scan conversion of points, lines, and
0854: * polygons. <code>glBlendFunc</code> does not affect
0855: * <code>glClear</code>.
0856: *
0857: * <h4>Examples</h4>
0858: *
0859: * <p>Transparency is best implemented using
0860: * <code>glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)</code> with
0861: * primitives sorted from farthest to nearest. Note that this
0862: * transparency calculation does not require the presence of alpha
0863: * bitplanes in the color buffer.
0864: *
0865: * <p><code>glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)</code> is
0866: * also useful for rendering antialiased points and lines.
0867: *
0868: * <h4>Notes</h4> Incoming (source) alpha is correctly thought of as
0869: * a material opacity, ranging from 1.0 (kA), representing complete
0870: * opacity, to 0.0 (0), representing complete transparency.
0871: *
0872: * <h4>Errors</h4>
0873: *
0874: * <p><code>GL_INVALID_ENUM</code> is generated if either
0875: * <code>sfactor</code> or <code>dfactor</code> is not an accepted
0876: * value.
0877: *
0878: * @param sfactor Specifies how the red, green, blue, and alpha
0879: * source blending factors are computed. The following symbolic
0880: * constants are accepted: <code>GL_ZERO</code>,
0881: * <code>GL_ONE</code>, <code>GL_SRC_COLOR</code> (1.1 only),
0882: * <code>GL_ONE_MINUS_SRC_COLOR</code> (1.1 only),
0883: * <code>GL_DST_COLOR</code>, <code>GL_ONE_MINUS_DST_COLOR</code>,
0884: * <code>GL_SRC_ALPHA</code>, <code>GL_ONE_MINUS_SRC_ALPHA</code>,
0885: * <code>GL_DST_ALPHA</code>, <code>GL_ONE_MINUS_DST_ALPHA</code>,
0886: * and <code>GL_SRC_ALPHA_SATURATE</code>. The initial value is
0887: * <code>GL_ONE</code>.
0888: * @param dfactor Specifies how the red, green, blue, and alpha
0889: * destination blending factors are computed. The following symbolic
0890: * constants are accepted: <code>GL_ZERO</code>,
0891: * <code>GL_ONE</code>, <code>GL_SRC_COLOR</code>,
0892: * <code>GL_ONE_MINUS_SRC_COLOR</code>, <code>GL_DST_COLOR</code>
0893: * (1.1 only), <code>GL_ONE_MINUS_DST_COLOR</code> (1.1 only),
0894: * <code>GL_SRC_ALPHA</code>, <code>GL_ONE_MINUS_SRC_ALPHA</code>,
0895: * <code>GL_DST_ALPHA</code>, and
0896: * <code>GL_ONE_MINUS_DST_ALPHA</code>. The initial value is
0897: * <code>GL_ZERO</code>.
0898: */
0899: void glBlendFunc(int sfactor, int dfactor);
0900:
0901: /**
0902: * Clear buffers to preset values.
0903: *
0904: * <p><code>glClear</code> sets the bitplane area of the window to
0905: * values previously selected by <code>glClearColor</code>,
0906: * <code>glClearDepth</code>, and <code>glClearStencil</code>.
0907: *
0908: * <p>The pixel ownership test, the scissor test, dithering, and the
0909: * color buffer masks affect the operation of
0910: * <code>glClear</code>. The scissor box bounds the cleared
0911: * region. Alpha function, blend function, logical operation,
0912: * stenciling, texture mapping, and depth-buffering are ignored by
0913: * <code>glClear</code>.
0914: *
0915: * <p><code>glClear</code> takes a single argument that is the
0916: * bitwise OR of several values indicating which buffer is to be
0917: * cleared.
0918: *
0919: * <p>The values are as follows:
0920: *
0921: * <ul>
0922: * <li><code>GL_COLOR_BUFFER_BIT</code></li>
0923: * Indicates the color buffer.
0924: * <li><code>GL_DEPTH_BUFFER_BIT</code></li>
0925: * Indicates the depth buffer.
0926: * <li><code>GL_STENCIL_BUFFER_BIT</code></li>
0927: * Indicates the stencil buffer.
0928: * </ul>
0929: *
0930: * <p>The value to which each buffer is cleared depends on the
0931: * setting of the clear value for that buffer.
0932: *
0933: * <h4>Notes</h4>
0934: *
0935: * <p>If a buffer is not present, then a <code>glClear</code>
0936: * directed at that buffer has no effect.
0937: *
0938: * <h4>Errors</h4>
0939: *
0940: * <p><code>GL_INVALID_VALUE</code> is generated if any bit other
0941: * than the defined bits is set in <code>mask</code>.
0942: *
0943: * @param mask Bitwise OR of masks that indicate the buffers to be
0944: * cleared. Valid masks are <code>GL_COLOR_BUFFER_BIT</code>,
0945: * <code>GL_DEPTH_BUFFER_BIT</code>, and <code>GL_STENCIL_BUFFER_BIT</code>.
0946: */
0947: void glClear(int mask);
0948:
0949: /**
0950: * Specify clear values for the color buffer.
0951: *
0952: * <p><code>glClearColor</code> specifies the red, green, blue, and
0953: * alpha values used by <code>glClear</code> to clear the color
0954: * buffer. Values specified by <code>glClearColor</code> are clamped
0955: * to the range <code>[0, 1]</code>.
0956: *
0957: * @param red Specifies the red value used when the color buffer is
0958: * cleared. The initial value is 0.
0959: * @param green Specifies the green value used when the color buffer
0960: * is cleared. The initial value is 0.
0961: * @param blue Specifies the blue value used when the color buffer is
0962: * cleared. The initial value is 0.
0963: * @param alpha Specifies the alpha value used when the color buffer
0964: * is cleared. The initial value is 0.
0965: */
0966: void glClearColor(float red, float green, float blue, float alpha);
0967:
0968: /**
0969: * Fixed-point version of <code>glClearColor</code>.
0970: *
0971: * @see #glClearColor
0972: */
0973: void glClearColorx(int red, int green, int blue, int alpha);
0974:
0975: /**
0976: * Specify the clear value for the depth buffer.
0977: *
0978: * <p><code>glClearDepth</code> specifies the depth value used by
0979: * <code>glClear</code> to clear the depth buffer. Values specified
0980: * by <code>glClearDepth</code> are clamped to the range <code>[0, 1]</code>.
0981: *
0982: * @param depth Specifies the depth value used when the depth buffer
0983: * is cleared. The initial value is 1.
0984: */
0985: void glClearDepthf(float depth);
0986:
0987: /**
0988: * Fixed-point version of <code>glClearDepth</code>.
0989: *
0990: * @see #glClearDepthf
0991: */
0992: void glClearDepthx(int depth);
0993:
0994: /**
0995: * Specify the clear value for the stencil buffer.
0996: *
0997: * <p><code>glClearStencil</code> specifies the index used by
0998: * <code>glClear</code> to clear the stencil buffer. <code>s</code>
0999: * is masked with 2^<i>m</i> - 1, where <i>m</i> is the number of
1000: * bits in the stencil buffer.
1001: *
1002: * <h4>Associated Gets</h4>
1003: *
1004: * <p><code>glGetIntegerv</code> with argument
1005: * <code>GL_STENCIL_BITS</code>
1006: *
1007: * @param s Specifies the index used when the stencil buffer is
1008: * cleared. The initial value is 0.
1009: */
1010: void glClearStencil(int s);
1011:
1012: /**
1013: * Select client-side active texture unit.
1014: *
1015: * <p><code>glClientActiveTexture</code> selects the vertex array
1016: * client state parameters to be modified by
1017: * <code>glTexCoordPointer</code>, and enabled or disabled with
1018: * <code>glEnableClientState</code> or
1019: * <code>glDisableClientState</code>, respectively, when called with
1020: * a parameter of <code>GL_TEXTURE_COORD_ARRAY</code>.
1021: *
1022: * <h4>Notes</h4>
1023: *
1024: * <p>It is always the case that <code>GL_TEXTURE</code><i>i</i> =
1025: * <code>GL_TEXTURE0</code> + <i>i</i>.
1026: *
1027: * <h4>Errors</h4>
1028: *
1029: * <p><code>GL_INVALID_ENUM</code> is generated if
1030: * <code>texture</code> is not one of
1031: * <code>GL_TEXTURE</code><i>i</i>, where <code>0 <= <i>i</i> <
1032: * GL_MAX_TEXTURE_UNITS</code>.
1033: *
1034: * <h4>Associated Gets</h4>
1035: *
1036: * <p><code>glGetIntegerv</code> with argument
1037: * <code>GL_MAX_TEXTURE_UNITS</code>
1038: *
1039: * @param texture Specifies which texture unit to make active. The
1040: * number of texture units is implementation dependent, but must be
1041: * at least one (for 1.0), or two (for 1.1). <code>texture</code>
1042: * must be one of <code>GL_TEXTURE</code><i>i</i>, <code>0 <=
1043: * <i>i</i> < GL_MAX_TEXTURE_UNITS</code>, which is an
1044: * implementation-dependent value. The initial value is
1045: * <code>GL_TEXTURE0</code>.
1046: */
1047: void glClientActiveTexture(int texture);
1048:
1049: /**
1050: * Set the current color.
1051: *
1052: * <p>The GL stores a current four-valued RGBA
1053: * color. <code>glColor</code> sets a new four-valued RGBA color.
1054: *
1055: * <p>Current color values are stored in fixed-point or
1056: * floating-point. In case the values are stored in floating-point,
1057: * the mantissa and exponent sizes are unspecified.
1058: *
1059: * <p>Neither fixed-point nor floating-point values are clamped to
1060: * the range <code>[0, 1]</code> before the current color is
1061: * updated. However, color components are clamped to this range
1062: * before they are interpolated or written into the color buffer.
1063: *
1064: * @param red Specifies a new red value for the current color. The
1065: * initial value is 1.
1066: * @param green Specifies a new green value for the current color. The
1067: * initial value is 1.
1068: * @param blue Specifies a new blue value for the current color. The
1069: * initial value is 1.
1070: * @param alpha Specifies a new alpha value for the current color. The
1071: * initial value is 1.
1072: */
1073: void glColor4f(float red, float green, float blue, float alpha);
1074:
1075: /**
1076: * Fixed-point version of <code>glColor</code>.
1077: *
1078: * @see #glColor4f
1079: */
1080: void glColor4x(int red, int green, int blue, int alpha);
1081:
1082: /**
1083: * Enable and disable writing of color buffer components.
1084: *
1085: * <p><code>glColorMask</code> specifies whether the individual
1086: * components in the color buffer can or cannot be written. If
1087: * <code>red</code> is <code>false</code>, for example, no change
1088: * is made to the red component of any pixel in the color buffer,
1089: * regardless of the drawing operation attempted, including
1090: * <code>glClear</code>.
1091: *
1092: * <p>Changes to individual bits of components cannot be
1093: * controlled. Rather, changes are either enabled or disabled for
1094: * entire color components.
1095: *
1096: * @param red Specifies whether red can or cannot be written into
1097: * the color buffer. The initial value is <code>true</code>, indicating
1098: * that the color component can be written.
1099: * @param green Specifies whether green can or cannot be written into
1100: * the color buffer. The initial value is <code>true</code>, indicating
1101: * that the color component can be written.
1102: * @param blue Specifies whether blue can or cannot be written into
1103: * the color buffer. The initial value is <code>true</code>, indicating
1104: * that the color component can be written.
1105: * @param alpha Specifies whether alpha can or cannot be written
1106: * into the color buffer. The initial value is <code>true</code>,
1107: * indicating that the color component can be written.
1108: */
1109: void glColorMask(boolean red, boolean green, boolean blue,
1110: boolean alpha);
1111:
1112: /**
1113: * Define an array of colors.
1114: *
1115: * <p><code>glColorPointer</code> specifies an array of color
1116: * components to use when rendering. <code>size</code> specifies the
1117: * number of components per color, and must be 4. <code>type</code>
1118: * specifies the data type of each color component, and
1119: * <code>stride</code> specifies the byte stride from one color to
1120: * the next allowing vertices and attributes to be packed into a
1121: * single array or stored in separate arrays. (Single-array storage
1122: * may be more efficient on some implementations.)
1123: *
1124: * <p>When a color array is specified, <code>size</code>,
1125: * <code>type</code>, <code>stride</code>, and <code>pointer</code>
1126: * are saved as client-side state.
1127: *
1128: * <p>If the color array is enabled, it is used when
1129: * <code>glDrawArrays</code>, or <code>glDrawElements</code> is
1130: * called. To enable and disable the color array, call
1131: * <code>glEnableClientState</code> and
1132: * <code>glDisableClientState</code> with the argument
1133: * <code>GL_COLOR_ARRAY</code>. The color array is initially
1134: * disabled and isn't accessed when <code>glDrawArrays</code> or
1135: * <code>glDrawElements</code> is called.
1136: *
1137: * <p>Use <code>glDrawArrays</code> to construct a sequence of
1138: * primitives (all of the same type) from prespecified vertex and
1139: * vertex attribute arrays. Use <code>glDrawElements</code> to
1140: * construct a sequence of primitives by indexing vertices and
1141: * vertex attributes.
1142: *
1143: * <p>Setting <code>pointer</code> to <code>null</code> releases any
1144: * previously set <code>Buffer</code>.
1145: *
1146: * <h4>Notes</h4>
1147: *
1148: * <p><code>glColorPointer</code> is typically implemented on the
1149: * client side.
1150: *
1151: * <h4>Errors</h4>
1152: *
1153: * <p><code>GL_INVALID_VALUE</code> is generated if
1154: * <code>size</code> is not 4.
1155: *
1156: * <p><code>GL_INVALID_ENUM</code> is generated if <code>type</code>
1157: * is not an accepted value.
1158: *
1159: * <p><code>GL_INVALID_VALUE</code> is generated if
1160: * <code>stride</code> is negative.
1161: *
1162: * <p> The <code>pointer</code> argument must be a direct buffer
1163: * with a type matching that specified by the <code>type</code>
1164: * argument.
1165: *
1166: * @param size Specifies the number of components per color. Must be
1167: * 4. The initial value is 4.
1168: * @param type Specifies the data type of each color component in
1169: * the array. Symbolic constants <code>GL_UNSIGNED_BYTE</code>,
1170: * <code>GL_FIXED</code>, and <code>GL_FLOAT</code> are
1171: * accepted. The initial value is <code>GL_FLOAT</code>.
1172: * @param stride Specifies the byte offset between consecutive
1173: * colors. If <code>stride</code> is 0, the colors are understood to
1174: * be tightly packed in the array. The initial value is 0.
1175: * @param pointer Specifies a <code>Buffer</code> containing the
1176: * colors.
1177: *
1178: * @exception IllegalStateException if OpenGL ES 1.1 is being used and
1179: * VBOs are enabled.
1180: * @exception IllegalArgumentException if <code>pointer</code> is
1181: * <code>null</code>.
1182: * @exception IllegalArgumentException if <code>pointer</code> is
1183: * not direct.
1184: */
1185: void glColorPointer(int size, int type, int stride, Buffer pointer);
1186:
1187: /**
1188: * Specify a two-dimensional compressed texture image.
1189: *
1190: * <p><code>glCompressedTexImage2D</code> defines a two-dimensional
1191: * texture image in compressed format.
1192: *
1193: * <p>The supported compressed formats are paletted textures. The
1194: * layout of the compressed image is a palette followed by multiple
1195: * mip-levels of texture indices used for lookup into the
1196: * palette. The palette format can be one of <code>R5_G6_B5</code>,
1197: * <code>RGBA4</code>, <code>RGB5_A1</code>, <code>RGB8</code>, or
1198: * <code>RGBA8</code>. The texture indices can have a resolution of
1199: * 4 or 8 bits. As a result, the number of palette entries is either
1200: * 16 or 256. If level is 0, only one mip-level of texture indices
1201: * is described in data. Otherwise, the negative value of level
1202: * specifies up to which mip-level the texture indices are
1203: * described. A possibly remaining pad nibble (half byte) for the
1204: * lowest resolution mip-level is ignored.
1205: *
1206: * <h4>Notes</h4>
1207: *
1208: * <p><code>glPixelStore</code> has no effect on compressed texture
1209: * images.
1210: *
1211: * <p><code>glCompressedTexImage2D</code> specifies the
1212: * two-dimensional texture for the currently bound texture,
1213: * specified with <code>glBindTexture</code>, and the current
1214: * texture unit, specified with <code>glActiveTexture</code>.
1215: *
1216: * <h4>Errors</h4>
1217: *
1218: * <p><code>GL_INVALID_ENUM</code> is generated if
1219: * <code>target</code> is not <code>GL_TEXTURE_2D</code>.
1220: *
1221: * <p><code>GL_INVALID_VALUE</code> may be generated if
1222: * <code>level</code> is greater than 0 or the absolute value of
1223: * level is greater than log_2(<i>max</i>), where <i>max</i> is the
1224: * returned value of <code>GL_MAX_TEXTURE_SIZE</code>.
1225: *
1226: * <p>(1.0) <code>GL_INVALID_VALUE</code> is generated if
1227: * <code>internalformat</code> is not one of the accepted symbolic
1228: * constants.
1229: *
1230: * <p>(1.1) <code>GL_INVALID_ENUM</code> is generated if
1231: * <code>internalformat</code> is not one of the accepted symbolic
1232: * constants.
1233: *
1234: * <p><code>GL_INVALID_VALUE</code> is generated if
1235: * <code>width</code> or <code>height</code> is less than 0 or
1236: * greater than 2 + <code>GL_MAX_TEXTURE_SIZE</code>, or if either
1237: * cannot be represented as 2^<i>k</i> + 2*<code>border</code> for
1238: * some integer <i>k</i>.
1239: *
1240: * <p><code>GL_INVALID_VALUE</code> is generated if
1241: * <code>border</code> is not 0.
1242: *
1243: * <p><code>GL_INVALID_VALUE</code> is generated if
1244: * <code>imageSize</code> is not consistent with format, dimentions,
1245: * and contents of the compressed image.
1246: *
1247: * @param target Specifies the target texture. Must be
1248: * <code>GL_TEXTURE_2D</code>.
1249: * @param level Specifies the level-of-detail number. Must be less
1250: * than or equal to 0. Level 0 indicates a single
1251: * mip-level. Negative values indicate how many mip-levels are
1252: * described by data.
1253: * @param internalformat Specifies the color components in the
1254: * texture. The following symbolic constants are accepted:
1255: * <code>GL_PALETTE4_RGB8_OES</code>,
1256: * <code>GL_PALETTE4_RGBA8_OES</code>,
1257: * <code>GL_PALETTE4_R5_G6_B5_OES</code>,
1258: * <code>GL_PALETTE4_RGBA4_OES</code>,
1259: * <code>GL_PALETTE4_RGB5_A1_OES</code>,
1260: * <code>GL_PALETTE8_RGB8_OES</code>,
1261: * <code>GL_PALETTE8_RGBA8_OES</code>,
1262: * <code>GL_PALETTE8_R5_G6_B5_OES</code>,
1263: * <code>GL_PALETTE8_RGBA4_OES</code>, and
1264: * <code>GL_PALETTE8_RGB5_A1_OES</code>.
1265: * @param width Specifies the width of the texture image. Must be
1266: * 2^<i>n</i> + 2*<code>border</code> for some integer <i>n</i>. All
1267: * implementations support texture images that are at least 64
1268: * texels wide.
1269: * @param height Specifies the height of the texture image. Must be
1270: * 2^<i>m</i> + 2*<code>border</code> for some integer <i>m</i>. All
1271: * implementations support texture images that are at least 64
1272: * texels high.
1273: * @param border Specifies the width of the border. Must be 0.
1274: * @param imageSize Specifies the size of the compressed image data
1275: * in bytes.
1276: * @param data Specifies a <code>Buffer</code> containing the
1277: * compressed image data.
1278: *
1279: * @exception IllegalArgumentException if <code>data</code> is
1280: * <code>null</code>.
1281: * @exception IllegalArgumentException if
1282: * <code>data.remaining()</code> is less than
1283: * <code>imageSize</code>.
1284: */
1285: void glCompressedTexImage2D(int target, int level,
1286: int internalformat, int width, int height, int border,
1287: int imageSize, Buffer data);
1288:
1289: /**
1290: * Specify a two-dimensional compressed texture subimage.
1291: *
1292: * <p><code>glCompressedTexSubImage2D</code> redefines a contiguous
1293: * subregion of an existing two-dimensional compressed texture
1294: * image. The texels referenced by <code>pixels</code> replace the
1295: * portion of the existing texture array with x indices
1296: * <code>xoffset</code> and <code>xoffset</code> +
1297: * <code>width</code> - 1, inclusive, and y indices
1298: * <code>yoffset</code> and <code>yoffset</code> +
1299: * <code>height</code> - 1, inclusive. This region may not include
1300: * any texels outside the range of the texture array as it was
1301: * originally specified. It is not an error to specify a subtexture
1302: * with zero width or height, but such a specification has no
1303: * effect.
1304: *
1305: * <p>Currently, there is no supported compressed format for this
1306: * function.
1307: *
1308: * <h4>Notes</h4>
1309: *
1310: * <p><code>glPixelStore</code> has no effect on compressed texture
1311: * images.
1312: *
1313: * <p><code>glCompressedTexSubImage2D</code> specifies the
1314: * two-dimensional sub texture for the currently bound texture,
1315: * specified with <code>glBindTexture</code>, and the current
1316: * texture unit, specified with <code>glActiveTexture</code>.
1317: *
1318: * <h4>Errors</h4>
1319: *
1320: * <p><code>GL_INVALID_ENUM</code> is generated if
1321: * <code>target</code> is not <code>GL_TEXTURE_2D</code>.
1322: *
1323: * <p><code>GL_INVALID_OPERATION</code> is generated if the texture
1324: * array has not been defined by a previous
1325: * <code>glCompressedTexImage2D</code> operation.
1326: *
1327: * <p><code>GL_INVALID_VALUE</code> is generated if
1328: * <code>level</code> is less than 0.
1329: *
1330: * <p><code>GL_INVALID_VALUE</code> may be generated if
1331: * <code>level</code> is greater than log2(<i>max</i>), where
1332: * <i>max</i> is the returned value of
1333: * <code>GL_MAX_TEXTURE_SIZE</code>.
1334: *
1335: * <p><code>GL_INVALID_VALUE</code> is generated if
1336: * <code>xoffset</code> < <i>-b</i>, <code>xoffset</code> + width >
1337: * (<i>w - b</i>), <code>yoffset</code> < <i>-b</i>, or
1338: * <code>yoffset</code> + <code>height</code> > (<i>h</i> - <i>b</i>)
1339: * , where <i>w</i> is the texture width, <i>h</i> is the texture
1340: * height, and <i>b</i> is the border of the texture image being
1341: * modified. Note that <i>w</i> and <i>h</i> include twice the
1342: * border width.
1343: *
1344: * <p><code>GL_INVALID_VALUE</code> is generated if
1345: * <code>width</code> or <code>height</code> is less than 0.
1346: *
1347: * <p><code>GL_INVALID_ENUM</code> is generated if <code>type</code>
1348: * is not a type constant.
1349: *
1350: * <p><code>GL_INVALID_OPERATION</code> is generated if type
1351: * <code>is</code> <code>GL_UNSIGNED_SHORT_5_6_5</code> and
1352: * <code>format</code> is not <code>GL_RGB</code>.
1353: *
1354: * <p><code>GL_INVALID_OPERATION</code> is generated if
1355: * <code>type</code> is one of
1356: * <code>GL_UNSIGNED_SHORT_4_4_4_4</code>, or
1357: * <code>GL_UNSIGNED_SHORT_5_5_5_1</code> and <code>format</code> is
1358: * not <code>GL_RGBA</code>.
1359: *
1360: * <p><code>GL_INVALID_OPERATION</code> is generated if none of the
1361: * above error conditions apply.
1362: *
1363: * <h4>Associated Gets</h4>
1364: *
1365: * <p><code>glGetIntegerv</code> with argument
1366: * <code>GL_MAX_TEXTURE_SIZE</code>
1367: *
1368: * @param target Specifies the target texture. Must be
1369: * <code>GL_TEXTURE_2D</code>.
1370: * @param level Specifies the level-of-detail number.
1371: * @param xoffset Specifies a texel offset in the x direction within
1372: * the texture array.
1373: * @param yoffset Specifies a texel offset in the y direction within
1374: * the texture array.
1375: * @param width Specifies the width of the texture subimage.
1376: * @param height Specifies the height of the texture subimage.
1377: * @param format Specifies the format of the pixel data. Currently,
1378: * there is no supported format.
1379: * @param imageSize Specifies the size of the compressed pixel data in bytes.
1380: * @param data Specifies a <code>Buffer</code> containing the
1381: * compressed image data.
1382: *
1383: * @exception IllegalArgumentException if <code>data</code> is
1384: * <code>null</code>.
1385: * @exception IllegalArgumentException if
1386: * <code>data.remaining()</code> is less than
1387: * <code>imageSize</code>.
1388: */
1389: void glCompressedTexSubImage2D(int target, int level, int xoffset,
1390: int yoffset, int width, int height, int format,
1391: int imageSize, Buffer data);
1392:
1393: /**
1394: * Specify a two-dimensional texture image with pixels from the
1395: * color buffer.
1396: *
1397: * <p><code>glCopyTexImage2D</code> defines a two-dimensional
1398: * texture image with pixels from the color buffer.
1399: *
1400: * <p>The screen-aligned pixel rectangle with lower left corner at
1401: * (<code>x</code>, <code>y</code>) and with a width of
1402: * <code>width</code> + 2*<code>border</code> and a height of
1403: * <code>height</code> + 2*<code>border</code> defines the texture
1404: * array at the mipmap level specified by
1405: * <code>level</code>. <code>internalformat</code> specifies the
1406: * color components of the texture.
1407: *
1408: * <p>The red, green, blue, and alpha components of each pixel that
1409: * is read are converted to an internal fixed-point or
1410: * floating-point format with unspecified precision. The conversion
1411: * maps the largest representable component value to 1.0, and
1412: * component value 0 to 0.0. The values are then converted to the
1413: * texture's internal format for storage in the texel array.
1414: *
1415: * <p><code>internalformat</code> must be chosen such that color
1416: * buffer components can be dropped during conversion to the
1417: * internal format, but new components cannot be added. For example,
1418: * an RGB color buffer can be used to create <code>LUMINANCE</code>
1419: * or <code>RGB</code> textures, but not <code>ALPHA</code>,
1420: * <code>LUMINANCE_ALPHA</code> or <code>RGBA</code> textures.
1421: *
1422: * <p>Pixel ordering is such that lower x and y screen coordinates
1423: * correspond to lower s and t texture coordinates.
1424: *
1425: * <p>If any of the pixels within the specified rectangle of the
1426: * color buffer are outside the window associated with the current
1427: * rendering context, then the values obtained for those pixels are
1428: * undefined.
1429: *
1430: * <h4>Notes</h4>
1431: *
1432: * <p>An image with <code>height</code> or <code>width</code> of 0
1433: * indicates a null-texture.
1434: *
1435: * <h4>Errors</h4>
1436: *
1437: * <p><code>GL_INVALID_ENUM</code> is generated if
1438: * <code>target</code> is not <code>GL_TEXTURE_2D</code>. <!-- If the
1439: * <code>OES_texture_cube_map</code> extension is present, then
1440: * <code>GL_TEXTURE_CUBE_MAP_POSITIVE_X</code>,
1441: * <code>GL_TEXTURE_CUBE_MAP_POSITIVE_Y</code>,
1442: * <code>GL_TEXTURE_CUBE_MAP_POSITIVE_Z</code>,
1443: * <code>GL_TEXTURE_CUBE_MAP_NEGATIVE_X</code>,
1444: * <code>GL_TEXTURE_CUBE_MAP_NEGATIVE_Y</code>, and
1445: * <code>GL_TEXTURE_CUBE_MAP_NEGATIVE_Z</code> are also accepted. -->
1446: *
1447: * <p><code>GL_INVALID_OPERATION</code> is generated if
1448: * <code>internalformat</code> is not compatible with the color
1449: * buffer format.
1450: *
1451: * <p><code>GL_INVALID_VALUE</code> is generated if
1452: * <code>level</code> is less than 0.
1453: *
1454: * <p><code>GL_INVALID_VALUE</code> may be generated if level is
1455: * greater than log_2(<i>max</i>), where <i>max</i> is the returned
1456: * value of <code>GL_MAX_TEXTURE_SIZE</code>.
1457: *
1458: * <p><code>GL_INVALID_VALUE</code> is generated if
1459: * <code>width</code> or <code>height</code> is less than 0, greater
1460: * than <code>GL_MAX_TEXTURE_SIZE</code>, or if <code>width</code>
1461: * or <code>height</code> cannot be represented as 2^<i>k</i> +
1462: * 2*<code>border</code> for some integer <i>k</i>.
1463: *
1464: * <p><code>GL_INVALID_VALUE</code> is generated if
1465: * <code>border</code> is not 0.
1466: *
1467: * <p>(1.0) <code>GL_INVALID_VALUE</code> is generated if
1468: * <code>internalformat</code> is not an accepted constant.
1469: *
1470: * <p>(1.1) <code>GL_INVALID_ENUM</code> is generated if
1471: * <code>internalformat</code> is not an accepted constant.
1472: *
1473: * <h4>Associated Gets</h4>
1474: *
1475: * <p><code>glGetIntegerv</code> with argument
1476: * <code>GL_MAX_TEXTURE_SIZE</code>
1477: *
1478: * @param target Specifies the target texture. Must be
1479: * <code>GL_TEXTURE_2D</code>.
1480: * @param level Specifies the level-of-detail number. Level 0 is the
1481: * base image level. Level n is the nth mipmap reduction image.
1482: * @param internalformat Specifies the color components of the
1483: * texture. Must be one of the following symbolic constants:
1484: * <code>GL_ALPHA</code>, <code>GL_LUMINANCE</code>,
1485: * <code>GL_LUMINANCE_ALPHA</code>, <code>GL_RGB</code>, or
1486: * <code>GL_RGBA</code>.
1487: * @param x Specifies the window x coordinate of the lower left
1488: * corner of the rectangular region of pixels to be copied.
1489: * @param y Specifies the window y coordinate of the lower left
1490: * corner of the rectangular region of pixels to be copied.
1491: * @param width Specifies the width of the texture image. Must be 0
1492: * or 2^<i>n</i? + 2*<code>border</code> for some integer <i>n</i>.
1493: * @param height Specifies the height of the texture image. Must be
1494: * 0 or 2^<i>m</i> + 2*<code>border</code> for some integer <i>m</i>.
1495: * @param border Specifies the width of the border. Must be 0.
1496: */
1497: void glCopyTexImage2D(int target, int level, int internalformat,
1498: int x, int y, int width, int height, int border);
1499:
1500: /**
1501: * Specify a two-dimensional texture subimage with pixels from the
1502: * color buffer.
1503: *
1504: * <p><code>glCopyTexSubImage2D</code> replaces a rectangular portion of a
1505: * two-dimensional texture image with pixels from the color buffer.
1506: *
1507: * <p>The screen-aligned pixel rectangle with lower left corner at
1508: * (<code>x</code>, <code>y</code>) and with width width and height
1509: * height replaces the portion of the texture array with x indices
1510: * <code>xoffset</code> through <code>xoffset</code> +
1511: * <code>width</code> - 1, inclusive, and y indices
1512: * <code>yoffset</code> through <code>yoffset</code> +
1513: * <code>height</code> - 1, inclusive, at the mipmap level specified
1514: * by level.
1515: *
1516: * <p>The pixels in the rectangle are processed the same way as with
1517: * <code>glCopyTexImage2D</code>.
1518: *
1519: * <p><code>glCopyTexSubImage2D</code> requires that the internal
1520: * format of the currently bound texture is such that color buffer
1521: * components can be dropped during conversion to the internal
1522: * format, but new components cannot be added. For example, an RGB
1523: * color buffer can be used to create LUMINANCE or RGB textures, but
1524: * not ALPHA, LUMINANCE_ALPHA or RGBA textures.
1525: *
1526: * <p>The destination rectangle in the texture array may not include
1527: * any texels outside the texture array as it was originally
1528: * specified. It is not an error to specify a subtexture with zero
1529: * width or height, but such a specification has no effect.
1530: *
1531: * <p>If any of the pixels within the specified rectangle of the
1532: * current color buffer are outside the read window associated with
1533: * the current rendering context, then the values obtained for those
1534: * pixels are undefined.
1535: *
1536: * <p>No change is made to the <code>internalformat</code>,
1537: * <code>width</code>, <code>height</code>, or <code>border</code>
1538: * parameters of the specified texture array or to texel values
1539: * outside the specified subregion.
1540: *
1541: * <h4>Errors</h4>
1542: *
1543: * <p><code>GL_INVALID_ENUM</code> is generated if
1544: * <code>target</code> is not <code>GL_TEXTURE_2D</code>.
1545: *
1546: * <p><code>GL_INVALID_OPERATION</code> is generated if the texture
1547: * array has not been defined by a previous
1548: * <code>glTexImage2D</code> or <code>glCopyTexImage2D</code>
1549: * operation or if the internal format of the currently bound
1550: * texture is not compatible with the color buffer format.
1551: *
1552: * <p><code>GL_INVALID_VALUE</code> is generated if
1553: * <code>level</code> is less than 0.
1554: *
1555: * <p><code>GL_INVALID_VALUE</code> may be generated if
1556: * <code>level</code> is greater than log_2(<i>max</i>), where
1557: * <i>max</i> is the returned value of
1558: * <code>GL_MAX_TEXTURE_SIZE</code>.
1559: *
1560: * <p><code>GL_INVALID_VALUE</code> is generated if x < <i>-b</i>,
1561: * or y < <i>-b</i>, where <i>b</i> is the border of the texture
1562: * being modified.
1563: *
1564: * <p><code>GL_INVALID_VALUE</code> is generated if
1565: * <code>xoffset</code> < <i>-b</i>, <code>xoffset</code> +
1566: * <code>width</code> > (<i>w - b</i>) , <code>yoffset</code> <
1567: * <i>-b</i>, or <code>yoffset</code> + <code>height</code> > (<i>h
1568: * - b</i>) , where <i>w</i> is the texture width, <i>h</i> is the
1569: * texture height, and <i>b</i> is the border of the texture image
1570: * being modified. Note that <i>w</i> and <i>h</i> include twice the
1571: * border width.
1572: *
1573: * <h4>Associated Gets</h4>
1574: *
1575: * <p><p><code>glGetIntegerv</code> with argument
1576: * <code>GL_MAX_TEXTURE_SIZE</code>
1577: *
1578: * @param target Specifies the target texture. Must be
1579: * <code>GL_TEXTURE_2D</code>.
1580: * @param level Specifies the level-of-detail number. Level 0 is the
1581: * base image level. Level n is the nth mipmap reduction image.
1582: * @param xoffset Specifies a texel offset in the x direction within
1583: * the texture array.
1584: * @param yoffset Specifies a texel offset in the y direction within
1585: * the texture array.
1586: * @param x Specifies the window x coordinate of the lower left
1587: * corner of the rectangular region of pixels to be copied.
1588: * @param y Specifies the window y coordinate of the lower left
1589: * corner of the rectangular region of pixels to be copied.
1590: * @param width Specifies the width of the texture subimage.
1591: * @param height Specifies the height of the texture subimage.
1592: */
1593: void glCopyTexSubImage2D(int target, int level, int xoffset,
1594: int yoffset, int x, int y, int width, int height);
1595:
1596: /**
1597: * Specify whether front- or back-facing polygons are culled.
1598: *
1599: * <p><code>glCullFace</code> specifies whether front- or
1600: * back-facing polygons are culled (as specified by
1601: * <code>mode</code>) when culling is enabled. To enable and disable
1602: * culling, call <code>glEnable</code> and <code>glDisable</code>
1603: * with argument <code>GL_CULL_FACE</code>. Culling is initially
1604: * disabled.
1605: *
1606: * <p><code>glFrontFace</code> specifies which of the clockwise and
1607: * counterclockwise polygons are front-facing and back-facing.
1608: *
1609: * <h4>Notes</h4>
1610: *
1611: * <p>If mode is <code>GL_FRONT_AND_BACK</code>, no polygons are
1612: * drawn, but other primitives such as points and lines are drawn.
1613: *
1614: * <h4>Errors</h4>
1615: *
1616: * <p><code>GL_INVALID_ENUM</code> is generated if <code>mode</code>
1617: * is not an accepted value.
1618: *
1619: * @param mode Specifies whether front- or back-facing polygons are
1620: * culled. Symbolic constants <code>GL_FRONT</code>,
1621: * <code>GL_BACK</code>, and <code>GL_FRONT_AND_BACK</code> are
1622: * accepted. The initial value is <code>GL_BACK</code>.
1623: */
1624: void glCullFace(int mode);
1625:
1626: /**
1627: * Delete named textures.
1628: *
1629: * <p><code>glDeleteTextures</code> deletes <code>n</code> textures
1630: * named by the elements of the array <code>textures</code>. After a
1631: * texture is deleted, it has no contents or dimensionality, and its
1632: * name is free for reuse (for example by
1633: * <code>glGenTextures</code>). If a texture that is currently bound
1634: * is deleted, the binding reverts to 0 (the default texture).
1635: *
1636: * <p><code>glDeleteTextures</code> silently ignores 0's and names
1637: * that do not correspond to existing textures.
1638: *
1639: * <h4>Errors</h4>
1640: *
1641: * <p><code>GL_INVALID_VALUE</code> is generated if <code>n</code>
1642: * is negative.
1643: *
1644: * @param n Specifies the number of textures to be deleted.
1645: * @param textures Specifies an array of textures to be deleted.
1646: * @param offset the starting offset within the
1647: * <code>textures</code> array.
1648: *
1649: * @exception IllegalArgumentException if <code>textures</code> is
1650: * <code>null</code>.
1651: * @exception IllegalArgumentException if <code>offset</code> is
1652: * less than 0.
1653: * @exception IllegalArgumentException if <code>textures.length -
1654: * offset</code> is less than <code>n</code>.
1655: */
1656: void glDeleteTextures(int n, int[] textures, int offset);
1657:
1658: /**
1659: * Integer <code>Buffer</code> version of <code>glDeleteTextures</code>.
1660: *
1661: * @param textures an <code>IntBuffer</code>.
1662: *
1663: * @exception IllegalArgumentException if <code>textures</code> is
1664: * <code>null</code>.
1665: * @exception IllegalArgumentException if
1666: * <code>textures.remaining()</code> is less than <code>n</code>.
1667: *
1668: * @see #glDeleteTextures(int n, int[] textures, int offset)
1669: */
1670: void glDeleteTextures(int n, IntBuffer textures);
1671:
1672: /**
1673: * Specify the value used for depth buffer comparisons.
1674: *
1675: * <p><code>glDepthFunc</code> specifies the function used to compare
1676: * each incoming pixel depth value with the depth value present in
1677: * the depth buffer. The comparison is performed only if depth
1678: * testing is enabled. To enable and disable depth testing, call
1679: * <code>glEnable</code> and <code>glDisable</code> with argument
1680: * <code>GL_DEPTH_TEST</code>. Depth testing is initially disabled.
1681: *
1682: * <p>func specifies the conditions under which the pixel will be
1683: * drawn. The comparison functions are as follows:
1684: *
1685: * <ul>
1686: * <li><code>GL_NEVER</code></li>
1687: * Never passes.
1688: * <li><code>GL_LESS</code></li>
1689: * Passes if the incoming depth value is less than the stored depth value.
1690: * <li><code>GL_EQUAL</code></li>
1691: * Passes if the incoming depth value is equal to the stored depth value.
1692: * <li><code>GL_LEQUAL</code></li>
1693: * Passes if the incoming depth value is less than or equal to the
1694: * stored depth value.
1695: * <li><code>GL_GREATER</code></li>
1696: * Passes if the incoming depth value is greater than the stored
1697: * depth value.
1698: * <li><code>GL_NOTEQUAL</code></li>
1699: * Passes if the incoming depth value is not equal to the stored
1700: * depth value.
1701: * <li><code>GL_GEQUAL</code></li>
1702: * Passes if the incoming depth value is greater than or equal to
1703: * the stored depth value.
1704: * <li><code>GL_ALWAYS</code></li>
1705: * Always passes.
1706: * </ul>
1707: *
1708: * <p>The initial value of func is <code>GL_LESS</code>. Initially,
1709: * depth testing is disabled. Even if the depth buffer exists and
1710: * the depth mask is non-zero, the depth buffer is not updated if
1711: * the depth test is disabled.
1712: *
1713: * <h4>Errors</h4>
1714: *
1715: * <p><code>GL_INVALID_ENUM</code> is generated if <code>func</code>
1716: * is not an accepted value.
1717: *
1718: * @param func Specifies the depth comparison function. Symbolic
1719: * constants <code>GL_NEVER</code>, <code>GL_LESS</code>,
1720: * <code>GL_EQUAL</code>, <code>GL_LEQUAL</code>,
1721: * <code>GL_GREATER</code>, <code>GL_NOTEQUAL</code>,
1722: * <code>GL_GEQUAL</code>, and <code>GL_ALWAYS</code> are
1723: * accepted. The initial value is <code>GL_LESS</code>.
1724: */
1725: void glDepthFunc(int func);
1726:
1727: /**
1728: * Enable or disable writing into the depth buffer.
1729: *
1730: * <p><code>glDepthMask</code> specifies whether the depth buffer is
1731: * enabled for writing. If <code>flag</code> is <code>false</code>,
1732: * depth buffer writing is disabled. Otherwise, it is
1733: * enabled. Initially, depth buffer writing is enabled.
1734: *
1735: * <h4>1.0 Notes</h4>
1736: *
1737: * <p><code>glDepthMask</code> does not affect <code>glClear</code>.
1738: *
1739: * @param flag Specifies whether the depth buffer is enabled for
1740: * writing. If flag is <code>GL_FALSE</code>, depth buffer writing
1741: * is disabled, otherwise it is enabled. The initial value is
1742: * <code>true</code>.
1743: */
1744: void glDepthMask(boolean flag);
1745:
1746: /**
1747: * Specify mapping of depth values from normalized device
1748: * coordinates to window coordinates.
1749: *
1750: * <p>After clipping and division by w, depth coordinates range from
1751: * -1 to 1, corresponding to the near and far clipping
1752: * planes. <code>glDepthRange</code> specifies a linear mapping of
1753: * the normalized depth coordinates in this range to window depth
1754: * coordinates. Regardless of the actual depth buffer
1755: * implementation, window coordinate depth values are treated as
1756: * though they range from 0 through 1 (like color components). Thus,
1757: * the values accepted by <code>glDepthRange</code> are both clamped
1758: * to this range before they are accepted.
1759: *
1760: * <p>The setting of (0, 1) maps the near plane to 0 and the far
1761: * plane to 1. With this mapping, the depth buffer range is fully
1762: * utilized.
1763: *
1764: * <h4>Notes</h4>
1765: *
1766: * <p>It is not necessary that <code>near</code> be less than
1767: * <code>far</code>. Reverse mappings such as <code>near</code> = 1,
1768: * and <code>far</code> = 0 are acceptable.
1769: *
1770: * @param zNear Specifies the mapping of the near clipping plane to
1771: * window coordinates. The initial value is 0.
1772: * @param zFar Specifies the mapping of the far clipping plane to
1773: * window coordinates. The initial value is 1.
1774: */
1775: void glDepthRangef(float zNear, float zFar);
1776:
1777: /**
1778: * Fixed-point version of <code>glDepthRange</code>.
1779: *
1780: * @see #glDepthRangef(float zNear, float zFar)
1781: */
1782: void glDepthRangex(int zNear, int zFar);
1783:
1784: /**
1785: * Disable server-side GL capabilities.
1786: *
1787: * @see #glEnable
1788: */
1789: void glDisable(int cap);
1790:
1791: /**
1792: * Disable client-side capability.
1793: *
1794: * @see #glEnableClientState
1795: */
1796: void glDisableClientState(int array);
1797:
1798: /**
1799: * Render primitives from array data.
1800: *
1801: * <p><code>glDrawArrays</code> specifies multiple geometric
1802: * primitives with very few subroutine calls. You can prespecify
1803: * separate arrays of vertices, normals, colors, and texture
1804: * coordinates and use them to construct a sequence of primitives
1805: * with a single call to <code>glDrawArrays</code>.
1806: *
1807: * <p>When <code>glDrawArrays</code> is called, it uses
1808: * <code>count</code> sequential elements from each enabled array to
1809: * construct a sequence of geometric primitives, beginning with
1810: * element <code>first</code>. <code>mode</code> specifies what kind
1811: * of primitives are constructed, and how the array elements
1812: * construct those primitives. If <code>GL_VERTEX_ARRAY</code> is
1813: * not enabled, no geometric primitives are generated.
1814: *
1815: * <p>Vertex attributes that are modified by
1816: * <code>glDrawArrays</code> have an unspecified value after
1817: * <code>glDrawArrays</code> returns. For example, if
1818: * <code>GL_COLOR_ARRAY</code> is enabled, the value of the current
1819: * color is undefined after <code>glDrawArrays</code>
1820: * executes. Attributes that aren't modified remain well defined.
1821: *
1822: * <h4>Errors</h4>
1823: *
1824: * <p><code>GL_INVALID_ENUM</code> is generated if <code>mode</code>
1825: * is not an accepted value.
1826: *
1827: * <p><code>GL_INVALID_VALUE</code> is generated if
1828: * <code>count</code> is negative.
1829: *
1830: * @exception ArrayIndexOutOfBoundsException if any index in the
1831: * sequence <code>first, ..., first + count - 1</code> will result
1832: * in a reference to an entry outside of the current vertex, color,
1833: * normal, texture coordinate, point size, matrix index, or weight
1834: * array.
1835: *
1836: * @param mode Specifies what kind of primitives to render. Symbolic
1837: * constants <code>GL_POINTS</code>, <code>GL_LINE_STRIP</code>,
1838: * <code>GL_LINE_LOOP</code>, <code>GL_LINES</code>,
1839: * <code>GL_TRIANGLE_STRIP</code>, <code>GL_TRIANGLE_FAN</code>, and
1840: * <code>GL_TRIANGLES</code> are accepted.
1841: * @param first Specifies the starting index in the enabled arrays.
1842: * @param count Specifies the number of indices to be rendered.
1843: */
1844: void glDrawArrays(int mode, int first, int count);
1845:
1846: /**
1847: * Render primitives from array data.
1848: *
1849: * <p><code>glDrawElements</code> specifies multiple geometric
1850: * primitives with very few subroutine calls. You can prespecify
1851: * separate arrays of vertices, normals, colors, and texture
1852: * coordinates and use them to construct a sequence of primitives
1853: * with a single call to <code>glDrawElements</code>.
1854: *
1855: * <p>When <code>glDrawElements</code> is called, it uses
1856: * <code>count</code> sequential indices from <code>indices</code>
1857: * to lookup elements in enabled arrays to construct a sequence of
1858: * geometric primitives. <code>mode</code> specifies what kind of
1859: * primitives are constructed, and how the array elements construct
1860: * these primitives. If <code>GL_VERTEX_ARRAY</code> is not enabled,
1861: * no geometric primitives are constructed.
1862: *
1863: * <p>Vertex attributes that are modified by
1864: * <code>glDrawElements</code> have an unspecified value after
1865: * <code>glDrawElements</code> returns. For example, if
1866: * <code>GL_COLOR_ARRAY</code> is enabled, the value of the current
1867: * color is undefined after <code>glDrawElements</code>
1868: * executes. Attributes that aren't modified maintain their previous
1869: * values.
1870: *
1871: * <h4>Errors</h4>
1872: *
1873: * <p><code>GL_INVALID_ENUM</code> is generated if <code>mode</code>
1874: * is not an accepted value.
1875: *
1876: * <p><code>GL_INVALID_ENUM</code> is generated if <code>type</code>
1877: * is not an accepted value.
1878: *
1879: * <p><code>GL_INVALID_VALUE</code> is generated if
1880: * <code>count</code> is negative.
1881: *
1882: * @param mode Specifies what kind of primitives to render. Symbolic
1883: * constants <code>GL_POINTS</code>, <code>GL_LINE_STRIP</code>,
1884: * <code>GL_LINE_LOOP</code>, <code>GL_LINES</code>,
1885: * <code>GL_TRIANGLE_STRIP</code>, <code>GL_TRIANGLE_FAN</code>, and
1886: * <code>GL_TRIANGLES</code> are accepted.
1887: * @param count Specifies the number of elements to be rendered.
1888: * @param type Specifies the type of the values in indices. Must be
1889: * either <code>GL_UNSIGNED_BYTE</code> or <code>GL_UNSIGNED_SHORT</code>.
1890: * @param indices Specifies a pointer to the location where the
1891: * indices are stored.
1892: *
1893: * @exception IllegalStateException if the most recent call to
1894: * <code>glBindBuffer</code> for the
1895: * <code>GL_ELEMENT_ARRAY_BUFFER</code> target had a non-zero
1896: * <code>buffer</code> parameter (i.e., an index buffer is bound).
1897: * @exception IllegalArgumentException if <code>indices</code> is
1898: * <code>null</code>.
1899: * @exception ArrayIndexOutOfBoundsException if any index in the
1900: * sequence of indices from <code>0</code> to <code>count - 1</code>
1901: * would result in a reference to an entry outside of the currently
1902: * bound index or data (vertex, color, normal, texture coordinate
1903: * array, weight, matrix index, or point size) array.
1904: */
1905: void glDrawElements(int mode, int count, int type, Buffer indices);
1906:
1907: /**
1908: * Enable server-side GL capabilities.
1909: *
1910: * <p><code>glEnable</code> and <code>glDisable</code> enable and
1911: * disable various capabilities. The initial value for each
1912: * capability with the exception of <code>GL_DITHER</code> and
1913: * <code>GL_MULTISAMPLE</code> is <code>GL_FALSE</code>. The initial
1914: * value for <code>GL_DITHER</code> and <code>GL_MULTISAMPLE</code>
1915: * is <code>GL_TRUE</code>.
1916: *
1917: * <p>Both <code>glEnable</code> and <code>glDisable</code> take a
1918: * single argument, <code>cap</code>, which can assume one of the
1919: * following values:
1920: *
1921: * <ul>
1922: * <li><code>GL_ALPHA_TEST</code></li>
1923: *
1924: * <p>If enabled, do alpha testing. See <code>glAlphaFunc</code>.
1925: *
1926: * <li><code>GL_BLEND</code></li>
1927: *
1928: * <p>If enabled, blend the incoming color values with the values in
1929: * the color buffers. See <code>glBlendFunc</code>.
1930: *
1931: * <li><code>GL_COLOR_LOGIC_OP</code></li>
1932: *
1933: * <p>If enabled, apply the currently selected logical operation to the
1934: * incoming color and color buffer values. See <code>glLogicOp</code>.
1935: *
1936: * <li><code>GL_COLOR_MATERIAL</code></li>
1937: *
1938: * <p>If enabled, have ambient and diffuse material parameters track
1939: * the current color.
1940: *
1941: * <li><code>GL_CULL_FACE</code></li>
1942: *
1943: * <p>If enabled, cull polygons based on their winding in window
1944: * coordinates. See <code>glCullFace</code>.
1945: *
1946: * <li><code>GL_DEPTH_TEST</code></li>
1947: *
1948: * <p>If enabled, do depth comparisons and update the depth
1949: * buffer. Note that even if the depth buffer exists and the depth
1950: * mask is non-zero, the depth buffer is not updated if the depth
1951: * test is disabled. See <code>glDepthFunc</code>,
1952: * <code>glDepthMask</code>, and <code>glDepthRange</code>.
1953: *
1954: * <li><code>GL_DITHER</code></li>
1955: *
1956: * <p>If enabled, dither color components or indices before they are
1957: * written to the color buffer.
1958: *
1959: * <li><code>GL_FOG</code></li>
1960: *
1961: * <p>If enabled, blend a fog color into the posttexturing color. See
1962: * <code>glFog</code>.
1963: *
1964: * <li><code>GL_LIGHT</code><i>i</i></li>
1965: *
1966: * <p>If enabled, include light <i>i</i> in the evaluation of the
1967: * lighting equation. See <code>glLightModel</code> and
1968: * <code>glLight</code>.
1969: *
1970: * <li><code>GL_LIGHTING</code></li>
1971: *
1972: * <p>If enabled, use the current lighting parameters to compute the
1973: * vertex color. Otherwise, simply associate the current color with
1974: * each vertex. See <code>glMaterial</code>,
1975: * <code>glLightModel</code>, and <code>glLight</code>.
1976: *
1977: * <li><code>GL_LINE_SMOOTH</code></li>
1978: *
1979: * <p>If enabled, draw lines with correct filtering. Otherwise, draw
1980: * aliased lines. See <code>glLineWidth</code>.
1981: *
1982: * <li><code>GL_MULTISAMPLE</code></li>
1983: *
1984: * <p>If enabled, perform multisampling of fragments for single-pass
1985: * antialiasing and other effects. See <code>glSampleCoverage</code>.
1986: *
1987: * <li><code>GL_NORMALIZE</code></li>
1988: *
1989: * <p>If enabled, normal vectors are scaled to unit length after
1990: * transformation. See <code>glNormal</code> and
1991: * <code>glNormalPointer</code>.
1992: *
1993: * <li><code>GL_POINT_SMOOTH</code></li>
1994: *
1995: * <p>If enabled, draw points with proper filtering. Otherwise, draw
1996: * aliased points. See <code>glPointSize</code>.
1997: *
1998: * <li><code>GL_POLYGON_OFFSET_FILL</code></li>
1999: *
2000: * <p>If enabled, an offset is added to depth values of a polygon's
2001: * fragments before the depth comparison is performed. See
2002: * <code>glPolygonOffset</code>.
2003: *
2004: * <li><code>GL_RESCALE_NORMAL</code></li>
2005: *
2006: * <p>If enabled, normal vectors are scaled by a factor derived from
2007: * the modelview matrix. See <code>glNormal</code> and
2008: * <code>glNormalPointer</code>.
2009: *
2010: * <li><code>GL_SAMPLE_ALPHA_TO_MASK</code> (1.0 only)</li>
2011: *
2012: * <p>If enabled, convert fragment alpha values to multisample coverage
2013: * modification masks. See <code>glSampleCoverage</code>.
2014: *
2015: * <li><code>GL_SAMPLE_ALPHA_TO_COVERAGE</code> (1.1 only)</li>
2016: *
2017: * <p>If enabled, a temporary coverage value is generated where each
2018: * bit is determined by the alpha value at the corresponding sample
2019: * location. The temporary coverage value is then ANDed with the
2020: * fragment coverage value. Otherwise the fragment coverage value is
2021: * unchanged at this point. See <code>glSampleCoverage</code>.
2022: *
2023: * <li><code>GL_SAMPLE_ALPHA_TO_ONE</code></li>
2024: *
2025: * <p>If enabled, set fragment alpha to the maximum permissible value
2026: * after computing multisample coverage modification masks. See
2027: * <code>glSampleCoverage</code>.
2028: *
2029: * <li><code>GL_SAMPLE_MASK</code> (1.0 only)</li>
2030: *
2031: * <p>If enabled, apply a mask to modify fragment coverage during
2032: * multisampling. See <code>glSampleCoverage</code>.
2033: *
2034: * <li><code>GL_SAMPLE_COVERAGE</code> (1.1 only)</li>
2035: *
2036: * <p>If enabled, the fragment coverage is ANDed with another temporary
2037: * coverage. This temporary coverage is generated in the same manner
2038: * as for <code>GL_SAMPLE_ALPHA_TO_COVERAGE</code> described above,
2039: * but as a function of the value of
2040: * <code>GL_SAMPLE_COVERAGE_VALUE</code>. If
2041: * <code>GL_SAMPLE_COVERAGE_INVERT</code> is <code>GL_TRUE</code>,
2042: * the temporary coverage is inverted (all bit values are inverted)
2043: * before it is ANDed with the fragment coverage. See
2044: * <code>glSampleCoverage</code>.
2045: *
2046: * <li><code>GL_SCISSOR_TEST</code></li>
2047: *
2048: * <p>If enabled, discard fragments that are outside the scissor
2049: * rectangle. See <code>glScissor</code>.
2050: *
2051: * <li><code>GL_STENCIL_TEST</code></li>
2052: *
2053: * <p>If enabled, do stencil testing and update the stencil buffer. See
2054: * <code>glStencilFunc</code>, <code>glStencilMask</code>, and
2055: * <code>glStencilOp</code>.
2056: *
2057: * <li><code>GL_TEXTURE_2D</code></li>
2058: *
2059: * <p>If enabled, two-dimensional texturing is performed for the active
2060: * texture unit. See <code>glActiveTexture</code>,
2061: * <code>glTexImage2D</code>, <code>glCompressedTexImage2D</code>,
2062: * and <code>glCopyTexImage2D</code>.
2063: *
2064: * <li><code>GL_CLIP_PLANE</code><i>i</i> (1.1 only)</li>
2065: *
2066: * <p>If enabled, clipping plane <i>i</i> is enabled. See
2067: * <code>glClipPlane</code>.
2068: *
2069: * <li><code>GL_POINT_SPRITE_OES</code>
2070: * (1.1 + <code>OES_point_sprite</code> extension)</li>
2071: *
2072: * <p>If enabled, point sprites are enabled. See
2073: * <code>glPointSize</code> and <code>glTexEnv</code>.
2074: *
2075: * </ul>
2076: *
2077: * <h4>Errors</h4>
2078: *
2079: * <p><code>GL_INVALID_ENUM</code> is generated if cap is not one of
2080: * the values listed previously.
2081: *
2082: * @param cap Specifies a symbolic constant indicating a GL capability.
2083: */
2084: void glEnable(int cap);
2085:
2086: /**
2087: * Enable client-side capability.
2088: *
2089: * <p><code>glEnableClientState</code> and
2090: * <code>glDisableClientState</code> enable or disable individual
2091: * client-side capabilities. By default, all client-side
2092: * capabilities are disabled. Both <code>glEnableClientState</code>
2093: * and <code>glDisableClientState</code> take a single argument,
2094: * <code>array</code>, which can assume one of the following values:
2095: *
2096: * <ul>
2097: *
2098: * <li><code>GL_COLOR_ARRAY</code></li>
2099: *
2100: * <p>If enabled, the color array is enabled for writing and used
2101: * during rendering when <code>glDrawArrays</code>, or
2102: * <code>glDrawElements</code> is called. See
2103: * <code>glColorPointer</code>.
2104: *
2105: * <li><code>GL_NORMAL_ARRAY</code></li>
2106: *
2107: * <p>If enabled, the normal array is enabled for writing and used
2108: * during rendering when <code>glDrawArrays</code>, or
2109: * <code>glDrawElements</code> is called. See
2110: * <code>glNormalPointer</code>.
2111: *
2112: * <li><code>GL_TEXTURE_COORD_ARRAY</code></li>
2113: *
2114: * <p>If enabled, the texture coordinate array is enabled for writing
2115: * and used during rendering when <code>glDrawArrays</code>, or
2116: * <code>glDrawElements</code> is called. See
2117: * <code>glTexCoordPointer</code>.
2118: *
2119: * <li><code>GL_VERTEX_ARRAY</code></li>
2120: *
2121: * <p>If enabled, the vertex array is enabled for writing and used
2122: * during rendering when <code>glDrawArrays</code>, or
2123: * <code>glDrawElements</code> is called. See
2124: * <code>glVertexPointer</code>.
2125: *
2126: * <li><code>GL_POINT_SIZE_ARRAY_OES</code>
2127: * (<code>OES_point_size_array</code> extension)</li>
2128: *
2129: * <p>If enabled, the point size array controls the sizes used to
2130: * render points and point sprites. In this case the point size
2131: * defined by <code>glPointSize</code> is ignored. The point sizes
2132: * supplied in the point size arrays will be the sizes used to
2133: * render both points and point sprites. See
2134: * <code>glPointSize</code>.
2135: *
2136: * </ul>
2137: *
2138: * <h4>Notes</h4>
2139: *
2140: * <p>Enabling and disabling <code>GL_TEXTURE_COORD_ARRAY</code>
2141: * affects the active client texture unit. The active client texture
2142: * unit is controlled with <code>glClientActiveTexture</code>.
2143: * <h4>Errors</h4>
2144: *
2145: * <p><code>GL_INVALID_ENUM</code> is generated if
2146: * <code>array</code> is not an accepted value.
2147: *
2148: * @param array Specifies the capability to enable or
2149: * disable. Symbolic constants <code>GL_COLOR_ARRAY</code>,
2150: * <code>GL_NORMAL_ARRAY</code>,
2151: * <code>GL_TEXTURE_COORD_ARRAY</code>,
2152: * <code>GL_VERTEX_ARRAY</code>, and
2153: * <code>GL_POINT_SIZE_ARRAY_OES</code>
2154: * (<code>OES_point_size_array</code> extension) are accepted. <!-- If the
2155: * <code>OES_matrix_palette</code> extension is present, symbolic
2156: * constants <code>GL_MATRIX_INDEX_ARRAY_OES</code>,
2157: * <code>GL_WEIGHT_ARRAY_OES</code> are additionally accepted. -->
2158: */
2159: void glEnableClientState(int array);
2160:
2161: /**
2162: * Block until all GL execution is complete.
2163: *
2164: * <p><code>glFinish</code> does not return until the effects of all
2165: * previously called GL commands are complete. Such effects include
2166: * all changes to GL state, all changes to connection state, and all
2167: * changes to the frame buffer contents.
2168: *
2169: * <h4>Notes</h4>
2170: *
2171: * <p><code>glFinish</code> requires a round trip to the server.
2172: */
2173: void glFinish();
2174:
2175: /**
2176: * Force execution of GL commands in finite time.
2177: *
2178: * <p>Different GL implementations buffer commands in several
2179: * different locations, including network buffers and the graphics
2180: * accelerator itself. <code>glFlush</code> empties all of these
2181: * buffers, causing all issued commands to be executed as quickly as
2182: * they are accepted by the actual rendering engine. Though this
2183: * execution may not be completed in any particular time period, it
2184: * does complete in finite time.
2185: *
2186: * <p>Because any GL program might be executed over a network, or on an
2187: * accelerator that buffers commands, all programs should call
2188: * <code>glFlush</code> whenever they count on having all of their previously
2189: * issued commands completed. For example, call <code>glFlush</code> before
2190: * waiting for user input that depends on the generated image.
2191: *
2192: * <h4>Notes</h4>
2193: *
2194: * <p><code>glFlush</code> can return at any time. It does not wait until the
2195: * execution of all previously issued GL commands is complete.
2196: */
2197: void glFlush();
2198:
2199: /**
2200: * Specify fog parameters.
2201: *
2202: * <p>If fog is enabled, fog affects rasterized geometry, bitmaps,
2203: * and pixel blocks, but not buffer clear operations. To enable and
2204: * disable fog, call <code>glEnable</code> and
2205: * <code>glDisable</code> with argument <code>GL_FOG</code>. Fog is
2206: * initially disabled.
2207: *
2208: * <p><code>glFog</code> assigns the value in <code>param</code> to
2209: * the fog parameter specified by <code>pname</code>. The following
2210: * values are accepted for <code>pname</code>:
2211: *
2212: * <ul>
2213: *
2214: * <li><code>GL_FOG_MODE</code></li>
2215: *
2216: * <p><code>param</code> is a single value that specifies the equation
2217: * to be used to compute the fog blend factor f. Three symbolic
2218: * constants are accepted: <code>GL_LINEAR</code>,
2219: * <code>GL_EXP</code>, and <code>GL_EXP2</code>. The equations
2220: * corresponding to these symbolic constants are defined below. The
2221: * initial fog mode is <code>GL_EXP</code>.
2222: *
2223: * <li><code>GL_FOG_DENSITY</code></li>
2224: *
2225: * <p><code>param</code> is a single value that specifies density, the
2226: * fog density used in both exponential fog equations. Only
2227: * nonnegative densities are accepted. The initial fog density is 1.
2228: *
2229: * <li><code>GL_FOG_START</code></li>
2230: *
2231: * <p><code>param</code> is a single value that specifies start, the
2232: * near distance used in the linear fog equation. The initial near
2233: * distance is 0.
2234: *
2235: * <li><code>GL_FOG_END</code></li>
2236: *
2237: * <p><code>param</code> is a single value that specifies end, the far
2238: * distance used in the linear fog equation. The initial far
2239: * distance is 1.
2240: *
2241: * </ul>
2242: *
2243: * <h4>Errors</h4>
2244: *
2245: * <p><code>GL_INVALID_ENUM</code> is generated if
2246: * <code>pname</code> is not an accepted value, or if
2247: * <code>pname</code> is <code>GL_FOG_MODE</code> and
2248: * <code>param</code> is not an accepted value.
2249: *
2250: * <p><code>GL_INVALID_VALUE</code> is generated if
2251: * <code>pname</code> is <code>GL_FOG_DENSITY</code>, and
2252: * <code>param</code> is negative.
2253: *
2254: * @param pname Specifies a single-valued fog
2255: * parameter. <code>GL_FOG_MODE</code>, <code>GL_FOG_DENSITY</code>,
2256: * <code>GL_FOG_START</code>, and <code>GL_FOG_END</code> are
2257: * accepted.
2258: * @param param Specifies the value that <code>pname</code> will be
2259: * set to.
2260: */
2261: void glFogf(int pname, float param);
2262:
2263: /**
2264: * Specify fog parameters (array version).
2265: *
2266: * <p>If fog is enabled, fog affects rasterized geometry, bitmaps,
2267: * and pixel blocks, but not buffer clear operations. To enable and
2268: * disable fog, call <code>glEnable</code> and
2269: * <code>glDisable</code> with argument <code>GL_FOG</code>. Fog is
2270: * initially disabled.
2271: *
2272: * <p><code>glFog</code> assigns the value or values in
2273: * <code>params</code> to the fog parameter specified by
2274: * <code>pname</code>. The following values are accepted for
2275: * <code>pname</code>:
2276: *
2277: * <ul>
2278: *
2279: * <li><code>GL_FOG_MODE</code></li>
2280: *
2281: * <p><code>params</code> contains a single value that specifies the
2282: * equation to be used to compute the fog blend factor f. Three
2283: * symbolic constants are accepted: <code>GL_LINEAR</code>,
2284: * <code>GL_EXP</code>, and <code>GL_EXP2</code>. The equations
2285: * corresponding to these symbolic constants are defined below. The
2286: * initial fog mode is <code>GL_EXP</code>.
2287: *
2288: * <li><code>GL_FOG_DENSITY</code></li>
2289: *
2290: * <p><code>params</code> contains a single value that specifies
2291: * density, the fog density used in both exponential fog
2292: * equations. Only nonnegative densities are accepted. The initial
2293: * fog density is 1.
2294: *
2295: * <li><code>GL_FOG_START</code></li>
2296: *
2297: * <p><code>params</code> contains a single value that specifies start,
2298: * the near distance used in the linear fog equation. The initial
2299: * near distance is 0.
2300: *
2301: * <li><code>GL_FOG_END</code></li>
2302: *
2303: * <p><code>params</code> contains a single value that specifies end,
2304: * the far distance used in the linear fog equation. The initial far
2305: * distance is 1.
2306: *
2307: * <li><code>GL_FOG_COLOR</code></li>
2308: *
2309: * <p><code>params</code> contains four values that specify
2310: * <i>Cf</i>, the fog color. Both fixed-point and floating-point
2311: * values are mapped directly. After conversion, all color
2312: * components are clamped to the range <code>[0, 1]</code>. The
2313: * initial fog color is <code>(0, 0, 0, 0)</code>.
2314: *
2315: * </ul>
2316: *
2317: * <p>Fog blends a fog color with each rasterized pixel fragment's
2318: * posttexturing color using a blending factor f. Factor f is computed in
2319: * one of three ways, depending on the fog mode. Let z be the distance in
2320: * eye coordinates from the origin to the fragment being fogged. The
2321: * equation for <code>GL_LINEAR</code> fog is
2322: *
2323: * <pre>
2324: * f = (end - z)/(end - start)
2325: * </pre>
2326: *
2327: * <p>The equation for <code>GL_EXP</code> fog is
2328: *
2329: * <pre>
2330: * f = e -(density - z)
2331: * </pre>
2332: *
2333: * <p>The equation for <code>GL_EXP2</code> fog is
2334: *
2335: * <pre>
2336: * f = e -(density - z)2
2337: * </pre>
2338: *
2339: * <p>Regardless of the fog mode, <i>f</i> is clamped to the range
2340: * <code>[0, 1]</code> after it is computed. Then, the fragment's
2341: * red, green, and blue colors, represented by <i>Cr</i>, are
2342: * replaced by:
2343: *
2344: * <pre>
2345: * C'r = f Cr + (1 - f) Cf
2346: * </pre>
2347: *
2348: * <p>Fog does not affect a fragment's alpha component.
2349: *
2350: * <h4>Errors</h4>
2351: *
2352: * <p><code>GL_INVALID_ENUM</code> is generated if
2353: * <code>pname</code> is not an accepted value, or if
2354: * <code>pname</code> is <code>GL_FOG_MODE</code> and
2355: * <code>params</code> is not an accepted value.
2356: *
2357: * <p><code>GL_INVALID_VALUE</code> is generated if
2358: * <code>pname</code> is <code>GL_FOG_DENSITY</code>, and the first
2359: * value in <code>params</code> is negative.
2360: *
2361: * @param pname Specifies a fog parameter. <code>GL_FOG_MODE</code>,
2362: * <code>GL_FOG_DENSITY</code>, <code>GL_FOG_START</code>,
2363: * <code>GL_FOG_END</code>, and <code>GL_FOG_COLOR</code> are
2364: * accepted.
2365: * @param params Specifies the value or values to be assigned to
2366: * <code>pname</code>. <code>GL_FOG_COLOR</code> requires an array
2367: * of four values. All other parameters accept an array containing
2368: * only a single value.
2369: * @param offset the starting offset within the
2370: * <code>params</code> array.
2371: *
2372: * @exception IllegalArgumentException if <code>params</code> is
2373: * <code>null</code>.
2374: * @exception IllegalArgumentException if <code>offset</code> is
2375: * less than 0.
2376: * @exception IllegalArgumentException if <code>params.length -
2377: * offset</code> is smaller than the number of values required by
2378: * the parameter.
2379: */
2380: void glFogfv(int pname, float[] params, int offset);
2381:
2382: /**
2383: * Floating-point <code>Buffer</code> version of <code>glFog</code>.
2384: *
2385: * @see #glFogfv(int pname, float[] params, int offset)
2386: *
2387: * @exception IllegalArgumentException if <code>params</code> is
2388: * <code>null</code>.
2389: * @exception IllegalArgumentException if
2390: * <code>params.remaining()</code> is smaller than the number of
2391: * values required by the parameter.
2392: */
2393: void glFogfv(int pname, FloatBuffer params);
2394:
2395: /**
2396: * Fixed-point version of <code>glFog</code>.
2397: *
2398: * @see #glFogf(int pname, float param)
2399: */
2400: void glFogx(int pname, int param);
2401:
2402: /**
2403: * Fixed-point array version of <code>glFog</code>.
2404: *
2405: * @see #glFogfv(int pname, float[] params, int offset)
2406: *
2407: * @exception IllegalArgumentException if <code>params</code> is
2408: * <code>null</code>.
2409: * @exception IllegalArgumentException if <code>offset</code> is
2410: * less than 0.
2411: * @exception IllegalArgumentException if <code>params.length -
2412: * offset</code> is smaller than the number of values required by
2413: * the parameter.
2414: */
2415: void glFogxv(int pname, int[] params, int offset);
2416:
2417: /**
2418: * Fixed-point <code>Buffer</code> version of <code>glFog</code>.
2419: *
2420: * @see #glFogfv(int pname, float[] params, int offset)
2421: *
2422: * @exception IllegalArgumentException if <code>params</code> is
2423: * <code>null</code>.
2424: * @exception IllegalArgumentException if
2425: * <code>params.remaining()</code> is smaller than the number of
2426: * values required by the parameter.
2427: */
2428: void glFogxv(int pname, IntBuffer params);
2429:
2430: /**
2431: * Define front- and back-facing polygons.
2432: *
2433: * <p>In a scene composed entirely of opaque closed surfaces,
2434: * back-facing polygons are never visible. Eliminating (culling)
2435: * these invisible polygons has the obvious benefit of speeding up
2436: * the rendering of the image. To enable and disable culling, call
2437: * <code>glEnable</code> and <code>glDisable</code> with argument
2438: * <code>GL_CULL_FACE</code>. Culling is initially disabled.
2439: *
2440: * <p>The projection of a polygon to window coordinates is said to
2441: * have clockwise winding if an imaginary object following the path
2442: * from its first vertex, its second vertex, and so on, to its last
2443: * vertex, and finally back to its first vertex, moves in a
2444: * clockwise direction about the interior of the polygon. The
2445: * polygon's winding is said to be counterclockwise if the imaginary
2446: * object following the same path moves in a counterclockwise
2447: * direction about the interior of the polygon. glFrontFace
2448: * specifies whether polygons with clockwise winding in window
2449: * coordinates, or counterclockwise winding in window coordinates,
2450: * are taken to be front-facing. Passing <code>GL_CCW</code> to
2451: * <code>mode</code> selects counterclockwise polygons as
2452: * front-facing. <code>GL_CW</code> selects clockwise polygons as
2453: * front-facing. By default, counterclockwise polygons are taken to
2454: * be front-facing.
2455: *
2456: * <h4>Errors</h4>
2457: *
2458: * <p><code>GL_INVALID_ENUM</code> is generated if <code>mode</code>
2459: * is not an accepted value.
2460: *
2461: * @param mode Specifies the orientation of front-facing
2462: * polygons. <code>GL_CW</code> and <code>GL_CCW</code> are
2463: * accepted. The initial value is <code>GL_CCW</code>.
2464: */
2465: void glFrontFace(int mode);
2466:
2467: // Need revisit - definition wrong?
2468: /**
2469: * Multiply the current matrix by a perspective matrix.
2470: *
2471: * <p><code>glFrustum</code> describes a perspective matrix that
2472: * produces a perspective projection. The current matrix (see
2473: * <code>glMatrixMode</code>) is multiplied by this matrix and the
2474: * result replaces the current matrix, as if
2475: * <code>glMultMatrix</code> were called with the following matrix
2476: * as its argument:
2477: *
2478: * <pre>
2479: * ( 2/(right - left) 0 A 0 )
2480: * ( 0 2/(top - bottom) B 0 )
2481: * ( 0 0 C D )
2482: * ( 0 0 -1 0 )
2483: * </pre>
2484: *
2485: * <p>where
2486: *
2487: * <pre>
2488: * A = - (right + left)/(right - left)
2489: * B = - (top + bottom)/(top - bottom)
2490: * C = - (far + near)/(far - near)
2491: * D = - 2farnear/(far - near)
2492: * </pre>
2493: *
2494: * <p>Typically, the matrix mode is <code>GL_PROJECTION</code>, and
2495: * (<code>left</code>, <code>bottom</code>, -<code>near</code>) and
2496: * (<code>right</code>, <code>top</code>, -<code>near</code>)
2497: * specify the points on the near clipping plane that are mapped to
2498: * the lower left and upper right corners of the window, assuming
2499: * that the eye is located at (0, 0, 0). -<code>far</code> specifies
2500: * the location of the far clipping plane. Both <code>near</code>
2501: * and <code>far</code> must be positive.
2502: *
2503: * <p>Use <code>glPushMatrix</code> and <code>glPopMatrix</code> to
2504: * save and restore the current matrix stack.
2505: *
2506: * <h4>Notes</h4>
2507: *
2508: * <p>Depth buffer precision is affected by the values specified for
2509: * near and far. The greater the ratio of <code>far</code> to
2510: * <code>near</code> is, the less effective the depth buffer will be
2511: * at distinguishing between surfaces that are near each other. If
2512: *
2513: * <pre>
2514: * r = far/near
2515: * </pre>
2516: *
2517: * roughly log_2(<i>r</i>) bits of depth buffer precision are
2518: * lost. Because <i>r</i> approaches infinity as <code>near</code>
2519: * approaches 0, <code>near</code> must never be set to 0.
2520: *
2521: * <h4>Errors</h4>
2522: *
2523: * <p><code>GL_INVALID_VALUE</code> is generated if
2524: * <code>near</code> or <code>far</code> is not positive, or if
2525: * <code>left</code> = <code>right</code>, or <code>bottom</code> =
2526: * <code>top</code>.
2527: *
2528: * @param left Specifies the coordinate for the left vertical
2529: * clipping plane.
2530: * @param right Specifies the coordinate for the right vertical
2531: * clipping plane.
2532: * @param bottom Specifies the coordinate for the bottom horizontal
2533: * clipping plane.
2534: * @param top Specifies the coordinate for the top horizontal
2535: * clipping plane.
2536: * @param near Specifies the distances to the near depth clipping
2537: * plane. The distance must be positive.
2538: * @param far Specifies the distances to the near depth clipping
2539: * plane. The distance must be positive.
2540: */
2541: void glFrustumf(float left, float right, float bottom, float top,
2542: float near, float far);
2543:
2544: /**
2545: * Fixed-point version of <code>glFrustum</code>.
2546: *
2547: * @see #glFrustumf
2548: */
2549: void glFrustumx(int left, int right, int bottom, int top, int near,
2550: int far);
2551:
2552: /**
2553: * Generate texture names.
2554: *
2555: * <p><code>glGenTextures</code> returns <code>n</code> texture
2556: * names in <code>textures</code>. There is no guarantee that the
2557: * names form a contiguous set of integers. However, it is
2558: * guaranteed that none of the returned names was in use immediately
2559: * before the call to <code>glGenTextures</code>.
2560: *
2561: * <p>The generated textures have no dimensionality; they assume the
2562: * dimensionality of the texture target to which they are first
2563: * bound (see glBindTexture).
2564: *
2565: * <p>Texture names returned by a call to <code>glGenTextures</code> are not
2566: * returned by subsequent calls, unless they are first deleted with
2567: * <code>glDeleteTextures</code>.
2568: *
2569: * <h4>Errors</h4>
2570: *
2571: * <p><code>GL_INVALID_VALUE</code> is generated if <code>n</code>
2572: * is negative.
2573: *
2574: * @param n Specifies the number of texture names to be generated.
2575: * @param textures Specifies an array in which the generated texture
2576: * names are stored.
2577: * @param offset the starting offset within the
2578: * <code>textures</code> array.
2579: *
2580: * @exception IllegalArgumentException if <code>textures</code> is
2581: * <code>null</code>.
2582: * @exception IllegalArgumentException if <code>offset</code> is
2583: * less than 0.
2584: * @exception IllegalArgumentException if <code>textures.length -
2585: * offset</code> is less than <code>n</code>.
2586: */
2587: void glGenTextures(int n, int[] textures, int offset);
2588:
2589: /**
2590: * Integer <code>Buffer</code> version of <code>glGenTextures</code>.
2591: *
2592: * @see #glGenTextures(int n, int[] textures, int offset)
2593: *
2594: * @exception IllegalArgumentException if <code>textures</code> is
2595: * <code>null</code>.
2596: * @exception IllegalArgumentException if
2597: * <code>textures.remaining()</code> is less than <code>n</code>.
2598: */
2599: void glGenTextures(int n, IntBuffer textures);
2600:
2601: /**
2602: * Return error information.
2603: *
2604: * <p><code>glGetError</code> returns the value of the error
2605: * flag. Each detectable error is assigned a numeric code and
2606: * symbolic name. When an error occurs, the error flag is set to the
2607: * appropriate error code value. No other errors are recorded until
2608: * <code>glGetError</code> is called, the error code is returned,
2609: * and the flag is reset to <code>GL_NO_ERROR</code>. If a call to
2610: * <code>glGetError</code> returns <code>GL_NO_ERROR</code>, there
2611: * has been no detectable error since the last call to
2612: * <code>glGetError</code>, or since the GL was initialized.
2613: *
2614: * <p>To allow for distributed implementations, there may be several
2615: * error flags. If any single error flag has recorded an error, the
2616: * value of that flag is returned and that flag is reset to
2617: * <code>GL_NO_ERROR</code> when <code>glGetError</code> is
2618: * called. If more than one flag has recorded an error,
2619: * <code>glGetError</code> returns and clears an arbitrary error
2620: * flag value. Thus, <code>glGetError</code> should always be called
2621: * in a loop, until it returns <code>GL_NO_ERROR</code>, if all
2622: * error flags are to be reset.
2623: *
2624: * <p>Initially, all error flags are set to <code>GL_NO_ERROR</code>.
2625: *
2626: * <p>The following errors are currently defined:
2627: *
2628: * <ul>
2629: *
2630: * <li><code>GL_NO_ERROR</code></li>
2631: *
2632: * <p>No error has been recorded. The value of this symbolic constant
2633: * is guaranteed to be 0.
2634: *
2635: * <li><code>GL_INVALID_ENUM</code></li>
2636: *
2637: * <p>An unacceptable value is specified for an enumerated
2638: * argument. The offending command is ignored, and has no other side
2639: * effect than to set the error flag.
2640: *
2641: * <li><code>GL_INVALID_VALUE</code></li>
2642: *
2643: * <p>A numeric argument is out of range. The offending command is
2644: * ignored, and has no other side effect than to set the error flag.
2645: *
2646: * <li><code>GL_INVALID_OPERATION</code></li>
2647: *
2648: * <p>The specified operation is not allowed in the current state. The
2649: * offending command is ignored, and has no other side effect than
2650: * to set the error flag.
2651: *
2652: * <li><code>GL_STACK_OVERFLOW</code></li>
2653: *
2654: * <p>This command would cause a stack overflow. The offending command
2655: * is ignored, and has no other side effect than to set the error
2656: * flag.
2657: *
2658: * <li><code>GL_STACK_UNDERFLOW</code></li>
2659: *
2660: * <p>This command would cause a stack underflow. The offending command
2661: * is ignored, and has no other side effect than to set the error
2662: * flag.
2663: *
2664: * <li><code>GL_OUT_OF_MEMORY</code></li>
2665: *
2666: * <p>There is not enough memory left to execute the command. The state
2667: * of the GL is undefined, except for the state of the error flags,
2668: * after this error is recorded.
2669: *
2670: * </ul>
2671: *
2672: * <p>When an error flag is set, results of a GL operation are
2673: * undefined only if <code>GL_OUT_OF_MEMORY</code> has occurred. In
2674: * all other cases, the command generating the error is ignored and
2675: * has no effect on the GL state or frame buffer contents. If the
2676: * generating command returns a value, it returns 0. If
2677: * <code>glGetError</code> itself generates an error, it returns 0.
2678: *
2679: * @return One of the error codes listed above.
2680: */
2681: int glGetError();
2682:
2683: /**
2684: * Return the value or values of a selected parameter.
2685: *
2686: * <p><code>glGet</code> returns values for static state
2687: * variables in GL. <code>pname</code> is a symbolic constant
2688: * indicating the static state variable to be returned, and
2689: * <code>params</code> is an array of integers in which to place the
2690: * returned data.
2691: *
2692: * <p> A boolean value is interpreted as either 1 or 0, and a
2693: * floating-point value is rounded to the nearest integer, unless
2694: * the value is an RGBA color component, a <code>DepthRange</code>
2695: * value, a depth buffer clear value, or a normal coordinate. In
2696: * these cases, the <code>glGet</code> command does a linear mapping
2697: * that maps 1.0 to the most positive representable integer value,
2698: * and -1.0 to the most negative representable integer value.
2699: *
2700: * <p> In OpenGL ES 1.0, on <code>glGetIntegerv</code> is provided.
2701: * OpenGL ES 1.1 additionally provides <code>glGetBooleanv</code>,
2702: * <code>glGetFixedv</code>, and <code>glGetFloatv</code>.
2703: *
2704: * <p>The following symbolic constants are accepted by
2705: * <code>pname</code>:
2706: *
2707: * <ul>
2708: * <li><code>GL_ALIASED_POINT_SIZE_RANGE</code></li>
2709: *
2710: * <p><code>params</code> returns two values, the smallest and largest
2711: * supported sizes for aliased points. The range must include 1. See
2712: * <code>glPointSize</code>.
2713: *
2714: * <li><code>GL_ALIASED_LINE_WIDTH_RANGE</code></li>
2715: *
2716: * <p><code>params</code> returns two values, the smallest and largest
2717: * supported widths for aliased lines. The range must include 1. See
2718: * <code>glLineWidth</code>.
2719: *
2720: * <li><code>GL_ALPHA_BITS</code></li>
2721: *
2722: * <p><code>params</code> returns one value, the number of alpha
2723: * bitplanes in the color buffer.
2724: *
2725: * <li><code>GL_ALPHA_TEST_FUNC</code> (1.1 only)</li>
2726: *
2727: * <p><code>params</code> returns one value, the symbolic name of
2728: * the alpha test function. See <code>glAlphaFunc</code>.
2729: *
2730: * <li><code>GL_ALPHA_TEST_REF</code> (1.1 only)</li>
2731: *
2732: * <p><code>params</code> returns one value, the reference value for
2733: * the alpha test. An integer value, if requested, is linearly
2734: * mapped from the internal floating-point representation such that
2735: * 1.0 returns the most positive representable integer value, and
2736: * -1.0 returns the most negative representable integer value. See
2737: * <code>glAlphaFunc</code>.
2738: *
2739: * <li><code>GL_BLEND_DST</code> (1.1 only)</li>
2740: *
2741: * <p><code>params</code> returns one value, the symbolic constant
2742: * identifying the destination blend function set by
2743: * <code>glBlendFunc</code>, or the destination RGB blend function
2744: * set by <code>glBlendFuncSeparate</code>. See
2745: * <code>glBlendFunc</code> and <code>glBlendFuncSeparate</code>.
2746: *
2747: * <li><code>GL_BLUE_BITS</code></li>
2748: *
2749: * <p><code>params</code> returns one value, the number of blue
2750: * bitplanes in the color buffer.
2751: *
2752: * <li><code>GL_COLOR_ARRAY_BUFFER_BINDING</code> (1.1 only)</li>
2753: *
2754: * <p><code>params</code> returns one value, the color array buffer
2755: * binding. See <code>glColorPointer</code>.
2756: *
2757: * <li><code>GL_COLOR_ARRAY_SIZE</code> (1.1 only)</li>
2758: *
2759: * <p><code>params</code> returns one value, the number of
2760: * components per color in the color array. See
2761: * <code>glColorPointer</code>.
2762: *
2763: * <li><code>GL_COLOR_ARRAY_STRIDE</code> (1.1 only)</li>
2764: *
2765: * <p><code>params</code> returns one value, the byte offset between
2766: * consecutive colors in the color array. See
2767: * <code>glColorPointer</code>.
2768: *
2769: * <li><code>GL_COLOR_ARRAY_TYPE</code> (1.1 only)</li>
2770: *
2771: * <p><code>params</code> returns one value, returns the data type
2772: * of each component in the color array. See
2773: * <code>glColorPointer</code>.
2774: *
2775: * <li><code>GL_COLOR_CLEAR_VALUE</code> (1.1 only)</li>
2776: *
2777: * <p><code>params</code> returns four values: the red, green, blue,
2778: * and alpha values used to clear the color buffers. See
2779: * <code>glClearColor</code>
2780: *
2781: * <li><code>GL_COLOR_WRITEMASK</code> (1.1 only)</li>
2782: *
2783: * <p><code>params</code> returns four boolean values: the red,
2784: * green, blue, and alpha write enables for the color buffers. See
2785: * <code>glColorMask</code>.
2786: *
2787: * <li><code>GL_COMPRESSED_TEXTURE_FORMATS</code></li>
2788: *
2789: * <p><code>params</code> returns
2790: * <code>GL_NUM_COMPRESSED_TEXTURE_FORMATS</code> values, the
2791: * supported compressed texture formats. See glCompressedTexImage2D
2792: * and <code>glCompressedTexSubImage2D</code>.
2793: *
2794: * <li><code>GL_CULL_FACE</code> (1.1 only)</li>
2795: *
2796: * <p><code>params</code> returns one value, a symbolic constant
2797: * indicating which polygon faces are to be culled. See
2798: * <code>glCullFace</code>.
2799: *
2800: * <li><code>GL_DEPTH_BITS</code></li>
2801: *
2802: * <p><code>params</code> returns one value, the number of bitplanes in
2803: * the depth buffer.
2804: *
2805: * <li><code>GL_DEPTH_CLEAR_VALUE</code> (1.1 only)</li>
2806: *
2807: * <p><code>params</code> returns one value, the value that is used
2808: * to clear the depth buffer. See <code>glClearDepth</code>.
2809: *
2810: * <li><code>GL_DEPTH_FUNC</code> (1.1 only)</li>
2811: *
2812: * <p><code>params</code> returns one value, the symbolic name of
2813: * the depth comparision function. See <code>glDepthFunc</code>.
2814: *
2815: * <li><code>GL_DEPTH_RANGE</code> (1.1 only)</li>
2816: *
2817: * <p><code>params</code> returns two values: the near and far
2818: * mapping limits for the depth buffer. See
2819: * <code>glDepthRange</code>.
2820: *
2821: * <li><code>GL_DEPTH_WRITEMASK</code> (1.1 only)</li>
2822: *
2823: * <p><code>params</code> returns a single boolean value indicating
2824: * if the depth buffer is enabled for writing. See
2825: * <code>glDepthMask</code>.
2826: *
2827: * <li><code>GL_FOG_COLOR</code> (1.1 only)</li>
2828: *
2829: * <p><code>params</code> returns four values: the red, green, blue,
2830: * and alpha components of the fog color. See <code>glFog</code>.
2831: *
2832: * <li><code>GL_FOG_DENSITY</code> (1.1 only)</li>
2833: *
2834: * <p><code>params</code> returns one value, the fog density
2835: * parameter. See <code>glFog</code>.
2836: *
2837: * <li><code>GL_FOG_END</code> (1.1 only)</li>
2838: *
2839: * <p><code>params</code> returns one value, the end factor for the
2840: * linear fog equation. See <code>glFog</code>.
2841: *
2842: * <li><code>GL_FOG_HINT</code> (1.1 only)</li>
2843: *
2844: * <p><code>params</code> returns one value, a symbolic constant
2845: * indicating the mode of the fog hint. See <code>glHint</code>.
2846: *
2847: * <li><code>GL_FOG_MODE</code> (1.1 only)</li>
2848: *
2849: * <p><code>params</code> returns one value, a symbolic constant
2850: * indicating which fog equation is selected. See <code>glFog</code>.
2851: *
2852: * <li><code>GL_FOG_START</code> (1.1 only)</li>
2853: *
2854: * <p><code>params</code> returns one value, the start factor for
2855: * the linear fog equation. See <code>glFog</code>.
2856: *
2857: * <li><code>GL_FRONT_FACE</code> (1.1 only)</li>
2858: *
2859: * <p><code>params</code> returns one value, a symbolic constant
2860: * indicating whether clockwise or counterclockwise polygon winding
2861: * is treated as front-facing. See <code>glFrontFace</code>.
2862: *
2863: * <li><code>GL_GREEN_BITS</code></li>
2864: *
2865: * <p><code>params</code> returns one value, the number of green
2866: * bitplanes in the color buffer.
2867: *
2868: * <li><code>GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES</code>
2869: * (<code>OES_read_format</code> extension)</li>
2870: *
2871: * <p><code>params</code> returns one value, the preferred format for
2872: * pixel read back. See <code>glReadPixels</code>.
2873: *
2874: * <li><code>GL_IMPLEMENTATION_COLOR_READ_TYPE_OES</code> (
2875: * (<code>OES_read_format</code> extension)</li>
2876: *
2877: * <p><code>params</code> returns one value, the preferred type for
2878: * pixel read back. See <code>glReadPixels</code>.
2879: *
2880: * <li><code>GL_LIGHT_MODEL_AMBIENT</code> (1.1 only)</li>
2881: *
2882: * <p><code>params</code> returns four values: the red, green, blue,
2883: * and alpha components of the ambient intensity of the entire
2884: * scene. See <code>glLightModel</code>.
2885: *
2886: * <li><code>GL_LIGHT_MODEL_TWO_SIDE</code> (1.1 only)</li>
2887: *
2888: * <p><code>params</code> returns a single boolean value indicating
2889: * whether separate materials are used to compute lighting for front
2890: * and back facing polygons. See <code>glLightModel</code>.
2891: *
2892: * <li><code>GL_LINE_SMOOTH_HINT</code> (1.1 only)</li>
2893: *
2894: * <p><code>params</code> returns one value, a symbolic constant
2895: * indicating the mode of the line antialiasing hint. See
2896: * <code>glHint</code>.
2897: *
2898: * <li><code>GL_LINE_WIDTH</code> (1.1 only)</li>
2899: *
2900: * <p><code>params</code> returns one value, the line width as
2901: * specified with <code>glLineWidth</code>.
2902: *
2903: * <li><code>GL_LOGIC_OP_MODE</code> (1.1 only)</li>
2904: *
2905: * <p><code>params</code> returns one value, a symbolic constant
2906: * indicating the selected logic operation mode. See
2907: * <code>glLogicOp</code>.
2908: *
2909: * <li><code>GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES</code>
2910: * (<code>OES_matrix_palette</code> extension)</li>
2911: *
2912: * <p><code>params</code> returns one value, the matrix index array
2913: * buffer binding. See <code>glMatrixIndexPointer</code>.
2914: *
2915: * <li><code>GL_MATRIX_INDEX_ARRAY_SIZE_OES</code>
2916: * (<code>OES_matrix_palette</code> extension)</li>
2917: *
2918: * <p><code>params</code> returns one value, the number of matrix
2919: * indices per vertex. See <code>glMatrixIndexPointer</code>.
2920: *
2921: * <li><code>GL_MATRIX_INDEX_ARRAY_STRIDE_OES</code>
2922: * (<code>OES_matrix_palette</code> extension)</li>
2923: *
2924: * <p><code>params</code> returns one value, the byte offset between
2925: * matrix indices. See <code>glMatrixIndexPointer</code>.
2926: *
2927: * <li><code>GL_MATRIX_INDEX_ARRAY_TYPE_OES</code>
2928: * (<code>OES_matrix_palette</code> extension)</li>
2929: *
2930: * <p><code>params</code> returns one value, the data type of each
2931: * matrix index in the matrix indices array. See
2932: * <code>glMatrixIndexPointer</code>.
2933: *
2934: * <li><code>GL_MATRIX_MODE</code> (1.1 only)</li>
2935: *
2936: * <p><code>params</code> returns one value, a symbolic constant
2937: * indicating which matrix stack is currently the target of all
2938: * matrix operations. See <code>glMatrixMode</code>.
2939: *
2940: * <li><code>GL_MAX_CLIP_PLANES</code> (1.1 only)</li>
2941: *
2942: * <p><code>params</code> returns one value, the maximum number of
2943: * application defined clipping planes. The value must be at least
2944: * 6. See <code>glClipPlane</code>.
2945: *
2946: * <li><code>GL_MAX_ELEMENTS_INDICES</code></li>
2947: *
2948: * <p><code>params</code> returns one value, the recommended maximum
2949: * number of vertex array indices. See <code>glDrawElements</code>.
2950: *
2951: * <li><code>GL_MAX_ELEMENTS_VERTICES</code></li>
2952: *
2953: * <p><code>params</code> returns one value, the recommended maximum
2954: * number of vertex array vertices. See <code>glDrawArrays</code>
2955: * and <code>glDrawElements</code>.
2956: *
2957: * <li><code>GL_MAX_LIGHTS</code></li>
2958: *
2959: * <p><code>params</code> returns one value, the maximum number of
2960: * lights. The value must be at least 8. See <code>glLight</code>.
2961: *
2962: * <li><code>GL_MAX_MODELVIEW_STACK_DEPTH</code></li>
2963: *
2964: * <p><code>params</code> returns one value, the maximum supported
2965: * depth of the modelview matrix stack. The value must be at least
2966: * 16. See <code>glPushMatrix</code>.
2967: *
2968: * <li><code>GL_MAX_PALETTE_MATRICES_OES</code>
2969: * (<code>OES_matrix_palette</code> extension)</li>
2970: *
2971: * <p><code>params</code> returns the size of the matrix
2972: * palette. The initial value is 9.
2973: *
2974: * <li><code>GL_MAX_PROJECTION_STACK_DEPTH</code></li>
2975: *
2976: * <p><code>params</code> returns one value, the maximum supported
2977: * depth of the projection matrix stack. The value must be at least
2978: * 2. See <code>glPushMatrix</code>.
2979: *
2980: * <li><code>GL_MAX_TEXTURE_SIZE</code></li>
2981: *
2982: * <p><code>params</code> returns one value. The value gives a rough
2983: * estimate of the largest texture that the GL can handle. The value
2984: * must be at least 64. See <code>glTexImage2D</code>,
2985: * <code>glCompressedTexImage2D</code>, and
2986: * <code>glCopyTexImage2D</code>.
2987: *
2988: * <li><code>GL_MAX_TEXTURE_STACK_DEPTH</code></li>
2989: *
2990: * <p><code>params</code> returns one value, the maximum supported
2991: * depth of the texture matrix stack. The value must be at least
2992: * 2. See <code>glPushMatrix</code>.
2993: *
2994: * <li><code>GL_MAX_TEXTURE_UNITS</code></li>
2995: *
2996: * <p><code>params</code> returns a single value indicating the number
2997: * of texture units supported. The value must be at least 1. See
2998: * <code>glActiveTexture</code>, <code>glClientActiveTexture</code>
2999: * and <code>glMultiTexCoord</code>.
3000: *
3001: * <li><code>GL_MAX_VERTEX_UNITS_OES</code>
3002: *
3003: * <p><code>params</code> returns the number of matrices per
3004: * vertex. The initial value is 3.
3005: *
3006: * <li><code>GL_MAX_VIEWPORT_DIMS</code></li>
3007: *
3008: * <p><code>params</code> returns two values: the maximum supported
3009: * width and height of the viewport. These must be at least as large
3010: * as the visible dimensions of the display being rendered to. See
3011: * <code>glViewport</code>.
3012: *
3013: * <li><code>GL_MODELVIEW_MATRIX</code> (1.1 only)</li>
3014: *
3015: * <p><code>params</code> returns sixteen values: the modelview
3016: * matrix on the top of the modelview matrix stack. See
3017: * <code>glPushMatrix</code>.
3018: *
3019: * <li><code>GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES</code>
3020: * (<code>OES_matrix_get</code> extension)</li>
3021: *
3022: * <p><code>params</code> returns a representation of the floating
3023: * point Model View matrix elements as as an array of integers,
3024: * according to the IEEE 754 floating point "single format" bit
3025: * layout. See <code>glMatrixMode</code>.
3026: *
3027: * <li><code>GL_MODELVIEW_STACK_DEPTH</code> (1.1 only)</li>
3028: *
3029: * <p><code>params</code> returns one value, the number of matrices
3030: * on the modelview matrix stack. See <code>glPushMatrix</code>.
3031: *
3032: * <li><code>GL_NORMAL_ARRAY_BUFFER_BINDING</code> (1.1 only)</li>
3033: *
3034: * <p><code>params</code> returns one value, the normal array buffer
3035: * binding. See <code>glNormalPointer</code>.
3036: *
3037: * <li><code>GL_NORMAL_ARRAY_STRIDE</code> (1.1 only)</li>
3038: *
3039: * <p><code>params</code> returns one value, the byte offset between
3040: * consective normals in the normal array. See
3041: * <code>glNormalPointer</code>.
3042: *
3043: * <li><code>GL_NORMAL_ARRAY_TYPE</code> (1.1 only)</li>
3044: *
3045: * <p><code>params</code> returns one value, the data type of each
3046: * normal in the normal array. See <code>glNormalPointer</code>.
3047: *
3048: * <li><code>GL_NUM_COMPRESSED_TEXTURE_FORMATS</code></li>
3049: *
3050: * <p><code>params</code> returns one value, the number of supported
3051: * compressed texture formats. The value must be at least 10. See
3052: * <code>glCompressedTexImage2D</code> and
3053: * <code>glCompressedTexSubImage2D</code>.
3054: *
3055: * <li><code>GL_PACK_ALIGNMENT</code> (1.1 only)</li>
3056: *
3057: * <p><code>params</code> returns one value, the byte alignment used
3058: * for writing pixel data to memory. See <code>glPixelStore</code>.
3059: *
3060: * <li><code>GL_PERSPECTIVE_CORRECTION_HINT</code> (1.1 only)</li>
3061: *
3062: * <p><code>params</code> returns one value, a symbolic constant
3063: * indicating the mode of the perspective correction hint. See
3064: * <code>glHint</code>.
3065: *
3066: * <li><code>GL_POINT_SIZE</code> (1.1 only)</li>
3067: *
3068: * <p><code>params</code> returns one value, the point size as
3069: * specified by <code>glPointSize</code>.
3070: *
3071: * <li><code>GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES</code>
3072: * (<code>OES_point_size_array</code> extension)</li>
3073: *
3074: * <p><code>params</code> returns one value, the point size array
3075: * buffer binding. See <code>glPointSizePointer</code>.
3076: *
3077: * <li><code>GL_POINT_SIZE_ARRAY_STRIDE_OES</code>
3078: * (<code>OES_point_size_array</code> extension)</li>
3079: *
3080: * <p><code>params</code> returns one value, the byte offset between
3081: * consecutive point sizes in the point size array. See
3082: * <code>glPointSizePointer</code>.
3083: *
3084: * <li><code>GL_POINT_SIZE_ARRAY_TYPE_OES</code>
3085: * (<code>OES_point_size_array</code> extension)</li>
3086: *
3087: * <p><code>params</code> returns one value, the data type of each
3088: * point size in the point array. See
3089: * <code>glPointSizePointer</code>.
3090: *
3091: * <li><code>GL_POINT_SMOOTH_HINT</code> (1.1 only)</li>
3092: *
3093: * <p><code>params</code> returns one value, a symbolic constant
3094: * indicating the mode of the point antialiasing hint. See
3095: * <code>glHint</code>.
3096: *
3097: * <li><code>GL_POLYGON_OFFSET_FACTOR</code> (1.1 only)</li>
3098: *
3099: * <p><code>params</code> returns one value, the scaling factor used
3100: * to determine the variable offset that is added to the depth value
3101: * of each fragment generated when a polygon is rasterized. See
3102: * <code>glPolygonOffset</code>.
3103: *
3104: * <li><code>GL_POLYGON_OFFSET_UNITS</code> (1.1 only)</li>
3105: *
3106: * <p><code>params</code> returns one value. This value is
3107: * multiplied by an implementation-specific value and then added to
3108: * the depth value of each fragment generated when a polygon is
3109: * rasterized. See <code>glPolygonOffset</code>.
3110: *
3111: * <li><code>GL_PROJECTION_MATRIX</code> (1.1 only)</li>
3112: *
3113: * <p><code>params</code> returns sixteen values: the projection
3114: * matrix on the top of the projection matrix stack. See
3115: * <code>glPushMatrix</code>.
3116: *
3117: * <li><code>GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES</code>
3118: * (<code>OES_matrix_get</code> extension)</li>
3119: *
3120: * <p><code>params</code> returns a representation of the floating
3121: * point Projection matrix elements as as an array of integers,
3122: * according to the IEEE 754 floating point "single format" bit
3123: * layout. See <code>glMatrixMode</code>.
3124: *
3125: * <li><code>GL_PROJECTION_STACK_DEPTH</code> (1.1 only)</li>
3126: *
3127: * <p><code>params</code> returns one value, the number of matrices
3128: * on the projection matrix stack. See <code>glPushMatrix</code>.
3129: *
3130: * <li><code>GL_RED_BITS</code></li>
3131: *
3132: * <p><code>params</code> returns one value, the number of red
3133: * bitplanes in each color buffer.
3134: *
3135: * <li><code>GL_SCISSOR_BOX</code> (1.1 only)</li>
3136: *
3137: * <p><code>params</code> returns four values: the x and y window
3138: * coordinates of the scissor box, followed by its width and
3139: * height. See <code>glScissor</code>.
3140: *
3141: * <li><code>GL_SHADE_MODEL</code> (1.1 only)</li>
3142: *
3143: * <p><code>params</code> returns one value, a symbolic constant
3144: * indicating whether the shading mode is flat or smooth. See
3145: * <code>glShadeModel</code>.
3146: *
3147: * <li><code>GL_SMOOTH_LINE_WIDTH_RANGE</code></li>
3148: *
3149: * <p><code>params</code> returns two values, the smallest and largest
3150: * supported widths for antialiased lines. The range must include
3151: * 1. See <code>glLineWidth</code>.
3152: *
3153: * <li><code>GL_SMOOTH_POINT_SIZE_RANGE</code></li>
3154: *
3155: * <p><code>params</code> returns two values, the smallest and largest
3156: * supported widths for antialiased points. The range must include
3157: * 1. See <code>glPointSize</code>.
3158: *
3159: * <li><code>GL_STENCIL_BITS</code></li>
3160: *
3161: * <p><code>params</code> returns one value, the number of bitplanes in
3162: * the stencil buffer.
3163: *
3164: * <li><code>GL_STENCIL_CLEAR_VALUE</code> (1.1 only)</li>
3165: *
3166: * <p><code>params</code> returns one value, the index to which the
3167: * stencil bitplanes are cleared. See <code>glClearStencil</code>.
3168: *
3169: * <li><code>GL_STENCIL_FAIL</code> (1.1 only)</li>
3170: *
3171: * <p><code>params</code> returns one value, a symbolic constant
3172: * indicating what action is taken when the stencil test fails. See
3173: * <code>glStencilOp</code>.
3174: *
3175: * <li><code>GL_STENCIL_FUNC</code> (1.1 only)</li>
3176: *
3177: * <p><code>params</code> returns one value, a symbolic constant
3178: * indicating what function is used to compare the stencil reference
3179: * value with the stencil buffer value. See
3180: * <code>glStencilFunc</code>.
3181: *
3182: * <li><code>GL_STENCIL_PASS_DEPTH_FAIL</code> (1.1 only)</li>
3183: *
3184: * <p><code>params</code> returns one value, a symbolic constant
3185: * indicating what action is taken when the stencil test passes, but
3186: * the depth test fails. See <code>glStencilOp</code>.
3187: *
3188: * <li><code>GL_STENCIL_PASS_DEPTH_PASS</code> (1.1 only)</li>
3189: *
3190: * <p><code>params</code> returns one value, a symbolic constant
3191: * indicating what action is taken when the stencil test passes, and
3192: * the depth test passes. See <code>glStencilOp</code>.
3193: *
3194: * <li><code>GL_STENCIL_REF</code> (1.1 only)</li>
3195: *
3196: * <p><code>params</code> returns one value, the reference value
3197: * that is compared with the contents of the stencil buffer. See
3198: * <code>glStencilFunc</code>.
3199: *
3200: * <li><code>GL_STENCIL_VALUE_MASK</code> (1.1 only)</li>
3201: *
3202: * <p><code>params</code> returns one value, the mask that is used
3203: * to mask both the stencil reference value and the stencil buffer
3204: * value before they are compared. See <code>glStencilFunc</code>.
3205: *
3206: * <li><code>GL_STENCIL_WRITEMASK</code> (1.1 only)</li>
3207: *
3208: * <p><code>params</code> returns one value, the mask that controls
3209: * writing of the stencil bitplanes. See <code>glStencilMask</code>.
3210: *
3211: * <li><code>GL_SUBPIXEL_BITS</code></li>
3212: *
3213: * <p><code>params</code> returns one value, an estimate of the number
3214: * of bits of subpixel resolution that are used to position
3215: * rasterized geometry in window coordinates. The value must be at
3216: * least 4.
3217: *
3218: * <li><code>GL_TEXTURE_BINDING_2D</code> (1.1 only)</li>
3219: *
3220: * <p><code>params</code> returns one value, the name of the texture
3221: * currently bound to the target <code>GL_TEXTURE_2D</code>. See
3222: * <code>glBindTexture</code>.
3223: *
3224: * <li><code>GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING</code> (1.1 only)</li>
3225: *
3226: * <p><code>params</code> returns one value, the texture coordinate
3227: * array buffer binding. See <code>glTexCoordPointer</code>.
3228: *
3229: * <li><code>GL_TEXTURE_COORD_ARRAY_SIZE</code> (1.1 only)</li>
3230: *
3231: * <p><code>params</code> returns one value, the number of
3232: * coordinates per element in the texture coordinate array. See
3233: * <code>glTexCoordPointer</code>.
3234: *
3235: * <li><code>GL_TEXTURE_COORD_ARRAY_STRIDE</code> (1.1 only)</li>
3236: *
3237: * <p><code>params</code> returns one value, the byte offset between
3238: * consecutive elements in the texture coordinate array. See
3239: * <code>glTexCoordPointer</code>.
3240: *
3241: * <li><code>GL_TEXTURE_COORD_ARRAY_TYPE</code> (1.1 only)</li>
3242: *
3243: * <p><code>params</code> returns one value, returns the data type
3244: * of each coordinate in the texture coordinate array. See
3245: * <code>glTexCoordPointer</code>.
3246: *
3247: * <li><code>GL_TEXTURE_MATRIX</code> (1.1 only)</li>
3248: *
3249: * <p><code>params</code> returns sixteen values: the texture matrix
3250: * on the top of the texture matrix stack. See
3251: * <code>glPushMatrix</code>.
3252: *
3253: * <li><code>GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES</code>
3254: * (<code>OES_matrix_get</code> extension)</li>
3255: *
3256: * <p><code>params</code> returns a representation of the floating
3257: * point Texture matrix elements as as an array of integers,
3258: * according to the IEEE 754 floating point "single format" bit
3259: * layout. See <code>glMatrixMode</code>.
3260: *
3261: * <li><code>GL_TEXTURE_STACK_DEPTH</code> (1.1 only)</li>
3262: *
3263: * <p><code>params</code> returns one value, the number of matrices
3264: * on the texture matrix stack. See <code>glBindTexture</code>.
3265: *
3266: * <li><code>GL_UNPACK_ALIGNMENT</code> (1.1 only)</li>
3267: *
3268: * <p><code>params</code> returns one value, the byte alignment used
3269: * for reading pixel data from memory. See
3270: * <code>glPixelStore</code>.
3271: *
3272: * <li><code>GL_VIEWPORT</code> (1.1 only)</li>
3273: *
3274: * <p><code>params</code> returns four values:, the x and y window
3275: * coordinates of the viewport, followed by its width and
3276: * height. See <code>glViewport</code>.
3277: *
3278: * <li><code>GL_VERTEX_ARRAY_BUFFER_BINDING</code> (1.1 only)</li>
3279: *
3280: * <p><code>params</code> returns one value, the vertex array buffer
3281: * binding. See <code>glVertexPointer</code>.
3282: *
3283: * <li><code>GL_VERTEX_ARRAY_SIZE</code> (1.1 only)</li>
3284: *
3285: * <p><code>params</code> returns one value, number of coordinates
3286: * per vertex in the vertex array. See <code>glVertexPointer</code>.
3287: *
3288: * <li><code>GL_VERTEX_ARRAY_STRIDE</code> (1.1 only)</li>
3289: *
3290: * <p><code>params</code> returns one value, the byte offset between
3291: * consecutive vertexes in the vertex array. See
3292: * <code>glVertexPointer</code>.
3293: *
3294: * <li><code>GL_VERTEX_ARRAY_TYPE</code> (1.1 only)</li>
3295: *
3296: * <p><code>params</code> returns one value, returns the data type
3297: * of each coordinate in the vertex array. See
3298: * <code>glVertexPointer</code>.
3299: *
3300: * <li><code>GL_WEIGHT_ARRAY_BUFFER_BINDING_OES</code>
3301: * (<code>OES_matrix_palette</code> extension)</li>
3302: *
3303: * <p><code>params</code> returns one value, the weight array buffer
3304: * binding. See <code>glWeightPointer</code>.
3305: *
3306: * <li><code>GL_WEIGHT_ARRAY_SIZE_OES</code>
3307: * (<code>OES_matrix_palette</code> extension)</li>
3308: *
3309: * <p><code>params</code> returns one value, the number of weights
3310: * per vertex. See <code>glWeightPointer</code>.
3311: *
3312: * <li><code>GL_WEIGHT_ARRAY_STRIDE_OES</code>
3313: * (<code>OES_matrix_palette</code> extension)</li>
3314: *
3315: * <p><code>params</code> returns one value, the byte offset between
3316: * weights per vertex. See <code>glWeightPointer</code>.
3317: *
3318: * <li><code>GL_WEIGHT_ARRAY_TYPE_OES</code>
3319: * (<code>OES_matrix_palette</code> extension)</li>
3320: *
3321: * <p><code>params</code> returns one value, the data type of each
3322: * weight in the weight array. See <code>glWeightPointer</code>.
3323: *
3324: * </ul>
3325: *
3326: * <h4>Errors</h4>
3327: *
3328: * <p><code>GL_INVALID_ENUM</code> is generated if <code>pname</code>
3329: * is not an accepted value.
3330: *
3331: * @param pname Specifies the parameter value to be returned. The
3332: * symbolic constants in the list above are accepted.
3333: * @param params Returns the value or values of the specified
3334: * parameter.
3335: * @param offset the starting offset within the
3336: * <code>params</code> array.
3337: *
3338: * @exception IllegalArgumentException if <code>params</code> is
3339: * <code>null</code>.
3340: * @exception IllegalArgumentException if <code>offset</code> is
3341: * less than 0.
3342: * @exception IllegalArgumentException if <code>params.length -
3343: * offset</code> is smaller than the number of values required by
3344: * the parameter.
3345: */
3346: void glGetIntegerv(int pname, int[] params, int offset);
3347:
3348: /**
3349: * Integer <code>Buffer</code> version of <code>glGetIntegerv</code>.
3350: *
3351: * @see #glGetIntegerv(int pname, int[] params, int offset)
3352: *
3353: * @exception IllegalArgumentException if <code>params</code> is
3354: * <code>null</code>.
3355: * @exception IllegalArgumentException if
3356: * <code>params.remaining()</code> is smaller than the number of
3357: * values required by the parameter.
3358: */
3359: void glGetIntegerv(int pname, IntBuffer params);
3360:
3361: /**
3362: * Return a string describing the underlying GL implementation. The
3363: * GL string is converted to UTF8 format to produce a standard Java
3364: * <code>String</code> object.
3365: *
3366: * <p><code>glGetString</code> returns a <code>String</code>
3367: * describing some aspect of the current GL
3368: * implementation. <code>name</code> can be one of the following:
3369: *
3370: * <ul>
3371: *
3372: * <li><code>GL_VENDOR</code></li>
3373: *
3374: * <p>Returns the company responsible for this GL implementation. This
3375: * name does not change from release to release.
3376: *
3377: * <li><code>GL_RENDERER</code></li>
3378: *
3379: * <p>Returns the name of the renderer. This name is typically specific
3380: * to a particular configuration of a hardware platform. It does not
3381: * change from release to release.
3382: *
3383: * <li><code>GL_VERSION</code></li>
3384: *
3385: * <p>Returns the particular OpenGL ES profile as well as the
3386: * version of that profile.
3387: *
3388: * <li><code>GL_EXTENSIONS</code></li>
3389: *
3390: * <p>Returns a space-separated list of supported extensions to GL.
3391: *
3392: * </ul>
3393: *
3394: * <p>Because the GL does not include queries for the performance
3395: * characteristics of an implementation, some applications are
3396: * written to recognize known platforms and modify their GL usage
3397: * based on known performance characteristics of these
3398: * platforms. Strings <code>GL_VENDOR</code> and
3399: * <code>GL_RENDERER</code> together uniquely specify a
3400: * platform. They do not change from release to release and should
3401: * be used by platform-recognition algorithms.
3402: *
3403: * <p>Some applications want to make use of features that are not part
3404: * of the standard GL. These features may be implemented as
3405: * extensions to the standard GL. The <code>GL_EXTENSIONS</code>
3406: * string is a space-separated list of supported GL
3407: * extensions. (Extension names never contain a space character.)
3408: *
3409: * <p>The <code>GL_VERSION</code> string begins with a version
3410: * number. The version number uses one of these forms:
3411: *
3412: * <p><i>major_number.minor_number</i> (1.0 only)
3413: * <p><i>major_number.minor_number.release_number</i> (1.0 only)
3414: * <p><i>OpenGL ES-CM</i> followed by
3415: * <i>major_number.minor_number</i> for the common profile (1.1 only).
3416: * <p><i>OpenGL ES-CL</i> followed by <i>major_number.minor_number</i> for
3417: * the common-lite profile (1.1 only).
3418: *
3419: * <p>On 1.0 implementations, vendor-specific information may
3420: * follow the version number. A space always separates the version
3421: * number and the vendor-specific information.
3422: *
3423: * <h4>Notes</h4>
3424: *
3425: * <p>If an error is generated, <code>glGetString</code> returns NULL.
3426: *
3427: * <p>The client and server may support different versions or
3428: * extensions. <code>glGetString</code> always returns a compatible
3429: * version number or list of extensions. The release number always
3430: * describes the server.
3431: *
3432: * <h4>Errors</h4>
3433: *
3434: * <p><code>GL_INVALID_ENUM</code> is generated if <code>name</code>
3435: * is not an accepted value.
3436: *
3437: * @param name Specifies a symbolic constant, one of
3438: * <code>GL_VENDOR</code>, <code>GL_RENDERER</code>,
3439: * <code>GL_VERSION</code>, or <code>GL_EXTENSIONS</code>.
3440: *
3441: * @return A <code>String</code> formatted as described above.
3442: */
3443: String glGetString(int name);
3444:
3445: /**
3446: * Specify implementation-specific hints.
3447: *
3448: * <p>Certain aspects of GL behavior, when there is room for
3449: * interpretation, can be controlled with hints. A hint is specified
3450: * with two arguments. <code>target</code> is a symbolic constant
3451: * indicating the behavior to be controlled, and <code>mode</code>
3452: * is another symbolic constant indicating the desired behavior. The
3453: * initial value for each <code>target</code> is
3454: * <code>GL_DONT_CARE</code>. <code>mode</code> can be one of the
3455: * following:
3456: *
3457: * <ul>
3458: *
3459: * <li><code>GL_FASTEST</code></li>
3460: *
3461: * <p>The most efficient option should be chosen.
3462: *
3463: * <li><code>GL_NICEST</code></li>
3464: *
3465: * <p>The most correct, or highest quality, option should be chosen.
3466: *
3467: * <li><code>GL_DONT_CARE</code></li>
3468: *
3469: * <p>No preference.
3470: *
3471: * </ul>
3472: *
3473: * <p>Though the implementation aspects that can be hinted are well
3474: * defined, the interpretation of the hints depends on the
3475: * implementation. The hint aspects that can be specified with
3476: * <code>target</code>, along with suggested semantics, are as follows:
3477: *
3478: * <ul>
3479: *
3480: * <li><code>GL_FOG_HINT</code></li>
3481: *
3482: * <p>Indicates the accuracy of fog calculation. If per-pixel fog
3483: * calculation is not efficiently supported by the GL
3484: * implementation, hinting <code>GL_DONT_CARE</code> or
3485: * <code>GL_FASTEST</code> can result in per-vertex calculation of
3486: * fog effects.
3487: *
3488: * <li><code>GL_LINE_SMOOTH_HINT</code></li>
3489: *
3490: * <p>Indicates the sampling quality of antialiased lines. If a larger
3491: * filter function is applied, hinting <code>GL_NICEST</code> can
3492: * result in more pixel fragments being generated during
3493: * rasterization,
3494: *
3495: * <li><code>GL_PERSPECTIVE_CORRECTION_HINT</code></li>
3496: *
3497: * <p>Indicates the quality of color and texture coordinate
3498: * interpolation. If perspective-corrected parameter interpolation
3499: * is not efficiently supported by the GL implementation, hinting
3500: * <code>GL_DONT_CARE</code> or <code>GL_FASTEST</code> can result
3501: * in simple linear interpolation of colors and/or texture
3502: * coordinates.
3503: *
3504: * <li><code>GL_POINT_SMOOTH_HINT</code></li>
3505: *
3506: * <p>Indicates the sampling quality of antialiased points. If a larger
3507: * filter function is applied, hinting <code>GL_NICEST</code> can
3508: * result in more pixel fragments being generated during
3509: * rasterization.
3510: *
3511: * <li><code>GL_GENERATE_MIPMAP_HINT</code> (1.1 only)</li>
3512: *
3513: * <p>Indicates the desired quality and performance of automatic
3514: * mipmap level generation.
3515: *
3516: * </ul>
3517: *
3518: * <h4>Notes</h4>
3519: *
3520: * <p>The interpretation of hints depends on the implementation. Some
3521: * implementations ignore <code>glHint</code> settings.
3522: *
3523: * <h4>Errors</h4>
3524: *
3525: * <p><code>GL_INVALID_ENUM</code> is generated if either
3526: * <code>target</code> or <code>mode</code> is not an accepted
3527: * value.
3528: *
3529: * @param target Specifies a symbolic constant indicating the
3530: * behavior to be controlled. <code>GL_FOG_HINT</code> ,
3531: * <code>GL_LINE_SMOOTH_HINT</code> ,
3532: * <code>GL_PERSPECTIVE_CORRECTION_HINT</code>, and
3533: * <code>GL_POINT_SMOOTH_HINT</code> are accepted. On 1.1,
3534: * <code>GL_GENERATE_MIPMAP_HINT</code> is additionally accepted.
3535: * @param mode Specifies a symbolic constant indicating the desired
3536: * behavior. <code>GL_FASTEST</code>, <code>GL_NICEST</code>, and
3537: * <code>GL_DONT_CARE</code> are accepted.
3538: */
3539: void glHint(int target, int mode);
3540:
3541: /**
3542: * Set the lighting model parameters.
3543: *
3544: * <p><code>glLightModel</code> sets the lighting model
3545: * parameter. <code>pname</code> names a parameter and param gives
3546: * the new value. There is one single-valued lighting model parameter:
3547: *
3548: * <ul>
3549: *
3550: * <li><code>GL_LIGHT_MODEL_TWO_SIDE</code></li>
3551: *
3552: * <p><code>param</code> specifies whether one- or two-sided lighting
3553: * calculations are done for polygons. It has no effect on the
3554: * lighting calculations for points, lines, or bitmaps. If
3555: * <code>param</code> is 0, one-sided lighting is specified, and
3556: * only the front material parameters are used in the lighting
3557: * equation. Otherwise, two-sided lighting is specified. In this
3558: * case, vertices of back-facing polygons are lighted using the back
3559: * material parameters, and have their normals reversed before the
3560: * lighting equation is evaluated. Vertices of front-facing polygons
3561: * are always lighted using the front material parameters, with no
3562: * change to their normals. The initial value is 0.
3563: *
3564: * </ul>
3565: *
3566: * <h4>Errors</h4>
3567: *
3568: * <p><code>GL_INVALID_ENUM</code> is generated if
3569: * <code>pname</code> is not an accepted value.
3570: *
3571: * @param pname Specifies a single-valued lighting model
3572: * parameter. Must be <code>GL_LIGHT_MODEL_TWO_SIDE</code>.
3573: * @param param Specifies the value that <code>param</code> will be
3574: * set to.
3575: */
3576: void glLightModelf(int pname, float param);
3577:
3578: /**
3579: * Set the lighting model parameters (array version).
3580: *
3581: * <p><code>glLightModel</code> sets the lighting model
3582: * parameter. <code>pname</code> names a parameter and
3583: * <code>params</code> gives the new value. There are two lighting
3584: * model parameters:
3585: *
3586: * <ul>
3587: *
3588: * <li><code>GL_LIGHT_MODEL_AMBIENT</code></li>
3589: *
3590: * <p><code>params</code> contains four values that specify the ambient
3591: * intensity of the entire scene. The values are not clamped. The
3592: * initial value is (0.2, 0.2, 0.2, 1.0).
3593: *
3594: * <li><code>GL_LIGHT_MODEL_TWO_SIDE</code></li>
3595: *
3596: * <p><code>params</code> contains a single value that specifies
3597: * whether one- or two-sided lighting calculations are done for
3598: * polygons. It has no effect on the lighting calculations for
3599: * points, lines, or bitmaps. If <code>params</code> contains 0,
3600: * one-sided lighting is specified, and only the front material
3601: * parameters are used in the lighting equation. Otherwise,
3602: * two-sided lighting is specified. In this case, vertices of
3603: * back-facing polygons are lighted using the back material
3604: * parameters, and have their normals reversed before the lighting
3605: * equation is evaluated. Vertices of front-facing polygons are
3606: * always lighted using the front material parameters, with no
3607: * change to their normals. The initial value is 0.
3608: *
3609: * </ul>
3610: *
3611: * <p>The lighted color of a vertex is the sum of the material
3612: * emission intensity, the product of the material ambient
3613: * reflectance and the lighting model full-scene ambient intensity,
3614: * and the contribution of each enabled light source. Each light
3615: * source contributes the sum of three terms: ambient, diffuse, and
3616: * specular. The ambient light source contribution is the product of
3617: * the material ambient reflectance and the light's ambient
3618: * intensity. The diffuse light source contribution is the product
3619: * of the material diffuse reflectance, the light's diffuse
3620: * intensity, and the dot product of the vertex's normal with the
3621: * normalized vector from the vertex to the light source. The
3622: * specular light source contribution is the product of the material
3623: * specular reflectance, the light's specular intensity, and the dot
3624: * product of the normalized vertex-to-eye and vertex-to-light
3625: * vectors, raised to the power of the shininess of the
3626: * material. All three light source contributions are attenuated
3627: * equally based on the distance from the vertex to the light source
3628: * and on light source direction, spread exponent, and spread cutoff
3629: * angle. All dot products are replaced with 0 if they evaluate to a
3630: * negative value.
3631: *
3632: * <p>The alpha component of the resulting lighted color is set to the
3633: * alpha value of the material diffuse reflectance.
3634: *
3635: * <h4>Errors</h4>
3636: *
3637: * <p><code>GL_INVALID_ENUM</code> is generated if
3638: * <code>pname</code> is not an accepted value.
3639: *
3640: * @param pname Specifies a lighting model
3641: * parameter. <code>GL_LIGHT_MODEL_AMBIENT</code> and
3642: * <code>GL_LIGHT_MODEL_TWO_SIDE</code> are accepted.
3643: * @param params Specifies an array containing values that parameter
3644: * <code>pname</code> will be set to.
3645: * @param offset the starting offset within the
3646: * <code>params</code> array.
3647: *
3648: * @exception IllegalArgumentException if <code>params</code> is
3649: * <code>null</code>.
3650: * @exception IllegalArgumentException if <code>offset</code> is
3651: * less than 0.
3652: * @exception IllegalArgumentException if <code>params.length -
3653: * offset</code> is smaller than the number of values required by
3654: * the parameter.
3655: */
3656: void glLightModelfv(int pname, float[] params, int offset);
3657:
3658: /**
3659: * Floating-point <code>Buffer</code> version of <code>glLightModel</code>.
3660: *
3661: * @see #glLightModelfv(int pname, float[] params, int offset)
3662: *
3663: * @exception IllegalArgumentException if <code>params</code> is
3664: * <code>null</code>.
3665: * @exception IllegalArgumentException if
3666: * <code>params.remaining()</code> is smaller than the number of
3667: * values required by the parameter.
3668: */
3669: void glLightModelfv(int pname, FloatBuffer params);
3670:
3671: /**
3672: * Fixed-point version of <code>glLightModel</code>.
3673: *
3674: * @see #glLightModelf(int pname, float param)
3675: */
3676: void glLightModelx(int pname, int param);
3677:
3678: /**
3679: * Fixed-point array version of <code>glLightModel</code>.
3680: *
3681: * @see #glLightModelfv(int pname, float[] params, int offset)
3682: *
3683: * @exception IllegalArgumentException if <code>params</code> is
3684: * <code>null</code>.
3685: * @exception IllegalArgumentException if <code>offset</code> is
3686: * less than 0.
3687: * @exception IllegalArgumentException if <code>params.length -
3688: * offset</code> is smaller than the number of values required by
3689: * the parameter.
3690: */
3691: void glLightModelxv(int pname, int[] params, int offset);
3692:
3693: /**
3694: * Fixed-point <code>Buffer</code> version of <code>glLightModel</code>.
3695: *
3696: * @see #glLightModelfv(int pname, float[] params, int offset)
3697: *
3698: * @exception IllegalArgumentException if <code>params</code> is
3699: * <code>null</code>.
3700: * @exception IllegalArgumentException if
3701: * <code>params.remaining()</code> is smaller than the number of
3702: * values required by the parameter.
3703: */
3704: void glLightModelxv(int pname, IntBuffer params);
3705:
3706: /**
3707: * Set light source parameters.
3708: *
3709: * <p><code>glLight</code> sets the values of individual light
3710: * source parameters. <code>light</code> names the light and is a
3711: * symbolic name of the form <code>GL_LIGHT</code><i>i</i>, where
3712: * <code>0 <= <i>i</i> < GL_MAX_LIGHTS</code>. <code>pname</code>
3713: * specifies one of ten light source parameters, again by symbolic
3714: * name. <code>param</code> contains the new value.
3715: *
3716: * <p>To enable and disable lighting calculation, call
3717: * <code>glEnable</code> and <code>glDisable</code> with argument
3718: * <code>GL_LIGHTING</code>. Lighting is initially disabled. When it
3719: * is enabled, light sources that are enabled contribute to the
3720: * lighting calculation. Light source <i>i</i> is enabled and disabled
3721: * using <code>glEnable</code> and <code>glDisable</code> with
3722: * argument <code>GL_LIGHT</code><i>i</i>.
3723: *
3724: * <p>The light parameters are as follows:
3725: *
3726: * <ul>
3727: *
3728: * <li><code>GL_SPOT_EXPONENT</code></li>
3729: *
3730: * <p><code>param</code> is a single value that specifies the
3731: * intensity distribution of the light. Fixed-point and
3732: * floating-point values are mapped directly. Only values in the
3733: * range [0, 128] are accepted.
3734: *
3735: * <p>Effective light intensity is attenuated by the cosine of the
3736: * angle between the direction of the light and the direction from
3737: * the light to the vertex being lighted, raised to the power of the
3738: * spot exponent. Thus, higher spot exponents result in a more
3739: * focused light source, regardless of the spot cutoff angle (see
3740: * <code>GL_SPOT_CUTOFF</code>, next paragraph). The initial spot
3741: * exponent is 0, resulting in uniform light distribution.
3742: *
3743: * <li><code>GL_SPOT_CUTOFF</code></li>
3744: *
3745: * <p><code>param</code> is a single value that specifies the maximum
3746: * spread angle of a light source. Fixed-point and floating-point
3747: * values are mapped directly. Only values in the range [0, 90] and
3748: * the special value 180 are accepted. If the angle between the
3749: * direction of the light and the direction from the light to the
3750: * vertex being lighted is greater than the spot cutoff angle, the
3751: * light is completely masked. Otherwise, its intensity is
3752: * controlled by the spot exponent and the attenuation factors. The
3753: * initial spot cutoff is 180, resulting in uniform light
3754: * distribution.
3755: *
3756: * <li><code>GL_CONSTANT_ATTENUATION</code>,
3757: * <code>GL_LINEAR_ATTENUATION</code>,
3758: * <code>GL_QUADRATIC_ATTENUATION</code></li>
3759: *
3760: * <p><code>param</code> is a single value that specifies one of the
3761: * three light attenuation factors. Fixed-point and floating-point
3762: * values are mapped directly. Only nonnegative values are
3763: * accepted. If the light is positional, rather than directional,
3764: * its intensity is attenuated by the reciprocal of the sum of the
3765: * constant factor, the linear factor times the distance between the
3766: * light and the vertex being lighted, and the quadratic factor
3767: * times the square of the same distance. The initial attenuation
3768: * factors are (1, 0, 0), resulting in no attenuation.
3769: *
3770: * </ul>
3771: *
3772: * <h4>Notes</h4>
3773: *
3774: * <p>It is always the case that <code>GL_LIGHT</code><i>i</i> =
3775: * <code>GL_LIGHT0</code> + <i>i</i>.
3776: *
3777: * <h4>Errors</h4>
3778: *
3779: * <p><code>GL_INVALID_ENUM</code> is generated if either
3780: * <code>light</code> or <code>pname</code> is not an accepted
3781: * value.
3782: *
3783: * <p><code>GL_INVALID_VALUE</code> is generated if a spot exponent
3784: * value is specified outside the range [0, 128], or if spot cutoff
3785: * is specified outside the range [0, 90] (except for the special
3786: * value 180), or if a negative attenuation factor is specified.
3787: *
3788: * @param light Specifies a light. The number of lights depends on
3789: * the implementation, but at least eight lights are supported. They
3790: * are identified by symbolic names of the form
3791: * <code>GL_LIGHT</code><i>i</i> where <code>0 <= <i>i</i> <
3792: * GL_MAX_LIGHTS</code>.
3793: * @param pname Specifies a single-valued light source parameter for
3794: * light. <code>GL_SPOT_EXPONENT</code>,
3795: * <code>GL_SPOT_CUTOFF</code>,
3796: * <code>GL_CONSTANT_ATTENUATION</code>,
3797: * <code>GL_LINEAR_ATTENUATION</code>, and
3798: * <code>GL_QUADRATIC_ATTENUATION</code> are accepted.
3799: * @param param Specifies the value that parameter
3800: * <code>pname</code> of light source light will be set to.
3801: */
3802: void glLightf(int light, int pname, float param);
3803:
3804: /**
3805: * Set light source parameters (array version).
3806: *
3807: * <p><code>glLight</code> sets the values of individual light
3808: * source parameters. <code>light</code> names the light and is a
3809: * symbolic name of the form <code>GL_LIGHT</code><i>i</i>, where
3810: * <code>0 <= <i>i</i> < GL_MAX_LIGHTS</code>. <code>pname</code>
3811: * specifies one of ten light source parameters, again by symbolic
3812: * name. <code>params</code> is an array that contains the new
3813: * values.
3814: *
3815: * <p>To enable and disable lighting calculation, call
3816: * <code>glEnable</code> and <code>glDisable</code> with argument
3817: * <code>GL_LIGHTING</code>. Lighting is initially disabled. When it
3818: * is enabled, light sources that are enabled contribute to the
3819: * lighting calculation. Light source <i>i</i> is enabled and disabled
3820: * using <code>glEnable</code> and <code>glDisable</code> with
3821: * argument <code>GL_LIGHT</code><i>i</i>.
3822: *
3823: * <p>The light parameters are as follows:
3824: *
3825: * <ul>
3826: *
3827: * <li><code>GL_AMBIENT</code></li>
3828: *
3829: * <p><code>params</code> contains four values that specify the ambient
3830: * RGBA intensity of the light. Both fixed-point and floating-point
3831: * values are mapped directly. Neither fixed-point nor
3832: * floating-point values are clamped. The initial ambient light
3833: * intensity is (0, 0, 0, 1).
3834: *
3835: * <li><code>GL_DIFFUSE</code></li>
3836: *
3837: * <p><code>params</code> contains four values that specify the diffuse
3838: * RGBA intensity of the light. Both fixed-point and floating-point
3839: * values are mapped directly. Neither fixed-point nor
3840: * floating-point values are clamped. The initial value for
3841: * <code>GL_LIGHT0</code> is (1, 1, 1, 1). For other lights, the
3842: * initial value is (0, 0, 0, 0).
3843: *
3844: * <li><code>GL_SPECULAR</code></li>
3845: *
3846: * <p><code>params</code> contains four values that specify the
3847: * specular RGBA intensity of the light. Both fixed-point and
3848: * floating-point values are mapped directly. Neither fixed-point
3849: * nor floating-point values are clamped. The initial value for
3850: * <code>GL_LIGHT0</code> is (1, 1, 1, 1). For other lights, the
3851: * initial value is (0, 0, 0, 0).
3852: *
3853: * <li><code>GL_POSITION</code> (1.0 only)</li>
3854: *
3855: * <p><code>params</code> contains four values that specify the
3856: * position of the light in homogeneous object coordinates. Both
3857: * fixed-point and floating-point values are mapped
3858: * directly. Neither fixed-point nor floating-point values are
3859: * clamped.
3860: *
3861: * <p>The position is transformed by the modelview matrix when
3862: * <code>glLight</code> is called (just as if it were a point), and
3863: * it is stored in eye coordinates. If the w component of the
3864: * position is 0, the light is treated as a directional
3865: * source. Diffuse and specular lighting calculations take the
3866: * light's direction, but not its actual position, into account, and
3867: * attenuation is disabled. Otherwise, diffuse and specular lighting
3868: * calculations are based on the actual location of the light in eye
3869: * coordinates, and attenuation is enabled. The initial position is
3870: * (0, 0, 1, 0). Thus, the initial light source is directional,
3871: * parallel to, and in the direction of the -z axis.
3872: *
3873: * <li><code>GL_SPOT_DIRECTION</code></li>
3874: *
3875: * <p><code>params</code> contains three values that specify the
3876: * direction of the light in homogeneous object coordinates. Both
3877: * fixed-point and floating-point values are mapped
3878: * directly. Neither fixed-point nor floating-point values are
3879: * clamped.
3880: *
3881: * <p>The spot direction is transformed by the inverse of the modelview
3882: * matrix when <code>glLight</code> is called (just as if it were a
3883: * normal), and it is stored in eye coordinates. It is significant
3884: * only when <code>GL_SPOT_CUTOFF</code> is not 180, which it is
3885: * initially. The initial direction is (0, 0, -1).
3886: *
3887: * <li><code>GL_SPOT_EXPONENT</code></li>
3888: *
3889: * <p><code>params</code> is a single value that specifies the
3890: * intensity distribution of the light. Fixed-point and
3891: * floating-point values are mapped directly. Only values in the
3892: * range [0, 128] are accepted.
3893: *
3894: * <p>Effective light intensity is attenuated by the cosine of the
3895: * angle between the direction of the light and the direction from
3896: * the light to the vertex being lighted, raised to the power of the
3897: * spot exponent. Thus, higher spot exponents result in a more
3898: * focused light source, regardless of the spot cutoff angle (see
3899: * <code>GL_SPOT_CUTOFF</code>, next paragraph). The initial spot
3900: * exponent is 0, resulting in uniform light distribution.
3901: *
3902: * <li><code>GL_SPOT_CUTOFF</code></li>
3903: *
3904: * <p><code>params</code> is a single value that specifies the maximum
3905: * spread angle of a light source. Fixed-point and floating-point
3906: * values are mapped directly. Only values in the range [0, 90] and
3907: * the special value 180 are accepted. If the angle between the
3908: * direction of the light and the direction from the light to the
3909: * vertex being lighted is greater than the spot cutoff angle, the
3910: * light is completely masked. Otherwise, its intensity is
3911: * controlled by the spot exponent and the attenuation factors. The
3912: * initial spot cutoff is 180, resulting in uniform light
3913: * distribution.
3914: *
3915: * <li><code>GL_CONSTANT_ATTENUATION</code>,
3916: * <code>GL_LINEAR_ATTENUATION</code>,
3917: * <code>GL_QUADRATIC_ATTENUATION</code></li>
3918: *
3919: * <p><code>params</code> is a single value that specifies one of the
3920: * three light attenuation factors. Fixed-point and floating-point
3921: * values are mapped directly. Only nonnegative values are
3922: * accepted. If the light is positional, rather than directional,
3923: * its intensity is attenuated by the reciprocal of the sum of the
3924: * constant factor, the linear factor times the distance between the
3925: * light and the vertex being lighted, and the quadratic factor
3926: * times the square of the same distance. The initial attenuation
3927: * factors are (1, 0, 0), resulting in no attenuation.
3928: *
3929: * </ul>
3930: *
3931: * <h4>Notes</h4>
3932: *
3933: * <p>It is always the case that <code>GL_LIGHT</code><i>i</i> =
3934: * <code>GL_LIGHT0</code> + <i>i</i>.
3935: *
3936: * <h4>Errors</h4>
3937: *
3938: * <p><code>GL_INVALID_ENUM</code> is generated if either
3939: * <code>light</code> or <code>pname</code> is not an accepted
3940: * value.
3941: *
3942: * <p><code>GL_INVALID_VALUE</code> is generated if a spot exponent
3943: * value is specified outside the range [0, 128], or if spot cutoff
3944: * is specified outside the range [0, 90] (except for the special
3945: * value 180), or if a negative attenuation factor is specified.
3946: *
3947: * @param light Specifies a light. The number of lights depends on
3948: * the implementation, but at least eight lights are supported. They
3949: * are identified by symbolic names of the form
3950: * <code>GL_LIGHT</code><i>i</i> where <code>0 <= <i>i</i> <
3951: * GL_MAX_LIGHTS</code>.
3952: * @param pname Specifies a light source parameter for
3953: * light. <code>GL_AMBIENT</code>, <code>GL_DIFFUSE</code>,
3954: * <code>GL_SPECULAR</code>, <code>GL_POSITION</code> (1.0 only),
3955: * <code>GL_SPOT_CUTOFF</code>, <code>GL_SPOT_DIRECTION</code>,
3956: * <code>GL_SPOT_EXPONENT</code>,
3957: * <code>GL_CONSTANT_ATTENUATION</code>,
3958: * <code>GL_LINEAR_ATTENUATION</code>, and
3959: * <code>GL_QUADRATIC_ATTENUATION</code> are accepted.
3960: * @param params Specifies an array containing values that parameter
3961: * <code>pname</code> of light source light will be set to.
3962: * @param offset the starting offset within the
3963: * <code>params</code> array.
3964: *
3965: * @exception IllegalArgumentException if <code>params</code> is
3966: * <code>null</code>.
3967: * @exception IllegalArgumentException if <code>offset</code> is
3968: * less than 0.
3969: * @exception IllegalArgumentException if <code>params.length -
3970: * offset</code> is smaller than the number of values required by
3971: * the parameter.
3972: */
3973: void glLightfv(int light, int pname, float[] params, int offset);
3974:
3975: /**
3976: * Floating-point <code>Buffer</code> version of <code>glLight</code>.
3977: *
3978: * @see #glLightfv(int light, int pname, float[] params, int offset)
3979: *
3980: * @exception IllegalArgumentException if <code>params</code> is
3981: * <code>null</code>.
3982: * @exception IllegalArgumentException if
3983: * <code>params.remaining()</code> is smaller than the number of
3984: * values required by the parameter.
3985: */
3986: void glLightfv(int light, int pname, FloatBuffer params);
3987:
3988: /**
3989: * Fixed-point version of <code>glLight</code>.
3990: *
3991: * @see #glLightf(int light, int pname, float param)
3992: */
3993: void glLightx(int light, int pname, int param);
3994:
3995: /**
3996: * Fixed-point array version of <code>glLight</code>.
3997: *
3998: * @see #glLightfv(int light, int pname, float[] params, int offset)
3999: *
4000: * @exception IllegalArgumentException if <code>params</code> is
4001: * <code>null</code>.
4002: * @exception IllegalArgumentException if <code>offset</code> is
4003: * less than 0.
4004: * @exception IllegalArgumentException if <code>params.length -
4005: * offset</code> is smaller than the number of values required by
4006: * the parameter.
4007: */
4008: void glLightxv(int light, int pname, int[] params, int offset);
4009:
4010: /**
4011: * Fixed-point <code>Buffer</code> version of <code>glLight</code>.
4012: *
4013: * @see #glLightfv(int light, int pname, float[] params, int offset)
4014: *
4015: * @exception IllegalArgumentException if <code>params</code> is
4016: * <code>null</code>.
4017: * @exception IllegalArgumentException if
4018: * <code>params.remaining()</code> is smaller than the number of
4019: * values required by the parameter.
4020: */
4021: void glLightxv(int light, int pname, IntBuffer params);
4022:
4023: /**
4024: * Specify the width of rasterized lines.
4025: *
4026: * <p><code>glLineWidth</code> specifies the rasterized width of
4027: * both aliased and antialiased lines. Using a line width other than
4028: * 1 has different effects, depending on whether line antialiasing
4029: * is enabled. To enable and disable line antialiasing, call
4030: * <code>glEnable</code> and <code>glDisable</code> with argument
4031: * <code>GL_LINE_SMOOTH</code>. Line antialiasing is initially
4032: * disabled.
4033: *
4034: * <p>If line antialiasing is disabled, the actual width is
4035: * determined by rounding the supplied width to the nearest
4036: * integer. (If the rounding results in the value 0, it is as if the
4037: * line width were 1.) If <code>|delta x| >= |delta y|</code>,
4038: * <i>i</i> pixels are filled in each column that is rasterized,
4039: * where <i>i</i> is the rounded value of
4040: * <code>width</code>. Otherwise, <i>i</i> pixels are filled in each
4041: * row that is rasterized.
4042: *
4043: * <p>If antialiasing is enabled, line rasterization produces a
4044: * fragment for each pixel square that intersects the region lying
4045: * within the rectangle having width equal to the current line
4046: * width, length equal to the actual length of the line, and
4047: * centered on the mathematical line segment. The coverage value for
4048: * each fragment is the window coordinate area of the intersection
4049: * of the rectangular region with the corresponding pixel
4050: * square. This value is saved and used in the final rasterization
4051: * step.
4052: *
4053: * <p>Not all widths can be supported when line antialiasing is
4054: * enabled. If an unsupported width is requested, the nearest
4055: * supported width is used. Only width 1 is guaranteed to be
4056: * supported; others depend on the implementation. Likewise, there
4057: * is a range for aliased line widths as well. To query the range of
4058: * supported widths and the size difference between supported widths
4059: * within the range, call <code>glGetIntegerv</code> with arguments
4060: * <code>GL_ALIASED_LINE_WIDTH_RANGE</code>,
4061: * <code>GL_SMOOTH_LINE_WIDTH_RANGE</code>,
4062: * <code>GL_SMOOTH_LINE_WIDTH_GRANULARITY</code>.
4063: *
4064: * <h4>Notes</h4>
4065: *
4066: * <p>Nonantialiased line width may be clamped to an
4067: * implementation-dependent maximum. Call <code>glGetIntegerv</code>
4068: * with <code>GL_ALIASED_LINE_WIDTH_RANGE</code> to determine the
4069: * maximum width.
4070: *
4071: * <h4>Errors</h4>
4072: *
4073: * <p><code>GL_INVALID_VALUE</code> is generated if width is less
4074: * than or equal to 0.
4075: *
4076: * <h4>Associated Gets</h4>
4077: *
4078: * <p><code>glGetIntegerv</code> with argument
4079: * <code>GL_ALIASED_LINE_WIDTH_RANGE</code>
4080: *
4081: * <p><code>glGetIntegerv</code> with argument
4082: * <code>GL_SMOOTH_LINE_WIDTH_RANGE</code>
4083: *
4084: * @param width Specifies the width of rasterized lines. The initial
4085: * value is 1.
4086: */
4087: void glLineWidth(float width);
4088:
4089: /**
4090: * Fixed-point version of <code>glLineWidth</code>.
4091: *
4092: * @see #glLineWidth
4093: */
4094: void glLineWidthx(int width);
4095:
4096: /**
4097: * Replace the current matrix with the identity matrix.
4098: *
4099: * <p><code>glLoadIdentity</code> replaces the current matrix with
4100: * the identity matrix. It is semantically equivalent to calling
4101: * glLoadMatrix with the identity matrix
4102: *
4103: * <pre>
4104: * ( 1 0 0 0 )
4105: * ( 0 1 0 0 )
4106: * ( 0 0 1 0 )
4107: * ( 0 0 0 1 )
4108: * </pre>
4109: *
4110: * but in some cases it is more efficient.
4111: */
4112: void glLoadIdentity();
4113:
4114: /**
4115: * Replace the current matrix with the specified matrix.
4116: *
4117: * <p><code>glLoadMatrix</code> replaces the current matrix with the
4118: * one whose elements are specified by <code>m</code>. The current
4119: * matrix is the projection matrix, modelview matrix, or texture
4120: * matrix, depending on the current matrix mode (see glMatrixMode).
4121: *
4122: * <p>The current matrix, <code>M</code>, defines a transformation
4123: * of coordinates. For instance, assume <code>M</code> refers to the
4124: * modelview matrix. If <code>v = (v[0], v[1], v[2], v[3])</code> is
4125: * the set of object coordinates of a vertex, and <code>m</code> is
4126: * an array of 16 fixed-point or single-precision floating-point
4127: * values <code>m[0]</code>, <code>m[1]</code>, ...,
4128: * <code>m[15]</code>, then the modelview transformation
4129: * <code>M(v)</code> does the following:
4130: *
4131: * <pre>
4132: * ( m[0] m[4] m[8] m[12] ) ( v[0] )
4133: * M(v) = ( m[1] m[5] m[9] m[13] ) x ( v[1] )
4134: * ( m[2] m[6] m[10] m[14] ) ( v[2] )
4135: * ( m[3] m[7] m[11] m[15] ) ( v[3] )
4136: * </pre>
4137: *
4138: * where "x" denotes matrix multiplication.
4139: *
4140: * <p>Projection and texture transformations are similarly defined.
4141: *
4142: * <h4>Notes</h4>
4143: *
4144: * <p>While the elements of the matrix may be specified with single or
4145: * double precision, the GL implementation may store or operate on
4146: * these values in less than single precision.
4147: *
4148: * @param m Specifies an array of at least 16 consecutive values,
4149: * the first 16 of which are used as the elements of a 4 × 4
4150: * column-major matrix.
4151: * @param offset the starting offset within the
4152: * <code>m</code> array.
4153: *
4154: * @exception IllegalArgumentException if <code>m</code> is
4155: * <code>null</code>.
4156: * @exception IllegalArgumentException if <code>offset</code> is
4157: * less than 0.
4158: * @exception IllegalArgumentException if <code>m.length -
4159: * offset</code> is less than 16.
4160: */
4161: void glLoadMatrixf(float[] m, int offset);
4162:
4163: /**
4164: * Floating-point <code>Buffer</code> version of <code>glLoadMatrix</code>.
4165: *
4166: * @see #glLoadMatrixf(float[] m, int offset)
4167: *
4168: * @exception IllegalArgumentException if <code>m</code> is
4169: * <code>null</code>.
4170: * @exception IllegalArgumentException if <code>m.remaining()</code>
4171: * is less than 16.
4172: */
4173: void glLoadMatrixf(FloatBuffer m);
4174:
4175: /**
4176: * Fixed-point array version of <code>glLoadMatrix</code>.
4177: *
4178: * @see #glLoadMatrixf(float[] m, int offset)
4179: *
4180: * @exception IllegalArgumentException if <code>m</code> is
4181: * <code>null</code>.
4182: * @exception IllegalArgumentException if <code>offset</code> is
4183: * less than 0.
4184: * @exception IllegalArgumentException if <code>m.length -
4185: * offset</code> is less than 16.
4186: */
4187: void glLoadMatrixx(int[] m, int offset);
4188:
4189: /**
4190: * Fixed-point <code>Buffer</code> version of <code>glLoadMatrix</code>.
4191: *
4192: * @see #glLoadMatrixf(float[] m, int offset)
4193: *
4194: * @exception IllegalArgumentException if <code>m</code> is
4195: * <code>null</code>.
4196: * @exception IllegalArgumentException if <code>m.remaining()</code>
4197: * is less than 16.
4198: */
4199: void glLoadMatrixx(IntBuffer m);
4200:
4201: /**
4202: * Specify a logical pixel operation.
4203: *
4204: * <p><code>glLogicOp</code> specifies a logical operation that,
4205: * when enabled, is applied between the incoming color and the color
4206: * at the corresponding location in the frame buffer. To enable or
4207: * disable the logical operation, call <code>glEnable</code> and
4208: * <code>glDisable</code> with argument
4209: * <code>GL_COLOR_LOGIC_OP</code>. Logical operation is initially
4210: * disabled.
4211: *
4212: * <pre>
4213: * Opcode Resulting Operation
4214: *
4215: * GL_CLEAR 0
4216: * GL_SET 1
4217: * GL_COPY s
4218: * GL_COPY_INVERTED ~ s
4219: * GL_NOOP d
4220: * GL_INVERT ~ d
4221: * GL_AND s & d
4222: * GL_NAND ~ (s & d)
4223: * GL_OR s | d
4224: * GL_NOR ~ (s | d)
4225: * GL_XOR s ^ d
4226: * GL_EQUIV ~ (s ^ d)
4227: * GL_AND_REVERSE s & ~ d
4228: * GL_AND_INVERTED ~ s & d
4229: * GL_OR_REVERSE s | ~ d
4230: * GL_OR_INVERTED ~ s | d
4231: * </pre>
4232: *
4233: * <p><code>opcode</code> is a symbolic constant chosen from the
4234: * list above. In the explanation of the logical operations,
4235: * <i>s</i> represents the incoming color and <i>d</i> represents
4236: * the color in the frame buffer. As in the Java language, "~"
4237: * represents bitwise negation, "&" represents bitwise AND, "|"
4238: * represents bitwise OR, and "^" represents bitwise XOR. As these
4239: * bitwise operators suggest, the logical operation is applied
4240: * independently to each bit pair of the source and destination
4241: * indices or colors.
4242: *
4243: * <h4>Errors</h4>
4244: *
4245: * <p><code>GL_INVALID_ENUM</code> is generated if opcode is not an
4246: * accepted value.
4247: *
4248: * @param opcode Specifies a symbolic constant that selects a
4249: * logical operation. The following symbols are accepted:
4250: * <code>GL_CLEAR</code>, <code>GL_SET</code>, <code>GL_COPY</code>,
4251: * <code>GL_COPY_INVERTED</code>, <code>GL_NOOP</code>,
4252: * <code>GL_INVERT</code>, <code>GL_AND</code>,
4253: * <code>GL_NAND</code>, <code>GL_OR</code>, <code>GL_NOR</code>,
4254: * <code>GL_XOR</code>, <code>GL_EQUIV</code>,
4255: * <code>GL_AND_REVERSE</code>, <code>GL_AND_INVERTED</code>,
4256: * <code>GL_OR_REVERSE</code>, and <code>GL_OR_INVERTED</code>. The
4257: * initial value is <code>GL_COPY</code>.
4258: */
4259: void glLogicOp(int opcode);
4260:
4261: /**
4262: * Specify material parameters for the lighting model.
4263: *
4264: * <p><code>glMaterial</code> assigns values to material
4265: * parameters. There are two matched sets of material
4266: * parameters. One, the front-facing set, is used to shade points,
4267: * lines, and all polygons (when two-sided lighting is disabled), or
4268: * just front-facing polygons (when two-sided lighting is
4269: * enabled). The other set, back-facing, is used to shade
4270: * back-facing polygons only when two-sided lighting is
4271: * enabled. Refer to the <code>glLightModel</code> reference page
4272: * for details concerning one- and two-sided lighting calculations.
4273: *
4274: * <p><code>glMaterial</code> takes three arguments. The first,
4275: * face, must be <code>GL_FRONT_AND_BACK</code> and specifies that
4276: * both front and back materials will be modified. The second,
4277: * pname, specifies which of several parameters in one or both sets
4278: * will be modified. The third, params, specifies what value or
4279: * values will be assigned to the specified parameter.
4280: *
4281: * <p>Material parameters are used in the lighting equation that is
4282: * optionally applied to each vertex. The equation is discussed in
4283: * the <code>glLightModel</code> reference page. The parameters that
4284: * can be specified using <code>glMaterial</code>, and their
4285: * interpretations by the lighting equation, are as follows:
4286: *
4287: * <ul>
4288: *
4289: * <li><code>GL_AMBIENT</code></li>
4290: *
4291: * <p><code>params</code> contains four fixed-point or
4292: * floating-point values that specify the ambient RGBA reflectance
4293: * of the material. The values are not clamped. The initial ambient
4294: * reflectance is (0.2, 0.2, 0.2, 1.0).
4295: *
4296: * <li><code>GL_DIFFUSE</code></li>
4297: *
4298: * <p><code>params</code> contains four fixed-point or
4299: * floating-point values that specify the diffuse RGBA reflectance
4300: * of the material. The values are not clamped. The initial diffuse
4301: * reflectance is (0.8, 0.8, 0.8, 1.0).
4302: *
4303: * <li><code>GL_SPECULAR</code></li>
4304: *
4305: * <p><code>params</code> contains four fixed-point or
4306: * floating-point values that specify the specular RGBA reflectance
4307: * of the material. The values are not clamped. The initial specular
4308: * reflectance is (0, 0, 0, 1).
4309: *
4310: * <li><code>GL_EMISSION</code></li>
4311: *
4312: * <p><code>params</code> contains four fixed-point or
4313: * floating-point values that specify the RGBA emitted light
4314: * intensity of the material. The values are not clamped. The
4315: * initial emission intensity is (0, 0, 0, 1).
4316: *
4317: * <li><code>GL_SHININESS</code></li>
4318: *
4319: * <p><code>params</code> is a single fixed-point or floating-point
4320: * value that specifies the RGBA specular exponent of the
4321: * material. Only values in the range [0, 128] are accepted. The
4322: * initial specular exponent is 0.
4323: *
4324: * <li><code>GL_AMBIENT_AND_DIFFUSE</code></li>
4325: *
4326: * <p>Equivalent to calling <code>glMaterial</code> twice with the same
4327: * parameter values, once with <code>GL_AMBIENT</code> and once with
4328: * <code>GL_DIFFUSE</code>.
4329: *
4330: * </ul>
4331: *
4332: * <h4>Notes</h4>
4333: *
4334: * <p>To change the diffuse and ambient material per vertex, color
4335: * material can be used. To enable and disable
4336: * <code>GL_COLOR_MATERIAL</code>, call <code>glEnable</code> and
4337: * <code>glDisable</code> with argument
4338: * <code>GL_COLOR_MATERIAL</code>. Color material is initially
4339: * disabled.
4340: *
4341: * <p>While the ambient, diffuse, specular and emission material
4342: * parameters all have alpha components, only the diffuse alpha
4343: * component is used in the lighting computation.
4344: *
4345: * <h4>Errors</h4>
4346: *
4347: * <p><code>GL_INVALID_ENUM</code> is generated if either face or
4348: * <code>pname</code> is not an accepted value.
4349: *
4350: * <p><code>GL_INVALID_VALUE</code> is generated if a specular
4351: * exponent outside the range [0, 128] is specified.
4352: *
4353: * @param face Specifies which face or faces are being updated. Must
4354: * be <code>GL_FRONT_AND_BACK</code>.
4355: * @param pname Specifies the single-valued material parameter of
4356: * the face or faces that is being updated. Must be
4357: * <code>GL_SHININESS</code>.
4358: * @param param Specifies the value that parameter
4359: * <code>GL_SHININESS</code> will be set to.
4360: */
4361: void glMaterialf(int face, int pname, float param);
4362:
4363: /**
4364: * Specify material parameters for the lighting model (array
4365: * version).
4366: *
4367: * <p><code>glMaterial</code> assigns values to material
4368: * parameters. There are two matched sets of material
4369: * parameters. One, the front-facing set, is used to shade points,
4370: * lines, and all polygons (when two-sided lighting is disabled), or
4371: * just front-facing polygons (when two-sided lighting is
4372: * enabled). The other set, back-facing, is used to shade
4373: * back-facing polygons only when two-sided lighting is
4374: * enabled. Refer to the <code>glLightModel</code> reference page
4375: * for details concerning one- and two-sided lighting calculations.
4376: *
4377: * <p><code>glMaterial</code> takes three arguments. The first,
4378: * face, must be <code>GL_FRONT_AND_BACK</code> and specifies that
4379: * both front and back materials will be modified. The second,
4380: * pname, specifies which of several parameters in one or both sets
4381: * will be modified. The third, params, specifies what value or
4382: * values will be assigned to the specified parameter.
4383: *
4384: * <p>Material parameters are used in the lighting equation that is
4385: * optionally applied to each vertex. The equation is discussed in
4386: * the <code>glLightModel</code> reference page. The parameters that
4387: * can be specified using <code>glMaterial</code>, and their
4388: * interpretations by the lighting equation, are as follows:
4389: *
4390: * <ul>
4391: *
4392: * <li><code>GL_AMBIENT</code></li>
4393: *
4394: * <p><code>params</code> contains four fixed-point or
4395: * floating-point values that specify the ambient RGBA reflectance
4396: * of the material. The values are not clamped. The initial ambient
4397: * reflectance is (0.2, 0.2, 0.2, 1.0).
4398: *
4399: * <li><code>GL_DIFFUSE</code></li>
4400: *
4401: * <p><code>params</code> contains four fixed-point or
4402: * floating-point values that specify the diffuse RGBA reflectance
4403: * of the material. The values are not clamped. The initial diffuse
4404: * reflectance is (0.8, 0.8, 0.8, 1.0).
4405: *
4406: * <li><code>GL_SPECULAR</code></li>
4407: *
4408: * <p><code>params</code> contains four fixed-point or
4409: * floating-point values that specify the specular RGBA reflectance
4410: * of the material. The values are not clamped. The initial specular
4411: * reflectance is (0, 0, 0, 1).
4412: *
4413: * <li><code>GL_EMISSION</code></li>
4414: *
4415: * <p><code>params</code> contains four fixed-point or
4416: * floating-point values that specify the RGBA emitted light
4417: * intensity of the material. The values are not clamped. The
4418: * initial emission intensity is (0, 0, 0, 1).
4419: *
4420: * <li><code>GL_SHININESS</code></li>
4421: *
4422: * <p><code>params</code> is a single fixed-point or floating-point
4423: * value that specifies the RGBA specular exponent of the
4424: * material. Only values in the range [0, 128] are accepted. The
4425: * initial specular exponent is 0.
4426: *
4427: * <li><code>GL_AMBIENT_AND_DIFFUSE</code></li>
4428: *
4429: * <p>Equivalent to calling <code>glMaterial</code> twice with the same
4430: * parameter values, once with <code>GL_AMBIENT</code> and once with
4431: * <code>GL_DIFFUSE</code>.
4432: *
4433: * </ul>
4434: *
4435: * <h4>Notes</h4>
4436: *
4437: * <p>To change the diffuse and ambient material per vertex, color
4438: * material can be used. To enable and disable
4439: * <code>GL_COLOR_MATERIAL</code>, call <code>glEnable</code> and
4440: * <code>glDisable</code> with argument
4441: * <code>GL_COLOR_MATERIAL</code>. Color material is initially
4442: * disabled.
4443: *
4444: * <p>While the ambient, diffuse, specular and emission material
4445: * parameters all have alpha components, only the diffuse alpha
4446: * component is used in the lighting computation.
4447: *
4448: * <h4>Errors</h4>
4449: *
4450: * <p><code>GL_INVALID_ENUM</code> is generated if either face or
4451: * <code>pname</code> is not an accepted value.
4452: *
4453: * <p><code>GL_INVALID_VALUE</code> is generated if a specular
4454: * exponent outside the range [0, 128] is specified.
4455: *
4456: * @param face Specifies which face or faces are being updated. Must
4457: * be <code>GL_FRONT_AND_BACK</code>.
4458: * @param pname Specifies the material parameter of the face or
4459: * faces that is being updated. Must be one of
4460: * <code>GL_AMBIENT</code>, <code>GL_DIFFUSE</code>,
4461: * <code>GL_SPECULAR</code>, <code>GL_EMISSION</code>,
4462: * <code>GL_SHININESS</code>, or
4463: * <code>GL_AMBIENT_AND_DIFFUSE</code>.
4464: * @param params Specifies a pointer to the value or values that
4465: * <code>pname</code> will be set to.
4466: * @param offset the starting offset within the
4467: * <code>params</code> array.
4468: *
4469: * @exception IllegalArgumentException if <code>params</code> is
4470: * <code>null</code>.
4471: * @exception IllegalArgumentException if <code>offset</code> is
4472: * less than 0.
4473: * @exception IllegalArgumentException if <code>params.length -
4474: * offset</code> is smaller than the number of values required by
4475: * the parameter.
4476: */
4477: void glMaterialfv(int face, int pname, float[] params, int offset);
4478:
4479: /**
4480: * Floating-point <code>Buffer</code> version of <code>glMaterial</code>.
4481: *
4482: * @see #glMaterialfv(int face, int pname, float[] params, int offset)
4483: *
4484: * @exception IllegalArgumentException if <code>params</code> is
4485: * <code>null</code>.
4486: * @exception IllegalArgumentException if
4487: * <code>params.remaining()</code> is smaller than the number of
4488: * values required by the parameter.
4489: */
4490: void glMaterialfv(int face, int pname, FloatBuffer params);
4491:
4492: /**
4493: * Fixed-point version of <code>glMaterial</code>.
4494: *
4495: * @see #glMaterialf(int face, int pname, float param)
4496: */
4497: void glMaterialx(int face, int pname, int param);
4498:
4499: /**
4500: * Fixed-point array version of <code>glMaterial</code>.
4501: *
4502: * @see #glMaterialfv(int face, int pname, float[] params, int offset)
4503: *
4504: * @exception IllegalArgumentException if <code>params</code> is
4505: * <code>null</code>.
4506: * @exception IllegalArgumentException if <code>offset</code> is
4507: * less than 0.
4508: * @exception IllegalArgumentException if <code>params.length -
4509: * offset</code> is smaller than the number of values required by
4510: * the parameter.
4511: */
4512: void glMaterialxv(int face, int pname, int[] params, int offset);
4513:
4514: /**
4515: * Fixed-point <code>Buffer</code> version of <code>glMaterial</code>.
4516: *
4517: * @see #glMaterialfv(int face, int pname, float[] params, int offset)
4518: *
4519: * @exception IllegalArgumentException if <code>params</code> is
4520: * <code>null</code>.
4521: * @exception IllegalArgumentException if
4522: * <code>params.remaining()</code> is smaller than the number of
4523: * values required by the parameter.
4524: */
4525: void glMaterialxv(int face, int pname, IntBuffer params);
4526:
4527: /**
4528: * Specify which matrix is the current matrix.
4529: *
4530: * <p><code>glMatrixMode</code> sets the current matrix mode. mode
4531: * can assume one of three values:
4532: *
4533: * <ul>
4534: *
4535: * <li><code>GL_MODELVIEW</code></li>
4536: *
4537: * <p>Applies subsequent matrix operations to the modelview matrix
4538: * stack.
4539: *
4540: * <li><code>GL_PROJECTION</code></li>
4541: *
4542: * <p>Applies subsequent matrix operations to the projection matrix
4543: * stack.
4544: *
4545: * <li><code>GL_TEXTURE</code></li>
4546: *
4547: * <p>Applies subsequent matrix operations to the texture matrix stack.
4548: *
4549: * <li><code>GL_MATRIX_PALETTE_OES</code>
4550: * (<code>OES_matrix_palette</code> extension)</li>
4551: *
4552: * <p>Enables the matrix palette stack extension, and applies
4553: * subsequent matrix operations to the matrix palette stack.
4554: *
4555: * </ul>
4556: *
4557: * <h4>Errors</h4>
4558: *
4559: * <p><code>GL_INVALID_ENUM</code> is generated if mode is not an
4560: * accepted value.
4561: *
4562: * @param mode Specifies which matrix stack is the target for
4563: * subsequent matrix operations. These values are accepted:
4564: * <code>GL_MODELVIEW</code>, <code>GL_PROJECTION</code>, and
4565: * <code>GL_TEXTURE</code>. In the <code>OES_matrix_palette</code>
4566: * extension is available, <code>GL_MATRIX_PALETTE_OES</code> is
4567: * additionally accepted. The initial value is
4568: * <code>GL_MODELVIEW</code>.
4569: */
4570: void glMatrixMode(int mode);
4571:
4572: /**
4573: * Multiply the current matrix with the specified matrix.
4574: *
4575: * <p><code>glMultMatrix</code> multiplies the current matrix with
4576: * the one specified using m, and replaces the current matrix with
4577: * the product.
4578: *
4579: * <p>The current matrix is determined by the current matrix mode (see
4580: * glMatrixMode). It is either the projection matrix, modelview
4581: * matrix, or the texture matrix.
4582: *
4583: * <h4>Examples</h4>
4584: *
4585: * <p>If the current matrix is <code>C</code>, and the coordinates
4586: * to be transformed are, <code>v</code> = (<code>v[0]</code>,
4587: * <code>v[1]</code>, <code>v[2]</code>, <code>v[3]</code>), then
4588: * the current transformation is <code>C x v</code>, or
4589: *
4590: * <pre>
4591: * ( c[0] c[4] c[8] c[12] ) ( v[0] )
4592: * ( c[1] c[5] c[9] c[13] ) x ( v[1] )
4593: * ( c[2] c[6] c[10] c[14] ) ( v[2] )
4594: * ( c[3] c[7] c[11] c[15] ) ( v[3] )
4595: * </pre>
4596: *
4597: * <p>Calling <code>glMultMatrix</code> with an argument of
4598: * <code>m</code> = <code>m[0]</code>, <code>m[1]</code>, ...,
4599: * <code>m[15]</code> replaces the current transformation with
4600: * <code>(C x M) x v</code>, or
4601: *
4602: * <pre>
4603: * ( c[0] c[4] c[8] c[12] ) ( m[0] m[4] m[8] m[12] ) ( v[0] )
4604: * ( c[1] c[5] c[9] c[13] ) x ( m[1] m[5] m[9] m[13] ) x ( v[1] )
4605: * ( c[2] c[6] c[10] c[14] ) ( m[2] m[6] m[10] m[14] ) ( v[2] )
4606: * ( c[3] c[7] c[11] c[15] ) ( m[3] m[7] m[11] m[15] ) ( v[3] )
4607: * </pre>
4608: *
4609: * <p>where "x" denotes matrix multiplication, and <code>v</code> is
4610: * represented as a 4 × 1 matrix.
4611: *
4612: * <h4>Notes</h4>
4613: *
4614: * <p>While the elements of the matrix may be specified with single or
4615: * double precision, the GL may store or operate on these values in
4616: * less than single precision.
4617: *
4618: * <p>The array elements are passed in as a one-dimensional
4619: * array in column-major order. The order of the multiplication
4620: * is important. For example, if the current transformation is a
4621: * rotation, and <code>glMultMatrix</code> is called with a
4622: * translation matrix, the translation is done directly on the
4623: * coordinates to be transformed, while the rotation is done on the
4624: * results of that translation.
4625: *
4626: * @param m Specifies an array of at least 16 consecutive values,
4627: * the first 16 of which are used as the elements of a 4 × 4
4628: * column-major matrix.
4629: * @param offset the starting offset within the
4630: * <code>m</code> array.
4631: *
4632: * @exception IllegalArgumentException if <code>m</code> is
4633: * <code>null</code>.
4634: * @exception IllegalArgumentException if <code>offset</code> is
4635: * less than 0.
4636: * @exception IllegalArgumentException if <code>m.length -
4637: * offset</code> is less than 16.
4638: */
4639: void glMultMatrixf(float[] m, int offset);
4640:
4641: /**
4642: * Floating-point <code>Buffer</code> version of <code>glMultMatrix</code>.
4643: *
4644: * @see #glMultMatrixf(float[] m, int offset)
4645: *
4646: * @exception IllegalArgumentException if <code>m</code> is
4647: * <code>null</code>.
4648: * @exception IllegalArgumentException if <code>m.remaining()</code>
4649: * is less than 16.
4650: */
4651: void glMultMatrixf(FloatBuffer m);
4652:
4653: /**
4654: * Fixed-point array version of <code>glMultMatrix</code>.
4655: *
4656: * @see #glMultMatrixf(float[] m, int offset)
4657: *
4658: * @exception IllegalArgumentException if <code>m</code> is
4659: * <code>null</code>.
4660: * @exception IllegalArgumentException if <code>offset</code> is
4661: * less than 0.
4662: * @exception IllegalArgumentException if <code>m.length -
4663: * offset</code> is less than 16.
4664: */
4665: void glMultMatrixx(int[] m, int offset);
4666:
4667: /** Fixed-point <code>Buffer</code> version of <code>glMultMatrix</code>.
4668: *
4669: * @see #glMultMatrixf(float[] m, int offset)
4670: *
4671: * @exception IllegalArgumentException if <code>m</code> is
4672: * <code>null</code>.
4673: * @exception IllegalArgumentException if <code>m.remaining()</code>
4674: * is less than 16.
4675: */
4676: void glMultMatrixx(IntBuffer m);
4677:
4678: /**
4679: * Set the current texture coordinates.
4680: *
4681: * <p><code>glMultiTexCoord</code> specifies the four texture
4682: * coordinates as <code>(s, t, r, q)</code>.
4683: *
4684: * <p>The current texture coordinates are part of the data that is
4685: * associated with each vertex.
4686: *
4687: * <h4>Notes</h4>
4688: *
4689: * <p>It is always the case that <code>GL_TEXTURE</code><i>i</i> =
4690: * <code>GL_TEXTURE0</code> + <i>i</i>.
4691: *
4692: * <h4>Associated Gets</h4>
4693: *
4694: * <p><code>glGetIntegerv</code> with argument
4695: * <code>GL_MAX_TEXTURE_UNITS</code>.
4696: *
4697: * @param target Specifies texture unit whose coordinates should be
4698: * modified. The number of texture units is implementation
4699: * dependent, but must be at least one. Must be one of
4700: * <code>GL_TEXTURE</code><i>i</i>, where <code>0 <= <i>i</i> <
4701: * GL_MAX_TEXTURE_UNITS</code>, which is an implementation-dependent
4702: * value.
4703: * @param s Specifies an s texture coordinate for target texture
4704: * unit. The initial value is 0.
4705: * @param t Specifies a t texture coordinate for
4706: * target texture unit. The initial value is 0.
4707: * @param r Specifies an r texture coordinate for
4708: * target texture unit. The initial value is 0.
4709: * @param q Specifies a q texture coordinate for
4710: * target texture unit. The initial value is 1.
4711: */
4712: void glMultiTexCoord4f(int target, float s, float t, float r,
4713: float q);
4714:
4715: /**
4716: * Fixed-point version of <code>glMultiTexCoord</code>.
4717: *
4718: * @see #glMultiTexCoord4f
4719: */
4720: void glMultiTexCoord4x(int target, int s, int t, int r, int q);
4721:
4722: /**
4723: * Set the current normal vector.
4724: *
4725: * <p>The current normal is set to the given coordinates whenever
4726: * <code>glNormal</code> is issued. Byte, short, or integer arguments are
4727: * converted to floating-point with a linear mapping that maps the
4728: * most positive representable integer value to 1.0, and the most
4729: * negative representable integer value to -1.0.
4730: *
4731: * <p>Normals specified with <code>glNormal</code> need not have
4732: * unit length. If <code>GL_NORMALIZE</code> is enabled, then
4733: * normals of any length specified with <code>glNormal</code> are
4734: * normalized after transformation. If
4735: * <code>GL_RESCALE_NORMAL</code> is enabled, normals are scaled by
4736: * a scaling factor derived from the modelview
4737: * matrix. <code>GL_RESCALE_NORMAL</code> requires that the
4738: * originally specified normals were of unit length, and that the
4739: * modelview matrix contain only uniform scales for proper
4740: * results. To enable and disable normalization, call
4741: * <code>glEnable</code> and <code>glDisable</code> with either
4742: * <code>GL_NORMALIZE</code> or
4743: * <code>GL_RESCALE_NORMAL</code>. Normalization is initially
4744: * disabled.
4745: *
4746: * @param nx Specifies the x coordinate of the new
4747: * current normal. The initial value is 0.
4748: * @param ny Specifies the y coordinate of the new
4749: * current normal. The initial value is 0.
4750: * @param nz Specifies the z coordinate of the new
4751: * current normal. The initial value is 1.
4752: */
4753: void glNormal3f(float nx, float ny, float nz);
4754:
4755: /**
4756: * Fixed-point version of <code>glNormal</code>.
4757: *
4758: * @see #glNormal3f
4759: */
4760: void glNormal3x(int nx, int ny, int nz);
4761:
4762: /**
4763: * Define an array of normals.
4764: *
4765: * <p><code>glNormalPointer</code> specifies the location and data
4766: * of an array of normals to use when rendering. type specifies the
4767: * data type of the normal coordinates and stride gives the byte
4768: * stride from one normal to the next, allowing vertices and
4769: * attributes to be packed into a single array or stored in separate
4770: * arrays. (Single-array storage may be more efficient on some
4771: * implementations.) When a normal array is specified, type , stride
4772: * , and pointer are saved as client-side state.
4773: *
4774: * <p>If the normal array is enabled, it is used when
4775: * <code>glDrawArrays</code> or <code>glDrawElements</code> is
4776: * called. To enable and disable the normal array, call
4777: * <code>glEnableClientState</code> and
4778: * <code>glDisableClientState</code> with the argument
4779: * <code>GL_NORMAL_ARRAY</code>. The normal array is initially
4780: * disabled and isn't accessed when <code>glDrawArrays</code> or
4781: * <code>glDrawElements</code> is called.
4782: *
4783: * <p>Use <code>glDrawArrays</code> to construct a sequence of
4784: * primitives (all of the same type) from prespecified vertex and
4785: * vertex attribute arrays. Use <code>glDrawElements</code> to
4786: * construct a sequence of primitives by indexing vertices and
4787: * vertex attributes.
4788: *
4789: * <h4>Notes</h4>
4790: *
4791: * <p><code>glNormalPointer</code> is typically implemented on the
4792: * client side.
4793: *
4794: * <h4>Errors</h4>
4795: *
4796: * <p><code>GL_INVALID_ENUM</code> is generated if type is not an
4797: * accepted value.
4798: *
4799: * <p><code>GL_INVALID_VALUE</code> is generated if stride is
4800: * negative.
4801: *
4802: * <p> The <code>pointer</code> argument must be a direct buffer
4803: * with a type matching that specified by the <code>type</code>
4804: * argument.
4805: *
4806: * @param type Specifies the data type of each coordinate in the
4807: * array. Symbolic constants <code>GL_BYTE</code>,
4808: * <code>GL_SHORT</code>, <code>GL_FIXED</code>, and
4809: * <code>GL_FLOAT</code> are accepted. The initial value is
4810: * <code>GL_FLOAT</code>.
4811: * @param stride Specifies the byte offset between consecutive
4812: * normals. If stride is 0, the normals are understood to be tightly
4813: * packed in the array. The initial value is 0.
4814: * @param pointer Specifies a pointer to the first coordinate of the
4815: * first normal in the array. The initial value is 0.
4816: *
4817: * @exception IllegalStateException if OpenGL ES 1.1 is being used and
4818: * VBOs are enabled.
4819: * @exception IllegalArgumentException if <code>pointer</code> is
4820: * <code>null</code>.
4821: * @exception IllegalArgumentException if <code>pointer</code> is not direct.
4822: */
4823: void glNormalPointer(int type, int stride, Buffer pointer);
4824:
4825: /**
4826: * Multiply the current matrix with an orthographic matrix.
4827: *
4828: * <p><code>glOrtho</code> describes a transformation that produces
4829: * a parallel projection. The current matrix (see glMatrixMode) is
4830: * multiplied by this matrix and the result replaces the current
4831: * matrix, as if <code>glMultMatrix</code> were called with the
4832: * following matrix as its argument:
4833: *
4834: * <pre>
4835: * ( 2/(right - left) 0 0 tx )
4836: * ( 0 2/(top - bottom) 0 ty )
4837: * ( 0 0 (-2)/(far - near) tz )
4838: * ( 0 0 0 1 )
4839: * </pre>
4840: *
4841: * <p>where
4842: *
4843: * <pre>
4844: * tx = - (right + left)/(right - left)
4845: * ty = - (top + bottom)/(top - bottom)
4846: * tz = - (far + near) /(far - near)
4847: * </pre>
4848: *
4849: * <p>Typically, the matrix mode is <code>GL_PROJECTION</code>, and
4850: * (left, bottom, -near) and (right, top, -near) specify the points
4851: * on the near clipping plane that are mapped to the lower left and
4852: * upper right corners of the window, respectively, assuming that
4853: * the eye is located at (0, 0, 0). -far specifies the location of
4854: * the far clipping plane. Both near and far can be either positive
4855: * or negative.
4856: *
4857: * <p>Use <code>glPushMatrix</code> and <code>glPopMatrix</code> to
4858: * save and restore the current matrix stack.
4859: *
4860: * @param left Specifies the coordinate for the left
4861: * vertical clipping plane.
4862: * @param right Specifies the coordinate for the right
4863: * vertical clipping plane.
4864: * @param bottom Specifies the coordinate for the bottom
4865: * horizontal clipping plane.
4866: * @param top Specifies the coordinate for the top
4867: * horizontal clipping plane.
4868: * @param near Specifies the distance to the nearer
4869: * depth clipping plane. This value is negative if the plane is
4870: * to be behind the viewer.
4871: * @param far Specifies the distance to the farther
4872: * depth clipping plane. This value is negative if the plane is
4873: * to be behind the viewer.
4874: */
4875: void glOrthof(float left, float right, float bottom, float top,
4876: float near, float far);
4877:
4878: /**
4879: * Fixed-point version of <code>glOrtho</code>.
4880: *
4881: * @see #glOrthof
4882: */
4883: void glOrthox(int left, int right, int bottom, int top, int near,
4884: int far);
4885:
4886: /**
4887: * Set pixel storage modes.
4888: *
4889: * <p><code>glPixelStore</code> sets pixel storage modes that affect
4890: * the operation of subsequent <code>glReadPixels</code> as well as
4891: * the unpacking of <code>glTexImage2D</code>, and
4892: * <code>glTexSubImage2D</code>.
4893: *
4894: * <p><code>pname</code> is a symbolic constant indicating the
4895: * parameter to be set, and <code>param</code> is the new value. The
4896: * following storage parameter affects how pixel data is returned to
4897: * client memory. This value is significant for
4898: * <code>glReadPixels</code>:
4899: *
4900: * <ul>
4901: *
4902: * <li><code>GL_PACK_ALIGNMENT</code></li>
4903: *
4904: * <p>Specifies the alignment requirements for the start of each pixel
4905: * row in memory. The allowable values are 1 (byte-alignment), 2
4906: * (rows aligned to even-numbered bytes), 4 (word-alignment), and 8
4907: * (rows start on double-word boundaries). The initial value is 4.
4908: *
4909: * <p>The following storage parameter affects how pixel data is read
4910: * from client memory. This value is significant for
4911: * <code>glTexImage2D</code> and <code>glTexSubImage2D</code>:
4912: *
4913: * <li><code>GL_UNPACK_ALIGNMENT</code></li>
4914: *
4915: * <p>Specifies the alignment requirements for the start of each pixel
4916: * row in memory. The allowable values are 1 (byte-alignment), 2
4917: * (rows aligned to even-numbered bytes), 4 (word-alignment), and 8
4918: * (rows start on double-word boundaries). The initial value is 4.
4919: *
4920: * </ul>
4921: *
4922: * <h4>Notes</h4>
4923: *
4924: * <p>Pixel storage modes are client states.
4925: *
4926: * <p><code>glCompressedTexImage2D</code> and
4927: * <code>glCompressedTexSubImage2D</code> are not affected by
4928: * <code>glPixelStore</code>.
4929: *
4930: * <h4>Errors</h4>
4931: *
4932: * <p><code>GL_INVALID_ENUM</code> is generated if
4933: * <code>pname</code> is not an accepted value.
4934: *
4935: * <p><code>GL_INVALID_VALUE</code> is generated if alignment is
4936: * specified as other than 1, 2, 4, or 8.
4937: *
4938: * @param pname Specifies the symbolic name of the parameter to be
4939: * set. <code>GL_PACK_ALIGNMENT</code> affects the packing of pixel
4940: * data into memory. <code>GL_UNPACK_ALIGNMENT</code> affects the
4941: * unpacking of pixel data from memory.
4942: * @param param Specifies the value that <code>pname</code> is set
4943: * to.
4944: */
4945: void glPixelStorei(int pname, int param);
4946:
4947: /**
4948: * Specify the diameter of rasterized points.
4949: *
4950: * <p><code>glPointSize</code> specifies the rasterized diameter of
4951: * both aliased and antialiased points. Using a point size other
4952: * than 1 has different effects, depending on whether point
4953: * antialiasing is enabled. To enable and disable point
4954: * antialiasing, call <code>glEnable</code> and
4955: * <code>glDisable</code> with argument
4956: * <code>GL_POINT_SMOOTH</code>. Point antialiasing is initially
4957: * disabled.
4958: *
4959: * <p>If point antialiasing is disabled, the actual size is determined
4960: * by rounding the supplied size to the nearest integer. (If the
4961: * rounding results in the value 0, it is as if the point size were
4962: * 1.) If the rounded size is odd, then the center point (x, y) of
4963: * the pixel fragment that represents the point is computed as
4964: *
4965: * <pre>
4966: * (floor(xw) + 1/2, floor(yw) + 1/2)
4967: * </pre>
4968: *
4969: * <p>where w subscripts indicate window coordinates. All pixels that
4970: * lie within the square grid of the rounded size centered at (x, y)
4971: * make up the fragment. If the size is even, the center point is
4972: *
4973: * <pre>
4974: * (floor(xw + 1/2), floor(yw + 1/2))
4975: * </pre>
4976: *
4977: * <p>and the rasterized fragment's centers are the half-integer window
4978: * coordinates within the square of the rounded size centered at (x,
4979: * y). All pixel fragments produced in rasterizing a nonantialiased
4980: * point are assigned the same associated data, that of the vertex
4981: * corresponding to the point.
4982: *
4983: * <p>If antialiasing is enabled, then point rasterization produces a
4984: * fragment for each pixel square that intersects the region lying
4985: * within the circle having diameter equal to the current point size
4986: * and centered at the point's (xw, yw) . The coverage value for
4987: * each fragment is the window coordinate area of the intersection
4988: * of the circular region with the corresponding pixel square. This
4989: * value is saved and used in the final rasterization step. The data
4990: * associated with each fragment is the data associated with the
4991: * point being rasterized.
4992: *
4993: * <p>Not all sizes are supported when point antialiasing is
4994: * enabled. If an unsupported size is requested, the nearest
4995: * supported size is used. Only size 1 is guaranteed to be
4996: * supported; others depend on the implementation. To query the
4997: * range of supported sizes, call <code>glGetIntegerv</code> with the argument
4998: * <code>GL_SMOOTH_POINT_SIZE_RANGE</code>. For aliased points, query the
4999: * supported ranges <code>glGetIntegerv</code> with the argument
5000: * <code>GL_ALIASED_POINT_SIZE_RANGE</code>.
5001: *
5002: * <h4>Notes</h4>
5003: *
5004: * <p>A non-antialiased point size may be clamped to an
5005: * implementation-dependent maximum. Although this maximum cannot be
5006: * queried, it must be no less than the maximum value for
5007: * antialiased points, rounded to the nearest integer value.
5008: *
5009: * <h4>Errors</h4>
5010: *
5011: * <p><code>GL_INVALID_VALUE</code> is generated if size is less
5012: * than or equal to 0.
5013: *
5014: * <h4>Associated Gets</h4>
5015: *
5016: * <p><code>glGetIntegerv</code> with argument
5017: * <code>GL_ALIASED_POINT_SIZE_RANGE</code>
5018: *
5019: * <p><code>glGetIntegerv</code> with argument
5020: * <code>GL_SMOOTH_POINT_SIZE_RANGE</code>
5021: *
5022: * @param size Specifies the diameter of rasterized points. The
5023: * initial value is 1.
5024: */
5025: void glPointSize(float size);
5026:
5027: /**
5028: * Fixed-point version of <code>glPointSize</code>.
5029: *
5030: * @see #glPointSize
5031: */
5032: void glPointSizex(int size);
5033:
5034: /**
5035: * Set the scale and units used to calculate depth values.
5036: *
5037: * <p>When <code>GL_POLYGON_OFFSET_FILL</code> is enabled, each
5038: * fragment's depth value will be offset after it is interpolated
5039: * from the depth values of the appropriate vertices. The value of
5040: * the offset is m * factor + r * units, where m is a measurement of
5041: * the change in depth relative to the screen area of the polygon,
5042: * and r is the smallest value that is guaranteed to produce a
5043: * resolvable offset for a given implementation. The offset is added
5044: * before the depth test is performed and before the value is
5045: * written into the depth buffer.
5046: *
5047: * <p><code>glPolygonOffset</code> is useful for for applying decals
5048: * to surfaces.
5049: *
5050: * @param factor Specifies a scale factor that is used to create a
5051: * variable depth offset for each polygon. The initial value is 0.
5052: * @param units Is multiplied by an implementation-specific value to
5053: * create a constant depth offset. The initial value is 0.
5054: */
5055: void glPolygonOffset(float factor, float units);
5056:
5057: /**
5058: * Fixed-point version of <code>glPolygonOffset</code>.
5059: *
5060: * @see #glPolygonOffset
5061: */
5062: void glPolygonOffsetx(int factor, int units);
5063:
5064: /**
5065: * Pop the current matrix stack.
5066: *
5067: * @see #glPushMatrix
5068: */
5069: void glPopMatrix();
5070:
5071: /**
5072: * Push the current matrix stack.
5073: *
5074: * <p>There is a stack of matrices for each of the matrix modes. In
5075: * <code>GL_MODELVIEW</code> mode, the stack depth is at least
5076: * 16. In the other modes, <code>GL_PROJECTION</code>, and
5077: * <code>GL_TEXTURE</code>, the depth is at least 2. The current
5078: * matrix in any mode is the matrix on the top of the stack for that
5079: * mode.
5080: *
5081: * <p><code>glPushMatrix</code> pushes the current matrix stack down
5082: * by one, duplicating the current matrix. That is, after a
5083: * glPushMatrix call, the matrix on top of the stack is identical to
5084: * the one below it.
5085: *
5086: * <p><code>glPopMatrix</code> pops the current matrix stack,
5087: * replacing the current matrix with the one below it on the stack.
5088: *
5089: * <p>Initially, each of the stacks contains one matrix, an identity matrix.
5090: *
5091: * <p>It is an error to push a full matrix stack, or to pop a matrix
5092: * stack that contains only a single matrix. In either case, the
5093: * error flag is set and no other change is made to GL state.
5094: *
5095: * <h4>Notes</h4>
5096: *
5097: * <p>Each texture unit has its own texture matrix stack. Use
5098: * <code>glActiveTexture</code> to select the desired texture matrix stack.
5099: *
5100: * <h4>Errors</h4>
5101: *
5102: * <p><code>GL_STACK_OVERFLOW</code> is generated if
5103: * <code>glPushMatrix</code> is called while the current matrix
5104: * stack is full.
5105: *
5106: * <p><code>GL_STACK_UNDERFLOW</code> is generated if
5107: * <code>glPopMatrix</code> is called while the current matrix stack
5108: * contains only a single matrix.
5109: *
5110: * <h4>Associated Gets</h4>
5111: *
5112: * <p><code>glGetIntegerv</code> with argument
5113: * <code>GL_MAX_MODELVIEW_STACK_DEPTH</code>
5114: *
5115: * <p><code>glGetIntegerv</code> with argument
5116: * <code>GL_MAX_PROJECTION_STACK_DEPTH</code>
5117: *
5118: * <p><code>glGetIntegerv</code> with argument
5119: * <code>GL_MAX_TEXTURE_STACK_DEPTH</code>
5120: *
5121: * <p><code>glGetIntegerv</code> with argument
5122: * <code>GL_MAX_TEXTURE_UNITS</code>
5123: */
5124: void glPushMatrix();
5125:
5126: /**
5127: * Read a block of pixels from the color buffer.
5128: *
5129: * <p><code>glReadPixels</code> returns pixel data from the color
5130: * buffer, starting with the pixel whose lower left corner is at
5131: * location (x, y), into client memory starting at location
5132: * pixels. The processing of the pixel data before it is placed into
5133: * client memory can be controlled with <code>glPixelStore</code>.
5134: *
5135: * <p><code>glReadPixels</code> returns values from each pixel with
5136: * lower left corner at <code>(x + i, y + j)</code> for <code>0 <=
5137: * <i>i</i> < width</code> and <code>0 <= j < height</code>. This
5138: * pixel is said to be the ith pixel in the jth row. Pixels are
5139: * returned in row order from the lowest to the highest row, left to
5140: * right in each row.
5141: *
5142: * <p><code>format</code> specifies the format of the returned pixel
5143: * values. <code>GL_RGBA</code> is always accepted, the value of
5144: * <code>GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES</code> may allow
5145: * another format:
5146: *
5147: * <ul>
5148: *
5149: * <li><code>GL_RGBA</code></li>
5150: *
5151: * <p>Each color component is converted to floating point such that
5152: * zero intensity maps to 0 and full intensity maps to 1.
5153: *
5154: * <li><code>GL_RGB</code></li>
5155: *
5156: * <p>Each element is an RGB triple. The GL converts it to floating
5157: * point and assembles it into an RGBA element by attaching 1 for
5158: * alpha.
5159: *
5160: * <li><code>GL_LUMINANCE</code></li>
5161: *
5162: * <p>Each element is a single luminance value. The GL converts it to
5163: * floating point and assembles it into an RGBA element by
5164: * replicating the luminance value three times for red, green and
5165: * blue and attaching 1 for alpha.
5166: *
5167: * <li><code>GL_LUMINANCE_ALPHA</code></li>
5168: *
5169: * <p>Each element is a luminance/alpha pair. The GL converts it to
5170: * floating point and assembles it into an RGBA element by
5171: * replicating the luminance value three times for red, green and
5172: * blue.
5173: *
5174: * <li><code>GL_ALPHA</code></li>
5175: *
5176: * <p>Each element is a single alpha component. The GL converts it to
5177: * floating point and assembles it into an RGBA element by attaching
5178: * 0 for red, green and blue.
5179: *
5180: * </ul>
5181: *
5182: * <p>Unneeded data is then discarded. For example,
5183: * <code>GL_ALPHA</code> discards the red, green, and blue
5184: * components, while <code>GL_RGB</code> discards only the alpha
5185: * component. <code>GL_LUMINANCE</code> computes a single-component
5186: * value as the sum of the red, green, and blue components, and
5187: * <code>GL_LUMINANCE_ALPHA</code> does the same, while keeping
5188: * alpha as a second value. The final values are clamped to the
5189: * range <code>[0, 1]</code>.
5190: *
5191: * <p>Finally, the components are converted to the proper, as specified
5192: * by type where each component is multiplied by 2^n - 1, where n is
5193: * the number of bits per component.
5194: *
5195: * <p>Return values are placed in memory as follows. If format is
5196: * <code>GL_ALPHA</code>, or <code>GL_LUMINANCE</code>, a single
5197: * value is returned and the data for the ith pixel in the jth row
5198: * is placed in location j * width + i. <code>GL_RGB</code> returns
5199: * three values, <code>GL_RGBA</code> returns four values, and
5200: * <code>GL_LUMINANCE_ALPHA</code> returns two values for each
5201: * pixel, with all values corresponding to a single pixel occupying
5202: * contiguous space in pixels. Storage parameter
5203: * <code>GL_PACK_ALIGNMENT</code> set by <code>glPixelStore</code>,
5204: * affects the way that data is written into memory. See
5205: * <code>glPixelStore</code> for a description.
5206: *
5207: * <h4>Notes</h4>
5208: *
5209: * <p>Values for pixels that lie outside the window connected to the
5210: * current GL context are undefined.
5211: *
5212: * <p>If an error is generated, no change is made to the contents of pixels.
5213: *
5214: * <h4>Errors</h4>
5215: *
5216: * <p><code>GL_INVALID_ENUM</code> is generated if format is not
5217: * <code>GL_RGBA</code> or the value of
5218: * <code>GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES</code>.
5219: *
5220: * <p><code>GL_INVALID_ENUM</code> is generated if type is not
5221: * <code>GL_UNSIGNED_BYTE</code> or the value of
5222: * <code>GL_IMPLEMENTATION_COLOR_READ_TYPE_OES</code>.
5223: *
5224: * <p><code>GL_INVALID_VALUE</code> is generated if either width or
5225: * height is negative.
5226: *
5227: * <p><code>GL_INVALID_OPERATION</code> is generated if format and
5228: * type are neither (<code>GL_RGBA</code>,
5229: * <code>GL_UNSIGNED_BYTE)</code> nor the values of
5230: * (<code>GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES</code>,
5231: * <code>GL_IMPLEMENTATION_COLOR_READ_TYPE_OES)</code>.
5232: *
5233: * <h4>Associated Gets</h4>
5234: *
5235: * <p><code>glGetIntegerv</code> with argument
5236: * <code>GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES</code>
5237: *
5238: * <p><code>glGetIntegerv</code> with argument
5239: * <code>GL_IMPLEMENTATION_COLOR_READ_TYPE_OES</code>
5240: *
5241: * @param x Specifies the window x coordinate of the first pixel
5242: * that is read from the color buffer. This location is the lower
5243: * left corner of a rectangular block of pixels.
5244: * @param y Specifies the window y coordinate of the first pixel
5245: * that is read from the color buffer. This location is the lower
5246: * left corner of a rectangular block of pixels.
5247: * @param width Specifies the width of the pixel
5248: * rectangle. width and height of one correspond to a single pixel.
5249: * @param height Specifies the height of the pixel
5250: * rectangle. width and height of one correspond to a single pixel.
5251: * @param format Specifies the format of the pixel data. Must be
5252: * either <code>GL_RGBA</code> or the value of
5253: * <code>GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES</code>.
5254: * @param type Specifies the data type of the pixel data. Must be
5255: * either <code>GL_UNSIGNED_BYTE</code> or the value of
5256: * <code>GL_IMPLEMENTATION_COLOR_READ_TYPE_OES</code>.
5257: * @param pixels Returns the pixel data.
5258: *
5259: * @exception IllegalArgumentException if <code>pixels</code> is
5260: * <code>null</code>.
5261: * @exception IllegalArgumentException if <code>pixels</code> does
5262: * not contain enough room for the pixel data.
5263: */
5264: void glReadPixels(int x, int y, int width, int height, int format,
5265: int type, Buffer pixels);
5266:
5267: /**
5268: * Multiply the current matrix by a rotation matrix.
5269: *
5270: * <p><code>glRotate</code> produces a rotation of angle degrees
5271: * around the vector (x, y, z) . The current matrix (see
5272: * glMatrixMode) is multiplied by a rotation matrix with the product
5273: * replacing the current matrix, as if <code>glMultMatrix</code>
5274: * were called with the following matrix as its argument:
5275: *
5276: * <pre>
5277: * ( x^2(1 - c) + c xy (1 - c) - zs xz (1 - c) + ys 0 )
5278: * ( xy (1 - c) + zs y^2(1 - c) + c yz (1 - c) - xs 0 )
5279: * ( xz (1 - c) - ys yz (1 - c) + xs z^2(1 - c) + c 0 )
5280: * ( 0 0 0 1 )
5281: * </pre>
5282: *
5283: * <p>Where c = cos (angle), s = sin (angle), and ||(x, y, z)|| = 1,
5284: * (if not, the GL will normalize this vector).
5285: *
5286: * <p>If the matrix mode is either <code>GL_MODELVIEW</code> or
5287: * <code>GL_PROJECTION</code>, all objects drawn after
5288: * <code>glRotate</code> is called are rotated. Use
5289: * <code>glPushMatrix</code> and <code>glPopMatrix</code> to save
5290: * and restore the unrotated coordinate system.
5291: *
5292: * <h4>Notes</h4>
5293: *
5294: * <p>This rotation follows the right-hand rule, so if the vector (x,
5295: * y, z) points toward the user, the rotation will be
5296: * counterclockwise.
5297: *
5298: * @param angle Specifies the angle of rotation, in degrees.
5299: * @param x Specifies the x coordinate of a vector.
5300: * @param y Specifies the y coordinate of a vector.
5301: * @param z Specifies the z coordinate of a vector.
5302: */
5303: void glRotatef(float angle, float x, float y, float z);
5304:
5305: /**
5306: * Fixed-point version of <code>glRotate</code>.
5307: *
5308: * @see #glRotatef
5309: */
5310: void glRotatex(int angle, int x, int y, int z);
5311:
5312: /**
5313: * Specify mask to modify multisampled pixel fragments.
5314: *
5315: * <p><code>glSampleCoverage</code> defines a mask to modify the coverage of
5316: * multisampled pixel fragments. This capability is used for
5317: * antialiased screen-door transparency and smooth transitions
5318: * between two renderings of an object (often for level-of-detail
5319: * management in simulation systems).
5320: *
5321: * <p>When multisampling is enabled (see <code>glEnable</code> with
5322: * argument <code>GL_MULTISAMPLE)</code> a ``fragment mask'' is
5323: * computed for each fragment generated by a primitive. This mask
5324: * reflects the amount of the pixel covered by the fragment, and
5325: * determines the frame buffer samples that may be affected by the
5326: * fragment.
5327: *
5328: * <p>If conversion of alpha values to masks is enabled
5329: * (<code>glEnable</code> with argument
5330: * <code>GL_SAMPLE_ALPHA_TO_MASK)</code>, the fragment alpha value
5331: * is used to generate a temporary modification mask which is then
5332: * ANDed with the fragment mask. One way to interpret this is as a
5333: * form of dithering: a multivalued alpha (coverage or opacity) for
5334: * the whole fragment is converted to simple binary values of
5335: * coverage at many locations (the samples).
5336: *
5337: * <p>After conversion of alpha values to masks, if replacement of
5338: * alpha values is enabled (<code>glEnable</code> with argument
5339: * <code>GL_SAMPLE_ALPHA_TO_ONE)</code>, the fragment's alpha is set
5340: * to the maximum allowable value.
5341: *
5342: * <p>Finally, if fragment mask modification is enabled
5343: * (<code>glEnable</code> with argument
5344: * <code>GL_SAMPLE_MASK)</code>, <code>glSampleCoverage</code>
5345: * defines an additional modification mask. value is used to
5346: * generate a modification mask in much the same way alpha was used
5347: * above. If invert is <code>GL_TRUE</code>, then the modification
5348: * mask specified by value will be inverted. The final modification
5349: * mask will then be ANDed with the fragment mask resulting from the
5350: * previous steps. This can be viewed as an ``override'' control
5351: * that selectively fades the effects of multisampled fragments.
5352: *
5353: * <p>Note that <code>glSampleCoverage(value, GL_TRUE)</code> is not
5354: * necessarily equivalent to <code>glSampleCoverage(1.0 - value,
5355: * GL_FALSE)</code>; due to round-off and other issues, complementing
5356: * the coverage will not necessarily yield an inverted modification
5357: * mask.
5358: *
5359: * @param value Specifies the coverage of the modification mask. The
5360: * value is clamped to the range <code>[0, 1]</code>, where 0
5361: * represents no coverage and 1 full coverage. The initial value is
5362: * 1.
5363: * @param invert Specifies whether the modification mask implied by
5364: * value is inverted or not. The initial value is <code>GL_FALSE</code>.
5365: */
5366: void glSampleCoverage(float value, boolean invert);
5367:
5368: /**
5369: * Fixed-point version of <code>glSampleCoverage</code>.
5370: *
5371: * @see #glSampleCoverage
5372: */
5373: void glSampleCoveragex(int value, boolean invert);
5374:
5375: /**
5376: * Multiply the current matrix by a general scaling matrix.
5377: *
5378: * <p><code>glScale</code> produces a nonuniform scaling along the
5379: * x, y, and z axes. The three parameters indicate the desired scale
5380: * factor along each of the three axes.
5381: *
5382: * <p>The current matrix (see glMatrixMode) is multiplied by this scale
5383: * matrix, and the product replaces the current matrix as if glScale
5384: * were called with the following matrix as its argument:
5385: *
5386: * <pre>
5387: * ( x 0 0 0 )
5388: * ( 0 y 0 0 )
5389: * ( 0 0 z 0 )
5390: * ( 0 0 0 1 )
5391: * </pre>
5392: *
5393: * <p>If the matrix mode is either <code>GL_MODELVIEW</code> or
5394: * <code>GL_PROJECTION</code>, all objects drawn after
5395: * <code>glScale</code> is called are scaled.
5396: *
5397: * <p>Use <code>glPushMatrix</code> and <code>glPopMatrix</code> to
5398: * save and restore the unscaled coordinate system.
5399: *
5400: * <h4>Notes</h4>
5401: *
5402: * <p>If scale factors other than 1 are applied to the modelview matrix
5403: * and lighting is enabled, lighting often appears wrong. In that
5404: * case, enable automatic normalization of normals by calling
5405: * <code>glEnable</code> with the argument <code>GL_NORMALIZE</code>.
5406: *
5407: * @param x Specifies the scale factor along the x axis.
5408: * @param y Specifies the scale factor along the y axis.
5409: * @param z Specifies the scale factor along the z axis.
5410: */
5411: void glScalef(float x, float y, float z);
5412:
5413: /**
5414: * Fixed-point version of <code>glScale</code>.
5415: *
5416: * @see #glScalef
5417: */
5418: void glScalex(int x, int y, int z);
5419:
5420: /**
5421: * Define the scissor box.
5422: *
5423: * <p><code>glScissor</code> defines a rectangle, called the scissor
5424: * box, in window coordinates. The first two arguments, x and y,
5425: * specify the lower left corner of the box. width and height
5426: * specify the width and height of the box.
5427: *
5428: * <p>To enable and disable the scissor test, call
5429: * <code>glEnable</code> and <code>glDisable</code> with argument
5430: * <code>GL_SCISSOR_TEST</code>. The scissor test is initially
5431: * disabled. While scissor test is enabled, only pixels that lie
5432: * within the scissor box can be modified by drawing
5433: * commands. Window coordinates have integer values at the shared
5434: * corners of frame buffer pixels. glScissor(0, 0, 1, 1) allows
5435: * modification of only the lower left pixel in the window, and
5436: * glScissor(0, 0, 0, 0) doesn't allow modification of any pixels in
5437: * the window.
5438: *
5439: * <p>When the scissor test is disabled, it is as though the scissor
5440: * box includes the entire window.
5441: *
5442: * <h4>Errors</h4>
5443: *
5444: * <p><code>GL_INVALID_VALUE</code> is generated if either width or
5445: * height is negative.
5446: *
5447: * @param x Specifies the x coordinate of the lower left corner
5448: * of the scissor box, in pixels. The initial value is 0.
5449: * @param y Specifies the y coordinate of the lower left corner
5450: * of the scissor box, in pixels. The initial value is 0.
5451: * @param width Specifies the width of the scissor box. When a GL
5452: * context is first attached to a surface (e.g. window), width and
5453: * height are set to the dimensions of that surface.
5454: * @param height Specifies the height of the scissor box. When a GL
5455: * context is first attached to a surface (e.g. window), width and
5456: * height are set to the dimensions of that surface.
5457: */
5458: void glScissor(int x, int y, int width, int height);
5459:
5460: /**
5461: * Select flat or smooth shading.
5462: *
5463: * <p>GL primitives can have either flat or smooth shading. Smooth
5464: * shading, the default, causes the computed colors of vertices to
5465: * be interpolated as the primitive is rasterized, typically
5466: * assigning different colors to each resulting pixel fragment. Flat
5467: * shading selects the computed color of just one vertex and assigns
5468: * it to all the pixel fragments generated by rasterizing a single
5469: * primitive. In either case, the computed color of a vertex is the
5470: * result of lighting if lighting is enabled, or it is the current
5471: * color at the time the vertex was specified if lighting is
5472: * disabled.
5473: *
5474: * <p>Flat and smooth shading are indistinguishable for
5475: * points. Starting at the beginning of the vertex array and
5476: * counting vertices and primitives from 1, the GL gives each
5477: * flat-shaded line segment <i>i</i> the computed color of
5478: * vertex <i>i</i> + 1, its second vertex. Counting similarly from 1,
5479: * the GL gives each flat-shaded polygon the computed color of
5480: * vertex <i>i</i> + 2, which is the last vertex to specify the
5481: * polygon.
5482: *
5483: * <p>Flat and smooth shading are specified by
5484: * <code>glShadeModel</code> with mode set to <code>GL_FLAT</code>
5485: * and <code>GL_SMOOTH</code>, respectively.
5486: *
5487: * <h4>Errors</h4>
5488: *
5489: * <p><code>GL_INVALID_ENUM</code> is generated if mode is any value
5490: * other than <code>GL_FLAT</code> or <code>GL_SMOOTH</code>.
5491: *
5492: * @param mode Specifies a symbolic value representing a shading
5493: * technique. Accepted values are <code>GL_FLAT</code> and
5494: * <code>GL_SMOOTH</code>. The initial value is
5495: * <code>GL_SMOOTH</code>.
5496: */
5497: void glShadeModel(int mode);
5498:
5499: /**
5500: * Set function and reference value for stencil testing.
5501: *
5502: * <p>Stenciling, like depth-buffering, enables and disables drawing on
5503: * a per-pixel basis. You draw into the stencil planes using GL
5504: * drawing primitives, then render geometry and images, using the
5505: * stencil planes to mask out portions of the screen. Stenciling is
5506: * typically used in multipass rendering algorithms to achieve
5507: * special effects, such as decals, outlining, and constructive
5508: * solid geometry rendering.
5509: *
5510: * <p>The stencil test conditionally eliminates a pixel based on the
5511: * outcome of a comparison between the reference value and the value
5512: * in the stencil buffer. To enable and disable stencil test, call
5513: * <code>glEnable</code> and <code>glDisable</code> with argument
5514: * <code>GL_STENCIL_TEST</code>. Stencil test is initially
5515: * disabled. To specify actions based on the outcome of the stencil
5516: * test, call <code>glStencilOp</code>.
5517: *
5518: * <p><code>func</code> is a symbolic constant that determines the
5519: * stencil comparison function. It accepts one of eight values,
5520: * shown in the following list. <code>ref</code> is an integer
5521: * reference value that is used in the stencil comparison. It is
5522: * clamped to the range <code>[0, 2^n - 1]</code>, where <i>n</i> is
5523: * the number of bitplanes in the stencil buffer. <code>mask</code>
5524: * is bitwise ANDed with both the reference value and the stored
5525: * stencil value, with the ANDed values participating in the
5526: * comparison.
5527: *
5528: * <p>If <code>stencil</code> represents the value stored in the
5529: * corresponding stencil buffer location, the following list shows
5530: * the effect of each comparison function that can be specified by
5531: * func. Only if the comparison succeeds is the pixel passed through
5532: * to the next stage in the rasterization process (see
5533: * glStencilOp). All tests treat stencil values as unsigned integers
5534: * in the range <code>[0, 2^n - 1]</code>, where <i>n</i> is the
5535: * number of bitplanes in the stencil buffer.
5536: *
5537: * <p>The following values are accepted by <code>func</code>:
5538: *
5539: * <ul>
5540: *
5541: * <li><code>GL_NEVER</code></li>
5542: *
5543: * <p>Always fails.
5544: *
5545: * <li><code>GL_LESS</code></li>
5546: *
5547: * <p>Passes if (ref & mask) < (stencil & mask) .
5548: *
5549: * <li><code>GL_LEQUAL</code></li>
5550: *
5551: * <p>Passes if (ref & mask) <= (stencil & mask) .
5552: *
5553: * <li><code>GL_GREATER</code></li>
5554: *
5555: * <p>Passes if (ref & mask) > (stencil & mask) .
5556: *
5557: * <li><code>GL_GEQUAL</code></li>
5558: *
5559: * <p>Passes if (ref & mask) >= (stencil & mask) .
5560: *
5561: * <li><code>GL_EQUAL</code></li>
5562: *
5563: * <p>Passes if (ref & mask) == (stencil & mask) .
5564: *
5565: * <li><code>GL_NOTEQUAL</code></li>
5566: *
5567: * <p>Passes if (ref & mask) != (stencil & mask) .
5568: *
5569: * <li><code>GL_ALWAYS</code></li>
5570: *
5571: * <p>Always passes.
5572: *
5573: * </ul>
5574: *
5575: * <h4>Notes</h4>
5576: *
5577: * <p>Initially, the stencil test is disabled. If there is no stencil
5578: * buffer, no stencil modification can occur and it is as if the
5579: * stencil test always passes.
5580: *
5581: * <h4>Errors</h4>
5582: *
5583: * <p><code>GL_INVALID_ENUM</code> is generated if func is not one
5584: * of the eight accepted values.
5585: *
5586: * <h4>Associated Gets</h4>
5587: *
5588: * <p><code>glGetIntegerv</code> with argument <code>GL_STENCIL_BITS</code>
5589: *
5590: * @param func Specifies the test function. Eight tokens are valid:
5591: * <code>GL_NEVER</code>, <code>GL_LESS</code>,
5592: * <code>GL_LEQUAL</code>, <code>GL_GREATER</code>,
5593: * <code>GL_GEQUAL</code>, <code>GL_EQUAL</code>,
5594: * <code>GL_NOTEQUAL</code>, and <code>GL_ALWAYS</code>. The initial
5595: * value is <code>GL_ALWAYS</code>.
5596: * @param ref Specifies the reference value for the stencil
5597: * test. <code>ref</code> is clamped to the range <code>[0, 2^n -
5598: * 1]</code>, where <i>n</i> is the number of bitplanes in the
5599: * stencil buffer. The initial value is 0.
5600: * @param mask Specifies a mask that is ANDed with both the
5601: * reference value and the stored stencil value when the test is
5602: * done. The initial value is all 1's.
5603: */
5604: void glStencilFunc(int func, int ref, int mask);
5605:
5606: /**
5607: * Control the writing of individual bits in the stencil planes.
5608: *
5609: * <p><code>glStencilMask</code> controls the writing of individual
5610: * bits in the stencil planes. The least significant n bits of mask,
5611: * where n is the number of bits in the stencil buffer, specify a
5612: * mask. Where a 1 appears in the mask, it's possible to write to
5613: * the corresponding bit in the stencil buffer. Where a 0 appears,
5614: * the corresponding bit is write-protected. Initially, all bits are
5615: * enabled for writing.
5616: *
5617: * <h4>Associated Gets</h4>
5618: *
5619: * <p><code>glGetIntegerv</code> with argument <code>GL_STENCIL_BITS</code>
5620: *
5621: * @param mask Specifies a bit mask to enable and disable writing of
5622: * individual bits in the stencil planes. The initial value is all
5623: * 1's.
5624: */
5625: void glStencilMask(int mask);
5626:
5627: /**
5628: * Set stencil test actions.
5629: *
5630: * <p>Stenciling, like depth-buffering, enables and disables drawing on
5631: * a per-pixel basis. You draw into the stencil planes using GL
5632: * drawing primitives, then render geometry and images, using the
5633: * stencil planes to mask out portions of the screen. Stenciling is
5634: * typically used in multipass rendering algorithms to achieve
5635: * special effects, such as decals, outlining, and constructive
5636: * solid geometry rendering.
5637: *
5638: * <p>The stencil test conditionally eliminates a pixel based on the
5639: * outcome of a comparison between the value in the stencil buffer
5640: * and a reference value. To enable and disable stencil test, call
5641: * <code>glEnable</code> and <code>glDisable</code> with argument
5642: * <code>GL_STENCIL_TEST</code>. To control it, call
5643: * <code>glStencilFunc</code>. Stenciling is initially disabled.
5644: *
5645: * <p><code>glStencilOp</code> takes three arguments that indicate
5646: * what happens to the stored stencil value while stenciling is
5647: * enabled. If the stencil test fails, no change is made to the
5648: * pixel's color or depth buffers, and fail specifies what happens
5649: * to the stencil buffer contents. The following six actions are
5650: * possible.
5651: *
5652: * <ul>
5653: *
5654: * <li><code>GL_KEEP</code></li>
5655: *
5656: * <p>Keeps the current value.
5657: *
5658: * <li><code>GL_ZERO</code></li>
5659: *
5660: * <p>Sets the stencil buffer value to 0.
5661: *
5662: * <li><code>GL_REPLACE</code></li>
5663: *
5664: * <p>Sets the stencil buffer value to ref, as specified by
5665: * <code>glStencilFunc</code>.
5666: *
5667: * <li><code>GL_INCR</code></li>
5668: *
5669: * <p>Increments the current stencil buffer value. Clamps to the
5670: * maximum representable unsigned value.
5671: *
5672: * <li><code>GL_DECR</code></li>
5673: *
5674: * <p>Decrements the current stencil buffer value. Clamps to 0.
5675: *
5676: * <li><code>GL_INVERT</code></li>
5677: *
5678: * <p>Bitwise inverts the current stencil buffer value.
5679: *
5680: * <--
5681: * <li>(<code>OES_stencil_wrap</code> extension)
5682: * <code>GL_DECR_WRAP</code></li>
5683: *
5684: * <p>Decrements the current stencil buffer value, wrapping around
5685: * to the maximum representable unsigned value if less than 0.
5686: *
5687: * <li>(<code>OES_stencil_wrap</code> extension)
5688: * <code>GL_INCR</code></li>
5689: *
5690: * <p>Increments the current stencil buffer value, wrapping around
5691: * to 0 if greater than the maximum representable unsigned value.
5692: * -->
5693: *
5694: * </ul>
5695: *
5696: * <p>Stencil buffer values are treated as unsigned integers. When
5697: * incremented and decremented, values are clamped to 0 and 2^n - 1,
5698: * where n is the value returned by querying <code>GL_STENCIL_BITS</code>.
5699: *
5700: * <p>The other two arguments to <code>glStencilOp</code> specify
5701: * stencil buffer actions that depend on whether subsequent depth
5702: * buffer tests succeed (<code>zpass</code>) or fail
5703: * (<code>zfail</code>) (see <code>glDepthFunc</code>). The actions
5704: * are specified using the same six symbolic constants as
5705: * <code>fail</code>. Note that <code>zfail</code> is ignored when
5706: * there is no depth buffer, or when the depth buffer is not
5707: * enabled. In these cases, <code>fail</code> and <code>zpass</code>
5708: * specify stencil action when the stencil test fails and passes,
5709: * respectively.
5710: *
5711: * <h4>Notes</h4>
5712: *
5713: * <p>If there is no stencil buffer, no stencil modification can occur
5714: * and it is as if the stencil tests always pass, regardless of any
5715: * call to <code>glStencilOp</code>.
5716: *
5717: * <h4>Errors</h4>
5718: *
5719: * <p><code>GL_INVALID_ENUM</code> is generated if fail, zfail, or
5720: * zpass is any value other than the six defined constant values.
5721: *
5722: * <h4>Associated Gets</h4>
5723: *
5724: * <p><code>glGetIntegerv</code> with argument <code>GL_STENCIL_BITS</code>
5725: *
5726: * @param fail Specifies the action to take when the stencil test
5727: * fails. Six symbolic constants are accepted: <code>GL_KEEP</code>,
5728: * <code>GL_ZERO</code>, <code>GL_REPLACE</code>,
5729: * <code>GL_INCR</code>, <code>GL_DECR</code>, and
5730: * <code>GL_INVERT</code> <!-- <code>GL_INCR_WRAP</code>
5731: * (<code>OES_stencil_wrap</code> extension), and
5732: * <code>GL_DECR_WRAP</code> (<code>OES_stencil_wrap</code>
5733: * extension) -->. The initial value is <code>GL_KEEP</code>.
5734: * @param zfail Specifies the stencil action when the stencil test
5735: * passes, but the depth test fails. <code>zfail</code> accepts the
5736: * same symbolic constants as <code>fail</code>. The initial value
5737: * is <code>GL_KEEP</code>.
5738: * @param zpass Specifies the stencil action when both the stencil
5739: * test and the depth test pass, or when the stencil test passes and
5740: * either there is no depth buffer or depth testing is not
5741: * enabled. <code>zpass</code> accepts the same symbolic constants
5742: * as <code>fail</code>. The initial value is <code>GL_KEEP</code>.
5743: */
5744: void glStencilOp(int fail, int zfail, int zpass);
5745:
5746: /**
5747: * Define an array of texture coordinates.
5748: *
5749: * <p><code>glTexCoordPointer</code> specifies the location and data
5750: * of an array of texture coordinates to use when rendering. size
5751: * specifies the number of coordinates per element, and must be 2,
5752: * 3, or 4. type specifies the data type of each texture coordinate
5753: * and stride specifies the byte stride from one array element to
5754: * the next allowing vertices and attributes to be packed into a
5755: * single array or stored in separate arrays. (Single-array storage
5756: * may be more efficient on some implementations.)
5757: *
5758: * <p>When a texture coordinate array is specified, size, type, stride,
5759: * and pointer are saved as client-side state.
5760: *
5761: * <p>If the texture coordinate array is enabled, it is used when
5762: * <code>glDrawArrays</code>, or <code>glDrawElements</code> is
5763: * called. To enable and disable the texture coordinate array for
5764: * the client-side active texture unit, call
5765: * <code>glEnableClientState</code> and
5766: * <code>glDisableClientState</code> with the argument
5767: * <code>GL_TEXTURE_COORD_ARRAY</code>. The texture coordinate array
5768: * is initially disabled for all client-side active texture units
5769: * and isn't accessed when <code>glDrawArrays</code> or
5770: * <code>glDrawElements</code> is called.
5771: *
5772: * <p>Use <code>glDrawArrays</code> to construct a sequence of
5773: * primitives (all of the same type) from prespecified vertex and
5774: * vertex attribute arrays. Use <code>glDrawElements</code> to
5775: * construct a sequence of primitives by indexing vertices and
5776: * vertex attributes.
5777: *
5778: * <h4>Notes</h4>
5779: *
5780: * <p><code>glTexCoordPointer</code> is typically implemented on the
5781: * client side.
5782: *
5783: * <p><code>glTexCoordPointer</code> updates the texture coordinate
5784: * array state of the client-side active texture unit, specified
5785: * with <code>glClientActiveTexture</code>.
5786: *
5787: * <h4>Errors</h4>
5788: *
5789: * <p><code>GL_INVALID_VALUE</code> is generated if size is not 2, 3, or 4.
5790: *
5791: * <p><code>GL_INVALID_ENUM</code> is generated if type is not an
5792: * accepted value.
5793: *
5794: * <p><code>GL_INVALID_VALUE</code> is generated if stride is negative.
5795: *
5796: * <p> The <code>pointer</code> argument must be a direct buffer
5797: * with a type matching that specified by the <code>type</code>
5798: * argument.
5799: *
5800: * @param size Specifies the number of coordinates per array
5801: * element. Must be 2, 3 or 4. The initial value is 4.
5802: * @param type Specifies the data type of each texture
5803: * coordinate. Symbolic constants <code>GL_BYTE</code>,
5804: * <code>GL_SHORT</code>, <code>GL_FIXED</code>,and
5805: * <code>GL_FLOAT</code> are accepted. The initial value is
5806: * <code>GL_FLOAT</code>.
5807: * @param stride Specifies the byte offset between consecutive array
5808: * elements. If stride is 0, the array elements are understood to be
5809: * tightly packed. The initial value is 0.
5810: * @param pointer Specifies a pointer to the first coordinate of the
5811: * first element in the array. The initial value is 0.
5812: *
5813: * @exception IllegalStateException if OpenGL ES 1.1 is being used and
5814: * VBOs are enabled.
5815: * @exception IllegalArgumentException if <code>pointer</code> is
5816: * <code>null</code> or is not direct.
5817: */
5818: void glTexCoordPointer(int size, int type, int stride,
5819: Buffer pointer);
5820:
5821: /**
5822: * Set texture environment parameters.
5823: *
5824: * <p>If <code>target</code> is <code>GL_TEXTURE_ENV</code>, then
5825: * the following applies:
5826: *
5827: * <p>A texture environment specifies how texture values are
5828: * interpreted when a fragment is textured. <code>target</code> must
5829: * be <code>GL_TEXTURE_ENV</code>. <code>pname</code> can be either
5830: * <code>GL_TEXTURE_ENV_MODE</code> or
5831: * <code>GL_TEXTURE_ENV_COLOR</code>.
5832: *
5833: * <p>If <code>pname</code> is <code>GL_TEXTURE_ENV_MODE</code>,
5834: * then <code>params</code> contains the symbolic name of a texture
5835: * function. Four texture functions may be specified:
5836: * <code>GL_MODULATE</code>, <code>GL_DECAL</code>,
5837: * <code>GL_BLEND</code>, and <code>GL_REPLACE</code>.
5838: *
5839: * <p>A texture function acts on the fragment to be textured using
5840: * the texture image value that applies to the fragment (see
5841: * <code>glTexParameter</code>) and produces an RGBA color for that
5842: * fragment. The following table shows how the RGBA color is
5843: * produced for each of the three texture functions that can be
5844: * chosen. <i>C</i> is a triple of color values (RGB) and <i>A</i>
5845: * is the associated alpha value. RGBA values extracted from a
5846: * texture image are in the range <code>[0, 1]</code>. The subscript
5847: * <i>f</i> refers to the incoming fragment, the subscript <i>t</i>
5848: * to the texture image, the subscript <i>c</i> to the texture
5849: * environment color, and subscript <i>v</i> indicates a value
5850: * produced by the texture function.
5851: *
5852: * <p>A texture image can have up to four components per texture
5853: * element (see <code>glTexImage2D</code>, and
5854: * <code>glCopyTexImage2D</code>). In a one-component image,
5855: * <i>Lt</i> indicates that single component. A two-component image
5856: * uses <i>Lt</i> and <i>At</i>. A three-component image has only a
5857: * color value, <i>Ct</i>. A four-component image has both a color
5858: * value <i>Ct</i> and an alpha value <i>At</i>.
5859: *
5860: * <p>For texture functions: <code>GL_REPLACE</code>,
5861: * <code>GL_MODULATE</code>, <code>GL_DECAL</code>,
5862: * <code>GL_BLEND</code>, or <code>GL_ADD</code>:
5863: *
5864: * <pre>
5865: * Base internal Texture functions
5866: * format GL_MODULATE GL_DECAL
5867: *
5868: * <p>GL_ALPHA Cv = Cf undefined
5869: * Av = Af*At
5870: *
5871: * <p>GL_LUMINANCE Cv = Cf*Lt undefined
5872: * Av = Af
5873: *
5874: * <p>GL_LUMINANCE_ALPHA Cv = Cf*Lt undefined
5875: * Av = Af*At
5876: *
5877: * <p>GL_RGB Cv = Cf*Ct Cv = Ct
5878: * Av = Af Av = Af
5879: *
5880: * <p>GL_RGBA Cv = Cf*Ct Cv = Cf*(1 - At) + Ct*At
5881: * Av = Af*At Av = Af
5882: *
5883: * <p>Base internal Texture functions
5884: * format GL_BLEND GL_REPLACE
5885: *
5886: * <p>GL_ALPHA Cv = Cf Cv = Cf
5887: * Av = Af*At Av = At
5888: *
5889: * <p>GL_LUMINANCE Cv = Cf*(1 - Lt) + Cc*Lt Cv = Lt
5890: * Av = Af Av = Af
5891: *
5892: * <p>GL_LUMINANCE_ALPHA Cv = Cf*(1 - Lt) + Cc*Lt Cv = Lt
5893: * Av = Af*At Av = At
5894: *
5895: * <p>GL_RGB Cv = Cf*(1 - Ct) + Cc*Ct Cv = Ct
5896: * Av = Af Av = Af
5897: *
5898: * <p>GL_RGBA Cv = Cf*(1 - Ct) + Cc*Ct Cv = Ct
5899: * Av = Af*At Av = At
5900: *
5901: * <p>Base internal Texture functions
5902: * format GL_ADD
5903: *
5904: * <p>GL_ALPHA Cv = Cf
5905: * Av = Af*At
5906: *
5907: * <p>GL_LUMINANCE Cv = Cf + Lt
5908: * Av = Af
5909: *
5910: * <p>GL_LUMINANCE_ALPHA Cv = Cf + Lt
5911: * Av = Af*At
5912: *
5913: * <p>GL_RGB Cv = Cf + Ct
5914: * Av = Af
5915: *
5916: * <p>GL_RGBA Cv = Cf + Ct
5917: * Av = Af*At
5918: * </pre>
5919: *
5920: * <p>If <code>pname</code> is <code>GL_TEXTURE_ENV_COLOR</code>,
5921: * <code>params</code> is a pointer to an array that holds an RGBA
5922: * color consisting of four values. The values are clamped to the
5923: * range <code>[0, 1]</code> when they are specified. <i>Cc</i>
5924: * takes these four values.
5925: *
5926: * <p>The initial value of <code>GL_TEXTURE_ENV_MODE</code> is
5927: * <code>GL_MODULATE</code>. The initial value of
5928: * <code>GL_TEXTURE_ENV_COLOR</code> is (0, 0, 0, 0).
5929: *
5930: * <h4>1.1 Notes</h4>
5931: *
5932: * <p> If the value of <code>GL_TEXTURE_ENV_MODE</code> is
5933: * <code>GL_COMBINE</code>, then the form of the texture function
5934: * depends on the values of <code>GL_COMBINE_RGB</code> and
5935: * <code>GL_COMBINE_ALPHA</code>.
5936: *
5937: * <p>The RGB and ALPHA results of the texture function are then
5938: * multiplied by the values of <code>GL_RGB_SCALE</code> and
5939: * <code>GL_ALPHA_SCALE</code>, respectively.
5940: *
5941: * <p>The results are clamped to <code>[0, 1]</code>.
5942: *
5943: * <p>The arguments <i>Arg0</i>, <i>Arg1</i>, <i>Arg2</i> are
5944: * determined by the values of
5945: * <code>GL_SRC</code><i>n</i><code>_RGB</code>,
5946: * <code>GL_SRC</code><i>n</i><code>_ALPHA</code>,
5947: * <code>GL_OPERAND</code><i>n</i><code>_RGB</code>,
5948: * <code>GL_OPERAND</code><i>n</i><code>_ALPHA</code>, where
5949: * <i>n</i> = 0, 1, or 2, <i>Cs</i> and <i>As</i> denote the texture
5950: * source color and alpha from the texture image bound to texture
5951: * unit <i>n</i>.
5952: *
5953: * <p>The state required for the current texture environment, for
5954: * each texture unit, consists of a six-valued integer indicating
5955: * the texture function, an eight-valued integer indicating the RGB
5956: * combiner function and a six-valued integer indicating the ALPHA
5957: * combiner function, six four-valued integers indicating the
5958: * combiner RGB and ALPHA source arguments, three four-valued
5959: * integers indicating the combiner RGB operands, three two-valued
5960: * integers indicating the combiner ALPHA operands, and four
5961: * floating-point environment color values. In the initial state,
5962: * the texture and combiner functions are each
5963: * <code>GL_MODULATE</code>, the combiner RGB and ALPHA sources are
5964: * each <code>GL_TEXTURE</code>, <code>GL_PREVIOUS</code>, and
5965: * <code>GL_CONSTANT</code> for sources 0, 1, and 2 respectively,
5966: * the combiner RGB operands for sources 0 and 1 are each
5967: * <code>SRC_COLOR</code>, the combiner RGB operand for source 2, as
5968: * well as for the combiner ALPHA operands, are each
5969: * <code>GL_SRC_ALPHA</code>, and the environment color is (0, 0, 0,
5970: * 0).
5971: *
5972: * <p>The state required for the texture filtering parameters, for
5973: * each texture unit, consists of a single floating-point level of
5974: * detail bias. The initial value of the bias is 0.0.
5975: *
5976: * <p>If <code>pname</code> is <code>GL_TEXTURE_ENV_COLOR</code>,
5977: * then <code>params</code> is an array that holds an RGBA color
5978: * consisting of four values. The values are clamped to the range
5979: * <code>[0, 1]</code> when they are specified. <i>Cc</i> takes
5980: * these four values.
5981: *
5982: * <p>The initial value of <code>GL_TEXTURE_ENV_MODE</code> is
5983: * <code>GL_MODULATE</code>. The initial value of
5984: * <code>GL_TEXTURE_ENV_COLOR</code> is (0, 0, 0, 0).
5985: *
5986: * <p>If <code>target</code> is <code>GL_POINT_SPRITE_OES</code>
5987: * then the following applies:
5988: *
5989: * <p>If <code>pname</code> is <code>GL_COORD_REPLACE_OES</code>,
5990: * then the point sprite texture coordinate replacement mode is set
5991: * from the value given by param, which may either be
5992: * <code>GL_FALSE</code> or <code>GL_TRUE</code>. The default value
5993: * for each texture unit is for point sprite texture coordinate
5994: * replacement to be disabled.
5995: *
5996: * <h4>Errors</h4>
5997: *
5998: * <p><code>GL_INVALID_ENUM</code> is generated when target or pname
5999: * is not one of the accepted values, or when <code>params</code>
6000: * should have a defined constant value (based on the value of
6001: * <code>pname</code>) and does not.
6002: *
6003: * <h4>Associated Gets (1.1 only)</h4>
6004: *
6005: * <p><code>glGetTexEnv</code>
6006: *
6007: * @param target Specifies a texture environment. Can be either
6008: * <code>GL_TEXTURE_ENV</code> or <code>GL_POINT_SPRITE_OES</code>
6009: * (<code>OES_point_sprite</code> extension).
6010: * @param pname Specifies the symbolic name of a single-valued
6011: * texture environment parameter. Must be one of
6012: * <code>GL_TEXTURE_ENV_MODE</code>,
6013: * <code>GL_TEXTURE_ENV_COLOR</code> (1.1 only),
6014: * <code>GL_COMBINE_RGB</code> (1.1 only),
6015: * <code>GL_COMBINE_ALPHA</code> (1.1 only), or
6016: * <code>GL_COORD_REPLACE_OES</code> (<code>OES_point_sprite</code>
6017: * extension).
6018: * @param param Specifies a single symbolic constant, one of
6019: * <code>GL_REPLACE</code>, <code>GL_MODULATE</code>,
6020: * <code>GL_DECAL</code>, <code>GL_BLEND</code>, or
6021: * <code>GL_ADD</code> (1.1 only).
6022: */
6023: void glTexEnvf(int target, int pname, float param);
6024:
6025: /**
6026: * Set texture environment parameters (array version).
6027: *
6028: * <p>A texture environment specifies how texture values are
6029: * interpreted when a fragment is textured. <code>target</code> must
6030: * be <code>GL_TEXTURE_ENV</code>. <code>pname</code> can be either
6031: * <code>GL_TEXTURE_ENV_MODE</code> or
6032: * <code>GL_TEXTURE_ENV_COLOR</code>.
6033: *
6034: * <p>If <code>pname</code> is <code>GL_TEXTURE_ENV_MODE</code>,
6035: * then <code>params</code> contains the symbolic name of a texture
6036: * function. Four texture functions may be specified:
6037: * <code>GL_MODULATE</code>, <code>GL_DECAL</code>,
6038: * <code>GL_BLEND</code>, and <code>GL_REPLACE</code>.
6039: *
6040: * <p>A texture function acts on the fragment to be textured using
6041: * the texture image value that applies to the fragment (see
6042: * <code>glTexParameter</code>) and produces an RGBA color for that
6043: * fragment. The following table shows how the RGBA color is
6044: * produced for each of the three texture functions that can be
6045: * chosen. C is a triple of color values (RGB) and A is the
6046: * associated alpha value. RGBA values extracted from a texture
6047: * image are in the range <code>[0, 1]</code>. The subscript
6048: * <i>f</i> refers to the incoming fragment, the subscript <i>t</i>
6049: * to the texture image, the subscript <i>c</i> to the texture
6050: * environment color, and subscript <i>v</i> indicates a value
6051: * produced by the texture function.
6052: *
6053: * <p>A texture image can have up to four components per texture
6054: * element (see <code>glTexImage2D</code>, and
6055: * <code>glCopyTexImage2D</code>). In a one-component image,
6056: * <i>Lt</i> indicates that single component. A two-component image
6057: * uses <i>Lt</i> and <i>At</i>. A three-component image has only a
6058: * color value, <i>Ct</i>. A four-component image has both a color
6059: * value <i>Ct</i> and an alpha value <i>At</i>.
6060: *
6061: * <pre>
6062: * Base internal Texture functions
6063: * format GL_MODULATE GL_DECAL
6064: *
6065: * <p>GL_ALPHA Cv = Cf undefined
6066: * Av = At Af
6067: *
6068: * <p>GL_LUMINANCE Cv = Lt Cf undefined
6069: * Av = Af
6070: *
6071: * <p>GL_LUMINANCE_ALPHA Cv = Lt Cf undefined
6072: * Av = At Af
6073: *
6074: * <p>GL_RGB Cv = Ct Cf Cv = Ct
6075: * Av = Af Av = Af
6076: *
6077: * <p>GL_RGBA Cv = Ct Cf Cv = (1 - At) Cf + At Ct
6078: * Av = At Af Av = Af
6079: *
6080: * <p>Base internal Texture functions
6081: * format GL_BLEND GL_REPLACE
6082: *
6083: * <p>GL_ALPHA Cv = Cf Cv = Cf
6084: * Av = At Af Av = At
6085: *
6086: * <p>GL_LUMINANCE Cv = (1 - Lt) Cf + Lt Cc Cv = Lt
6087: * Av = Af Av = Af
6088: *
6089: * <p>GL_LUMINANCE_ALPHA Cv = (1 - Lt) Cf + Lt Cc Cv = Lt
6090: * Av = At Af Av = At
6091: *
6092: * <p>GL_RGB Cv = (1 - Ct) Cf + Ct Cc Cv = Ct
6093: * Av = Af Av = Af
6094: *
6095: * <p>GL_RGBA Cv = (1 - Ct) Cf + Ct Cc Cv = Ct
6096: * Av = At Af Av = At
6097: * </pre>
6098: *
6099: * <p>If <code>pname</code> is <code>GL_TEXTURE_ENV_COLOR</code>,
6100: * <code>params</code> holds an RGBA color consisting of four
6101: * values. The values are clamped to the range <code>[0, 1]</code>
6102: * when they are specified. <i>Cc</i> takes these four values.
6103: *
6104: * <p>The initial value of <code>GL_TEXTURE_ENV_MODE</code> is
6105: * <code>GL_MODULATE</code>. The initial value of
6106: * <code>GL_TEXTURE_ENV_COLOR</code> is (0, 0, 0, 0).
6107: *
6108: * <h4>Errors</h4>
6109: *
6110: * <p><code>GL_INVALID_ENUM</code> is generated when target or pname
6111: * is not one of the accepted values, or when <code>params</code>
6112: * should have a defined constant value (based on the value of
6113: * <code>pname</code>) and does not.
6114: *
6115: * @param target Specifies a texture environment. Must be
6116: * <code>GL_TEXTURE_ENV</code>.
6117: * @param pname Specifies the symbolic name of a texture environment
6118: * parameter. Accepted values are <code>GL_TEXTURE_ENV_MODE</code> and
6119: * <code>GL_TEXTURE_ENV_COLOR</code>.
6120: * @param params Specifies a parameter array that contains either a
6121: * single symbolic constant or an RGBA color.
6122: * @param offset the starting offset within the
6123: * <code>params</code> array.
6124: *
6125: * @exception IllegalArgumentException if <code>params</code> is
6126: * <code>null</code>.
6127: * @exception IllegalArgumentException if <code>offset</code> is
6128: * less than 0.
6129: * @exception IllegalArgumentException if <code>params.length -
6130: * offset</code> is smaller than the number of values required by
6131: * the parameter.
6132: */
6133: void glTexEnvfv(int target, int pname, float[] params, int offset);
6134:
6135: /**
6136: * Floating-point <code>Buffer</code> version of <code>glTexEnv</code>.
6137: *
6138: * @see #glTexEnvfv(int target, int pname, float[] params, int offset)
6139: *
6140: * @exception IllegalArgumentException if <code>params</code> is
6141: * <code>null</code>.
6142: * @exception IllegalArgumentException if
6143: * <code>params.remaining()</code> is smaller than the number of
6144: * values required by the parameter.
6145: */
6146: void glTexEnvfv(int target, int pname, FloatBuffer params);
6147:
6148: /**
6149: * Fixed-point version of <code>glTexEnv</code>.
6150: *
6151: * @see #glTexEnvf(int target, int pname, float param)
6152: */
6153: void glTexEnvx(int target, int pname, int param);
6154:
6155: /**
6156: * Fixed-point array version of <code>glTexEnv</code>.
6157: *
6158: * @see #glTexEnvfv(int target, int pname, float[] params, int offset)
6159: *
6160: * @exception IllegalArgumentException if <code>params</code> is
6161: * <code>null</code>.
6162: * @exception IllegalArgumentException if <code>offset</code> is
6163: * less than 0.
6164: * @exception IllegalArgumentException if <code>params.length -
6165: * offset</code> is smaller than the number of values required by
6166: * the parameter.
6167: */
6168: void glTexEnvxv(int target, int pname, int[] params, int offset);
6169:
6170: /**
6171: * Fixed-point <code>Buffer</code> version of <code>glTexEnv</code>.
6172: *
6173: * @see #glTexEnvfv(int target, int pname, float[] params, int offset)
6174: *
6175: * @exception IllegalArgumentException if <code>params</code> is
6176: * <code>null</code>.
6177: * @exception IllegalArgumentException if
6178: * <code>params.remaining()</code> is smaller than the number of
6179: * values required by the parameter.
6180: */
6181: void glTexEnvxv(int target, int pname, IntBuffer params);
6182:
6183: /**
6184: * Specify a two-dimensional texture image.
6185: *
6186: * <p>Texturing maps a portion of a specified texture image onto
6187: * each graphical primitive for which texturing is enabled. To
6188: * enable and disable two-dimensional texturing, call
6189: * <code>glEnable</code> and glDisable with argument
6190: * <code>GL_TEXTURE_2D</code>. Two-dimensional texturing is
6191: * initially disabled.
6192: *
6193: * <p>To define texture images, call <code>glTexImage2D</code>. The arguments
6194: * describe the parameters of the texture image, such as height,
6195: * width, width of the border, level-of-detail number (see
6196: * glTexParameter), and number of color components provided. The
6197: * last three arguments describe how the image is represented in
6198: * memory.
6199: *
6200: * <p>Data is read from pixels as a sequence of unsigned bytes or
6201: * shorts, depending on type. These values are grouped into sets of
6202: * one, two, three, or four values, depending on format, to form
6203: * elements.
6204: *
6205: * <p>When type is <code>GL_UNSIGNED_BYTE</code>, each of these
6206: * bytes is interpreted as one color component, depending on
6207: * format. When type is one of <code>GL_UNSIGNED_SHORT_5_6_5</code>,
6208: * <code>GL_UNSIGNED_SHORT_4_4_4_4</code>,
6209: * <code>GL_UNSIGNED_SHORT_5_5_5_1</code>, each unsigned value is
6210: * interpreted as containing all the components for a single pixel,
6211: * with the color components arranged according to format.
6212: *
6213: * <p>The first element corresponds to the lower left corner of the
6214: * texture image. Subsequent elements progress left-to-right through
6215: * the remaining texels in the lowest row of the texture image, and
6216: * then in successively higher rows of the texture image. The final
6217: * element corresponds to the upper right corner of the texture
6218: * image.
6219: *
6220: * <p>By default, adjacent pixels are taken from adjacent memory
6221: * locations, except that after all width pixels are read, the read
6222: * pointer is advanced to the next four-byte boundary. The four-byte
6223: * row alignment is specified by <code>glPixelStore</code> with argument
6224: * <code>GL_UNPACK_ALIGNMENT</code>, and it can be set to one, two, four, or
6225: * eight bytes.
6226: *
6227: * <p>format determines the composition of each element in pixels. It
6228: * can assume one of the following symbolic values:
6229: *
6230: * <ul>
6231: *
6232: * <li><code>GL_ALPHA</code></li>
6233: *
6234: * <p>Each element is a single alpha component. The GL converts it to
6235: * floating point and assembles it into an RGBA element by attaching
6236: * 0 for red, green, and blue.
6237: *
6238: * <li><code>GL_RGB</code></li>
6239: *
6240: * <p>Each element is an RGB triple. The GL converts it to fixed-point
6241: * or floating-point and assembles it into an RGBA element by
6242: * attaching 1 for alpha.
6243: *
6244: * <li><code>GL_RGBA</code></li>
6245: *
6246: * <p>Each element contains all four components. The GL converts it to
6247: * fixed-point or floating-point.
6248: *
6249: * <li><code>GL_LUMINANCE</code></li>
6250: *
6251: * <p>Each element is a single luminance value. The GL converts it to
6252: * fixed-point or floating-point, then assembles it into an RGBA
6253: * element by replicating the luminance value three times for red,
6254: * green, and blue and attaching 1 for alpha.
6255: *
6256: * <li><code>GL_LUMINANCE_ALPHA</code></li>
6257: *
6258: * <p>Each element is a luminance/alpha pair. The GL converts it to
6259: * fixed-point or floating point, then assembles it into an RGBA
6260: * element by replicating the luminance value three times for red,
6261: * green, and blue.
6262: *
6263: * </ul>
6264: *
6265: * <h4>Notes</h4>
6266: *
6267: * <p>pixels may be NULL. In this case texture memory is allocated to
6268: * accommodate a texture of width width and height height. You can
6269: * then download subtextures to initialize this texture memory. The
6270: * image is undefined if the user tries to apply an uninitialized
6271: * portion of the texture image to a primitive.
6272: *
6273: * <p><code>glTexImage2D</code> specifies the two-dimensional texture for the
6274: * currently bound texture specified with <code>glBindTexture</code>, and the
6275: * current texture unit, specified with <code>glActiveTexture</code>.
6276: *
6277: * <h4>Errors</h4>
6278: *
6279: * <p><code>GL_INVALID_ENUM</code> is generated if target is not
6280: * <code>GL_TEXTURE_2D</code>.
6281: *
6282: * <p><code>GL_INVALID_ENUM</code> is generated if format is not an
6283: * accepted constant.
6284: *
6285: * <p><code>GL_INVALID_ENUM</code> is generated if type is not a
6286: * type constant.
6287: *
6288: * <p><code>GL_INVALID_VALUE</code> is generated if level is less
6289: * than 0.
6290: *
6291: * <p><code>GL_INVALID_VALUE</code> may be generated if level is
6292: * greater than log2max, where max is the returned value of
6293: * <code>GL_MAX_TEXTURE_SIZE</code>.
6294: *
6295: * <p><code>GL_INVALID_VALUE</code> is generated if internalformat
6296: * is not an accepted constant.
6297: *
6298: * <p><code>GL_INVALID_VALUE</code> is generated if width or height
6299: * is less than 0 or greater than <code>GL_MAX_TEXTURE_SIZE</code>,
6300: * or if either cannot be represented as 2^k + 2*border for some
6301: * integer k.
6302: *
6303: * <p><code>GL_INVALID_VALUE</code> is generated if border is not 0.
6304: *
6305: * <p><code>GL_INVALID_OPERATION</code> is generated if
6306: * internalformat and format are not the same.
6307: *
6308: * <p><code>GL_INVALID_OPERATION</code> is generated if type is
6309: * <code>GL_UNSIGNED_SHORT_5_6_5</code> and format is not
6310: * <code>GL_RGB</code>.
6311: *
6312: * <p><code>GL_INVALID_OPERATION</code> is generated if typeis one
6313: * of <code>GL_UNSIGNED_SHORT_4_4_4_4</code>, or
6314: * <code>GL_UNSIGNED_SHORT_5_5_5_1</code> and formatis not
6315: * <code>GL_RGBA</code>.
6316: *
6317: * <h4>Associated Gets</h4>
6318: *
6319: * <p><code>glGetIntegerv</code> with argument
6320: * <code>GL_MAX_TEXTURE_SIZE</code>
6321: *
6322: * @param target Specifies the target texture. Must be
6323: * <code>GL_TEXTURE_2D</code>.
6324: * @param level Specifies the level-of-detail number. Level 0 is the
6325: * base image level. Level n is the nth mipmap reduction image. Must
6326: * be greater or equal 0.
6327: * @param internalformat Specifies the color components in the
6328: * texture. Must be same as format. The following symbolic values
6329: * are accepted: <code>GL_ALPHA</code>, <code>GL_RGB</code>,
6330: * <code>GL_RGBA</code>, <code>GL_LUMINANCE</code>, or
6331: * <code>GL_LUMINANCE_ALPHA</code>.
6332: * @param width Specifies the width of the texture image. Must be
6333: * 2^n + 2*border for some integer n. All implementations support
6334: * texture images that are at least 64 texels wide.
6335: * @param height Specifies the height of the texture image. Must be
6336: * 2^m + 2*border for some integer m. All implementations support
6337: * texture images that are at least 64 texels high.
6338: * @param border Specifies the width of the border. Must be 0.
6339: * @param format Specifies the format of the pixel data. Must be
6340: * same as internalformat. The following symbolic values are
6341: * accepted: <code>GL_ALPHA</code>, <code>GL_RGB</code>,
6342: * <code>GL_RGBA</code>, <code>GL_LUMINANCE</code>, and
6343: * <code>GL_LUMINANCE_ALPHA</code>.
6344: * @param type Specifies the data type of the pixel data. The
6345: * following symbolic values are accepted:
6346: * <code>GL_UNSIGNED_BYTE</code>,
6347: * <code>GL_UNSIGNED_SHORT_5_6_5</code>,
6348: * <code>GL_UNSIGNED_SHORT_4_4_4_4</code>, and
6349: * <code>GL_UNSIGNED_SHORT_5_5_5_1</code>.
6350: * @param pixels Specifies a pointer to the image data in memory.
6351: *
6352: * @exception IllegalArgumentException if <code>pixels</code> is
6353: * <code>null</code>.
6354: * @exception IllegalArgumentException if <code>pixels</code> does
6355: * not contain the desired number of pixels.
6356: */
6357: void glTexImage2D(int target, int level, int internalformat,
6358: int width, int height, int border, int format, int type,
6359: Buffer pixels);
6360:
6361: /**
6362: * Set texture parameters.
6363: *
6364: * <p>Texture mapping is a technique that applies an image onto an
6365: * object's surface as if the image were a decal or cellophane
6366: * shrink-wrap. The image is created in texture space, with an (s,
6367: * t) coordinate system. A texture is a one- or two-dimensional
6368: * image and a set of parameters that determine how samples are
6369: * derived from the image.
6370: *
6371: * <p><code>glTexParameter</code> assigns the value or values in
6372: * <code>param</code> to the texture parameter specified as
6373: * <code>pname</code>. <code>target</code> defines the target
6374: * texture, which must be <code>GL_TEXTURE_2D</code>. The following
6375: * symbols are accepted in <code>pname</code>:
6376: *
6377: * <ul>
6378: *
6379: * <li><code>GL_TEXTURE_MIN_FILTER</code></li>
6380: *
6381: * <p>The texture minifying function is used whenever the pixel being
6382: * textured maps to an area greater than one texture element. There
6383: * are six defined minifying functions. Two of them use the nearest
6384: * one or nearest four texture elements to compute the texture
6385: * value. The other four use mipmaps.
6386: *
6387: * <p>A mipmap is an ordered set of arrays representing the same image
6388: * at progressively lower resolutions. If the texture has dimensions
6389: * 2^n × 2^m, there are max (n, m) + 1 mipmaps. The first mipmap is
6390: * the original texture, with dimensions 2^n × 2^m. Each subsequent
6391: * mipmap has dimensions 2^(k - 1) × 2^(l - 1), where 2^k × 2^l are
6392: * the dimensions of the previous mipmap, until either k = 0 or l =
6393: * 0. At that point, subsequent mipmaps have dimension 1 × 2^(l - 1)
6394: * or 2^(k - 1) × 1 until the final mipmap, which has dimension 1 ×
6395: * 1. To define the mipmaps, call <code>glTexImage2D</code> or
6396: * glCopyTexImage2D with the level argument indicating the order of
6397: * the mipmaps. Level 0 is the original texture. Level max (n, m) is
6398: * the final 1 × 1 mipmap.
6399: *
6400: * <p><code>param</code> supplies a function for minifying the
6401: * texture as one of the following:
6402: *
6403: * <ul>
6404: * <li><code>GL_NEAREST</code></li>
6405: *
6406: * <p>Returns the value of the texture element that is nearest (in
6407: * Manhattan distance) to the center of the pixel being textured.
6408: *
6409: * <li><code>GL_LINEAR</code></li>
6410: *
6411: * <p>Returns the weighted average of the four texture elements that
6412: * are closest to the center of the pixel being textured. These can
6413: * include border texture elements, depending on the values of
6414: * <code>GL_TEXTURE_WRAP_S</code> and
6415: * <code>GL_TEXTURE_WRAP_T</code>, and on the exact mapping.
6416: *
6417: * <li><code>GL_NEAREST_MIPMAP_NEAREST</code></li>
6418: *
6419: * <p>Chooses the mipmap that most closely matches the size of the
6420: * pixel being textured and uses the <code>GL_NEAREST</code>
6421: * criterion (the texture element nearest to the center of the
6422: * pixel) to produce a texture value.
6423: *
6424: * <li><code>GL_LINEAR_MIPMAP_NEAREST</code></li>
6425: *
6426: * <p>Chooses the mipmap that most closely matches the size of the
6427: * pixel being textured and uses the <code>GL_LINEAR</code>
6428: * criterion (a weighted average of the four texture elements that
6429: * are closest to the center of the pixel) to produce a texture
6430: * value.
6431: *
6432: * <li><code>GL_NEAREST_MIPMAP_LINEAR</code></li>
6433: *
6434: * <p>Chooses the two mipmaps that most closely match the size of the
6435: * pixel being textured and uses the <code>GL_NEAREST</code> criterion (the
6436: * texture element nearest to the center of the pixel) to produce a
6437: * texture value from each mipmap. The final texture value is a
6438: * weighted average of those two values.
6439: *
6440: * <li><code>GL_LINEAR_MIPMAP_LINEAR</code></li>
6441: *
6442: * <p>Chooses the two mipmaps that most closely match the size of the
6443: * pixel being textured and uses the <code>GL_LINEAR</code>
6444: * criterion (a weighted average of the four texture elements that
6445: * are closest to the center of the pixel) to produce a texture
6446: * value from each mipmap. The final texture value is a weighted
6447: * average of those two values.
6448: *
6449: * </ul>
6450: *
6451: * <p>As more texture elements are sampled in the minification process,
6452: * fewer aliasing artifacts will be apparent. While the
6453: * <code>GL_NEAREST</code> and <code>GL_LINEAR</code> minification
6454: * functions can be faster than the other four, they sample only one
6455: * or four texture elements to determine the texture value of the
6456: * pixel being rendered and can produce moire patterns or ragged
6457: * transitions.
6458: *
6459: * <p>The initial value of <code>GL_TEXTURE_MIN_FILTER</code> is
6460: * <code>GL_NEAREST_MIPMAP_LINEAR</code>.
6461: *
6462: * <li><code>GL_TEXTURE_MAG_FILTER</code></li>
6463: *
6464: * <p>The texture magnification function is used when the pixel being
6465: * textured maps to an area less than or equal to one texture
6466: * element. It sets the texture magnification function to either
6467: * <code>GL_NEAREST</code> or <code>GL_LINEAR</code> (see
6468: * below). <code>GL_NEAREST</code> is generally faster than
6469: * <code>GL_LINEAR</code>, but it can produce textured images with
6470: * sharper edges because the transition between texture elements is
6471: * not as smooth.
6472: *
6473: * <p>The initial value of <code>GL_TEXTURE_MAG_FILTER</code> is
6474: * <code>GL_LINEAR</code>.
6475: *
6476: * <li><code>GL_NEAREST</code></li>
6477: *
6478: * <p>Returns the value of the texture element that is nearest (in
6479: * Manhattan distance) to the center of the pixel being textured.
6480: *
6481: * <li><code>GL_LINEAR</code></li>
6482: *
6483: * <p>Returns the weighted average of the four texture elements that
6484: * are closest to the center of the pixel being textured. These can
6485: * include border texture elements, depending on the values of
6486: * <code>GL_TEXTURE_WRAP_S</code> and
6487: * <code>GL_TEXTURE_WRAP_T</code>, and on the exact mapping.
6488: *
6489: * <li><code>GL_TEXTURE_WRAP_S</code></li>
6490: *
6491: * <p>Sets the wrap parameter for texture coordinate <i>s</i> to
6492: * either <code>GL_CLAMP</code>, <code>GL_CLAMP_TO_EDGE</code>, or
6493: * <code>GL_REPEAT</code> <!-- , or <code>GL_MIRRORED_REPEAT</code>
6494: * (<code>OES_texture_mirrored_repeat</code>
6495: * extension) -->. <code>GL_CLAMP</code> causes <i>s</i> coordinates to
6496: * be clamped to the range <code>[0, 1]</code> and is useful for
6497: * preventing wrapping artifacts when mapping a single image onto an
6498: * object. <code>GL_CLAMP_TO_EDGE</code> causes <i>s</i> coordinates
6499: * to be clamped to the range <code>[1/(2<i>N</i>), 1 -
6500: * 1/(2<i>N</i>)]</code>, where <i>N</i> is the size of the texture
6501: * in the direction of clamping. <code>GL_REPEAT</code> causes the
6502: * integer part of the <i>s</i> coordinate to be ignored; the GL
6503: * uses only the fractional part, thereby creating a repeating
6504: * pattern. Border texture elements are accessed only if wrapping is
6505: * set to <code>GL_CLAMP</code>.
6506: *
6507: * <p>Initially, <code>GL_TEXTURE_WRAP_S</code> is set to
6508: * <code>GL_REPEAT</code>.
6509: *
6510: * <li><code>GL_TEXTURE_WRAP_T</code></li>
6511: *
6512: * <p>Sets the wrap parameter for texture coordinate <i>t</i> to
6513: * either <code>GL_CLAMP</code>, <code>GL_CLAMP_TO_EDGE</code>, or
6514: * <code>GL_REPEAT</code> <!-- , or <code>GL_MIRRORED_REPEAT</code>
6515: * (<code>OES_texture_mirrored_repeat</code> extension) -->. See the
6516: * discussion under <code>GL_TEXTURE_WRAP_S</code>.
6517: *
6518: * <p>Initially, <code>GL_TEXTURE_WRAP_T</code> is set to
6519: * <code>GL_REPEAT</code>.
6520: *
6521: * <li><code>GL_GENERATE_MIPMAP</code> (1.1 only)</li>
6522: *
6523: * <p>Sets the automatic mipmap generation parameter. If set to
6524: * <code>GL_TRUE</code>, making any change to the interior or border
6525: * texels of the levelbase array of a mipmap will also compute a
6526: * complete set of mipmap arrays derived from the modified levelbase
6527: * array. Array levels <i>levelbase + 1</i> through <i>p</i> are
6528: * replaced with the derived arrays, regardless of their previous
6529: * contents. All other mipmap arrays, including the levelbase array,
6530: * are left unchanged by this computation.
6531: *
6532: * <p>The initial value of <code>GL_GENERATE_MIPMAP</code> is
6533: * <code>GL_FALSE</code>.
6534: *
6535: * </ul>
6536: *
6537: * <h4>Notes</h4>
6538: *
6539: * <p>Suppose that a program has enabled texturing (by calling
6540: * glEnable with argument <code>GL_TEXTURE_2D</code> and has set
6541: * <code>GL_TEXTURE_MIN_FILTER</code> to one of the functions that
6542: * requires a mipmap. If either the dimensions of the texture images
6543: * currently defined (with previous calls to
6544: * <code>glTexImage2D</code>, or glCopyTexImage2D) do not follow the
6545: * proper sequence for mipmaps (described above), or there are fewer
6546: * texture images defined than are needed, or the set of texture
6547: * images have differing numbers of texture components, then it is
6548: * as if texture mapping were disabled.
6549: *
6550: * <p>Linear filtering accesses the four nearest texture elements.
6551: *
6552: * <p><code>glTexParameter</code> specifies the texture parameters
6553: * for the active texture unit, specified by calling
6554: * <code>glActiveTexture</code>.
6555: *
6556: * <h4>Errors</h4>
6557: *
6558: * <p><code>GL_INVALID_ENUM</code> is generated if target or pname
6559: * is not one of the accepted defined values.
6560: *
6561: * <p><code>GL_INVALID_ENUM</code> is generated if param should have
6562: * a defined constant value (based on the value of pname) and does
6563: * not.
6564: *
6565: * @param target Specifies the target texture, which must be
6566: * <code>GL_TEXTURE_2D</code>.
6567: * @param pname Specifies the symbolic name of a single-valued
6568: * texture parameter. <code>pname</code> can be one of the
6569: * following: <code>GL_TEXTURE_MIN_FILTER</code>,
6570: * <code>GL_TEXTURE_MAG_FILTER</code>,
6571: * <code>GL_TEXTURE_WRAP_S</code>, <code>GL_TEXTURE_WRAP_T</code>, or
6572: * <code>GL_GENERATE_MIPMAP</code> (1.1 only) <!--, or
6573: * <code>GL_TEXTURE_CROP_RECT_OES</code>
6574: * (<code>OES_draw_texture</code> extension) -->.
6575: * @param param Specifies the value of <code>pname</code>.
6576: */
6577: void glTexParameterf(int target, int pname, float param);
6578:
6579: /**
6580: * Fixed-point version of <code>glTexParameter</code>.
6581: *
6582: * @see #glTexParameterf(int target, int pname, float param)
6583: */
6584: void glTexParameterx(int target, int pname, int param);
6585:
6586: /**
6587: * Specify a two-dimensional texture subimage.
6588: *
6589: * <p>Texturing maps a portion of a specified texture image onto
6590: * each graphical primitive for which texturing is enabled. To
6591: * enable and disable two-dimensional texturing, call
6592: * <code>glEnable</code> and glDisable with argument
6593: * <code>GL_TEXTURE_2D</code>. Two-dimensional texturing is
6594: * initially disabled.
6595: *
6596: * <p><code>glTexSubImage2D</code> redefines a contiguous subregion
6597: * of an existing two-dimensional texture image. The texels
6598: * referenced by pixels replace the portion of the existing texture
6599: * array with x indices xoffset and xoffset + width - 1, inclusive,
6600: * and y indices yoffset and yoffset + height - 1, inclusive. This
6601: * region may not include any texels outside the range of the
6602: * texture array as it was originally specified. It is not an error
6603: * to specify a subtexture with zero width or height, but such a
6604: * specification has no effect.
6605: *
6606: * <h4>Notes</h4>
6607: *
6608: * <p><code>glPixelStore</code> affects texture images in exactly
6609: * the way it affects <code>glTexImage2D</code>.
6610: *
6611: * <p><code>glTexSubImage2D</code> specifies a two-dimensional sub
6612: * texture for the currently bound texture, specified with
6613: * <code>glBindTexture</code> and current texture unit, specified
6614: * with <code>glActiveTexture</code>.
6615: *
6616: * <h4>Errors</h4>
6617: *
6618: * <p><code>GL_INVALID_ENUM</code> is generated if target is not
6619: * <code>GL_TEXTURE_2D</code>.
6620: *
6621: * <p><code>GL_INVALID_OPERATION</code> is generated if the texture
6622: * array has not been defined by a previous
6623: * <code>glTexImage2D</code> or glCopyTexImage2D operation.
6624: *
6625: * <p><code>GL_INVALID_VALUE</code> is generated if level is less
6626: * than 0.
6627: *
6628: * <p><code>GL_INVALID_VALUE</code> may be generated if level is
6629: * greater than log2max, where max is the returned value of
6630: * <code>GL_MAX_TEXTURE_SIZE</code>.
6631: *
6632: * <p><code>GL_INVALID_VALUE</code> is generated if xoffset < - b,
6633: * xoffset + width > (w - b) , yoffset < - b, or yoffset + height >
6634: * (h - b) , where w is the texture width, h is the texture height,
6635: * and b is the border of the texture image being modified. Note
6636: * that w and h include twice the border width.
6637: *
6638: * <p><code>GL_INVALID_VALUE</code> is generated if width or height
6639: * is less than 0.
6640: *
6641: * <p><code>GL_INVALID_ENUM</code> is generated if format is not an
6642: * accepted constant.
6643: *
6644: * <p><code>GL_INVALID_ENUM</code> is generated if type is not a
6645: * type constant.
6646: *
6647: * <p><code>GL_INVALID_OPERATION</code> is generated if type is
6648: * <code>GL_UNSIGNED_SHORT_5_6_5</code> and format is not
6649: * <code>GL_RGB</code>.
6650: *
6651: * <p><code>GL_INVALID_OPERATION</code> is generated if type is one
6652: * of <code>GL_UNSIGNED_SHORT_4_4_4_4</code>, or
6653: * <code>GL_UNSIGNED_SHORT_5_5_5_1</code> and format is not
6654: * <code>GL_RGBA</code>.
6655: *
6656: * <h4>Associated Gets</h4>
6657: *
6658: * <p><code>glGetIntegerv</code> with argument
6659: * <code>GL_MAX_TEXTURE_SIZE</code>
6660: *
6661: * @param target Specifies the target texture. Must be
6662: * <code>GL_TEXTURE_2D</code>.
6663: * @param level Specifies the level-of-detail number. Level 0 is the
6664: * base image level. Level n is the nth mipmap reduction image.
6665: * @param xoffset Specifies a texel offset in the x direction within
6666: * the texture array.
6667: * @param yoffset Specifies a texel offset in the y direction within
6668: * the texture array.
6669: * @param width Specifies the width of the texture subimage.
6670: * @param height Specifies the height of the texture subimage.
6671: * @param format Specifies the of the pixel data. The following
6672: * symbolic values are accepted: <code>GL_ALPHA</code>,
6673: * <code>GL_RGB</code>, <code>GL_RGBA</code>,
6674: * <code>GL_LUMINANCE</code>, and <code>GL_LUMINANCE_ALPHA</code>.
6675: * @param type Specifies the data type of the pixel data. The
6676: * following symbolic values are accepted:
6677: * <code>GL_UNSIGNED_BYTE</code>,
6678: * <code>GL_UNSIGNED_SHORT_5_6_5</code>,
6679: * <code>GL_UNSIGNED_SHORT_4_4_4_4</code>, and
6680: * <code>GL_UNSIGNED_SHORT_5_5_5_1</code>.
6681: * @param pixels Specifies the image data.
6682: *
6683: * @exception IllegalArgumentException if <code>pixels</code> is
6684: * <code>null</code>.
6685: * @exception IllegalArgumentException if <code>pixels</code> does
6686: * not contain the desired number of pixels.
6687: */
6688: void glTexSubImage2D(int target, int level, int xoffset,
6689: int yoffset, int width, int height, int format, int type,
6690: Buffer pixels);
6691:
6692: /**
6693: * Multiply the current matrix by a translation matrix.
6694: *
6695: * <p><code>glTranslate</code> produces a translation by (x, y, z).
6696: * The current matrix (see glMatrixMode) is multiplied by this
6697: * translation matrix, with the product replacing the current
6698: * matrix, as if <code>glMultMatrix</code> were called with the
6699: * following matrix for its argument:
6700: *
6701: * <pre>
6702: * ( 1 0 0 x )
6703: * ( 0 1 0 y )
6704: * ( 0 0 1 z )
6705: * ( 0 0 0 1 )
6706: * </pre>
6707: *
6708: * <p>If the matrix mode is either <code>GL_MODELVIEW</code> or
6709: * <code>GL_PROJECTION</code>, all objects drawn after a call to
6710: * <code>glTranslate</code> are translated.
6711: *
6712: * <p>Use <code>glPushMatrix</code> and <code>glPopMatrix</code> to
6713: * save and restore the untranslated coordinate system.
6714: *
6715: * @param x Specifies the x coordinate of a translation vector.
6716: * @param y Specifies the y coordinate of a translation vector.
6717: * @param z Specifies the z coordinate of a translation vector.
6718: */
6719: void glTranslatef(float x, float y, float z);
6720:
6721: /**
6722: * Fixed-point version of <code>glTranslate</code>.
6723: *
6724: * @see #glTranslatef
6725: */
6726: void glTranslatex(int x, int y, int z);
6727:
6728: // Need revisit - pointer == null
6729: /**
6730: * Define an array of vertex coordinates.
6731: *
6732: * <p><code>glVertexPointer</code> specifies the location and data
6733: * of an array of vertex coordinates to use when
6734: * rendering. <code>size</code> specifies the number of coordinates
6735: * per vertex and type the data type of the
6736: * coordinates. <code>stride</code> specifies the byte stride from
6737: * one vertex to the next allowing vertices and attributes to be
6738: * packed into a single array or stored in separate
6739: * arrays. (Single-array storage may be more efficient on some
6740: * implementations.)
6741: *
6742: * <p>When a vertex array is specified, <code>size</code>,
6743: * <code>type</code>, <code>stride</code>, and <code>pointer</code>
6744: * are saved as client-side state.
6745: *
6746: * <p>If the vertex array is enabled, it is used when
6747: * <code>glDrawArrays</code>, or <code>glDrawElements</code> is
6748: * called. To enable and disable the vertex array, call
6749: * <code>glEnableClientState</code> and
6750: * <code>glDisableClientState</code> with the argument
6751: * <code>GL_VERTEX_ARRAY</code>. The vertex array is initially
6752: * disabled and isn't accessed when <code>glDrawArrays</code> or
6753: * <code>glDrawElements</code> is called.
6754: *
6755: * <p>Use <code>glDrawArrays</code> to construct a sequence of
6756: * primitives (all of the same type) from prespecified vertex and
6757: * vertex attribute arrays. Use <code>glDrawElements</code> to
6758: * construct a sequence of primitives by indexing vertices and
6759: * vertex attributes.
6760: *
6761: * <h4>Notes</h4>
6762: *
6763: * <p><code>glVertexPointer</code> is typically implemented on the
6764: * client side.
6765: *
6766: * <h4>Errors</h4>
6767: *
6768: * <p><code>GL_INVALID_VALUE</code> is generated if size is not 2,
6769: * 3, or 4.
6770: *
6771: * <p><code>GL_INVALID_ENUM</code> is generated if type is is not an
6772: * accepted value.
6773: *
6774: * <p><code>GL_INVALID_VALUE</code> is generated if stride is
6775: * negative.
6776: *
6777: * <p> The <code>pointer</code> argument must be a direct buffer
6778: * with a type matching that specified by the <code>type</code>
6779: * argument.
6780: *
6781: * @param size Specifies the number of coordinates per vertex. Must
6782: * be 2, 3, or 4. The initial value is 4.
6783: * @param type Specifies the data type of each vertex coordinate in
6784: * the array. Symbolic constants <code>GL_BYTE</code>,
6785: * <code>GL_SHORT</code>, <code>GL_FIXED</code>, and
6786: * <code>GL_FLOAT</code> are accepted. The initial value is
6787: * <code>GL_FLOAT</code>.
6788: * @param stride Specifies the byte offset between consecutive
6789: * vertices. If stride is 0, the vertices are understood to be
6790: * tightly packed in the array. The initial value is 0.
6791: * @param pointer Specifies a Buffer containing the coordinates of
6792: * the vertices.
6793: *
6794: * @exception IllegalStateException if OpenGL ES 1.1 is being used and
6795: * VBOs are enabled.
6796: * @exception IllegalArgumentException if <code>pointer</code>
6797: * is not direct.
6798: */
6799: void glVertexPointer(int size, int type, int stride, Buffer pointer);
6800:
6801: /**
6802: * Set the viewport.
6803: *
6804: * <p><code>glViewport</code> specifies the affine transformation of
6805: * x and y from normalized device coordinates to window
6806: * coordinates. Let (xnd, ynd) be normalized device
6807: * coordinates. Then the window coordinates (xw, yw) are computed as
6808: * follows:
6809: *
6810: * <pre>
6811: * xw = ( xnd + 1 ) width/2 + x
6812: * yw = ( ynd + 1 ) height/2 + y
6813: * </pre>
6814: *
6815: * <p>Viewport width and height are silently clamped to a range that
6816: * depends on the implementation. To query this range, call
6817: * <code>glGetIntegerv</code> with argument
6818: * <code>GL_MAX_VIEWPORT_DIMS</code>.
6819: *
6820: * <h4>Errors</h4>
6821: *
6822: * <p><code>GL_INVALID_VALUE</code> is generated if either width or
6823: * height is negative.
6824: *
6825: * <h4>Associated Gets</h4>
6826: *
6827: * <p><code>glGetIntegerv</code> with argument
6828: * <code>GL_MAX_VIEWPORT_DIMS</code>
6829: *
6830: * @param x Specifies the x coordinate of the lower left corner of
6831: * the viewport rectangle, in pixels. The initial value is 0.
6832: * @param y Specifies the y coordinate of the lower left corner of
6833: * the viewport rectangle, in pixels. The initial value is 0.
6834: * @param width Specifies the width of the viewport. When a GL
6835: * context is first attached to a surface (e.g. window), width and
6836: * height are set to the dimensions of that surface.
6837: * @param height Specifies the height of the viewport. When a GL
6838: * context is first attached to a surface (e.g. window), width and
6839: * height are set to the dimensions of that surface.
6840: */
6841: void glViewport(int x, int y, int width, int height);
6842: }
|