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:
0031: * The <code>GL11</code> interface contains the Java(TM) programming
0032: * language bindings for OpenGL(R) ES 1.1 core functionality.
0033: *
0034: * <p> The <code>OES_matrix_get</code>, <code>OES_point_sprite</code> and
0035: * <code>OES_point_size_array</code> core extensions are defined as
0036: * part of this interface.
0037: *
0038: * <p> Methods that are also present in OpenGL ES 1.0 are included in
0039: * this interface by inheritance, but are not separately documented.
0040: * Instead, the documentation from the <code>GL10</code> interface
0041: * specifies the functional differences between 1.0 and 1.1.
0042: *
0043: * <p> See the <code>GL</code> interface for a description of how to
0044: * obtain an instance of this interface.
0045: */
0046: public interface GL11 extends GL10 {
0047:
0048: // Begin GL 1.1
0049:
0050: // ClipPlaneName
0051:
0052: /** OpenGL ES 1.1 constant. */
0053: int GL_CLIP_PLANE0 = 0x3000;
0054: /** OpenGL ES 1.1 constant. */
0055: int GL_CLIP_PLANE1 = 0x3001;
0056: /** OpenGL ES 1.1 constant. */
0057: int GL_CLIP_PLANE2 = 0x3002;
0058: /** OpenGL ES 1.1 constant. */
0059: /** OpenGL ES 1.1 constant. */
0060: int GL_CLIP_PLANE3 = 0x3003;
0061: /** OpenGL ES 1.1 constant. */
0062: int GL_CLIP_PLANE4 = 0x3004;
0063: /** OpenGL ES 1.1 constant. */
0064: int GL_CLIP_PLANE5 = 0x3005;
0065:
0066: // GetPName
0067:
0068: /** OpenGL ES 1.1 constant. */
0069: int GL_CURRENT_COLOR = 0x0B00;
0070: /** OpenGL ES 1.1 constant. */
0071: int GL_CURRENT_NORMAL = 0x0B02;
0072: /** OpenGL ES 1.1 constant. */
0073: int GL_CURRENT_TEXTURE_COORDS = 0x0B03;
0074: /** OpenGL ES 1.1 constant. */
0075: int GL_POINT_SIZE = 0x0B11;
0076: /** OpenGL ES 1.1 constant. */
0077: int GL_POINT_SIZE_MIN = 0x8126;
0078: /** OpenGL ES 1.1 constant. */
0079: int GL_POINT_SIZE_MAX = 0x8127;
0080: /** OpenGL ES 1.1 constant. */
0081: int GL_POINT_FADE_THRESHOLD_SIZE = 0x8128;
0082: /** OpenGL ES 1.1 constant. */
0083: int GL_POINT_DISTANCE_ATTENUATION = 0x8129;
0084: /** OpenGL ES 1.1 constant. */
0085: int GL_LINE_WIDTH = 0x0B21;
0086: /** OpenGL ES 1.1 constant. */
0087: int GL_CULL_FACE_MODE = 0x0B45;
0088: /** OpenGL ES 1.1 constant. */
0089: int GL_FRONT_FACE = 0x0B46;
0090: /** OpenGL ES 1.1 constant. */
0091: int GL_SHADE_MODEL = 0x0B54;
0092: /** OpenGL ES 1.1 constant. */
0093: int GL_DEPTH_RANGE = 0x0B70;
0094: /** OpenGL ES 1.1 constant. */
0095: int GL_DEPTH_WRITEMASK = 0x0B72;
0096: /** OpenGL ES 1.1 constant. */
0097: int GL_DEPTH_CLEAR_VALUE = 0x0B73;
0098: /** OpenGL ES 1.1 constant. */
0099: int GL_DEPTH_FUNC = 0x0B74;
0100: /** OpenGL ES 1.1 constant. */
0101: int GL_STENCIL_CLEAR_VALUE = 0x0B91;
0102: /** OpenGL ES 1.1 constant. */
0103: int GL_STENCIL_FUNC = 0x0B92;
0104: /** OpenGL ES 1.1 constant. */
0105: int GL_STENCIL_VALUE_MASK = 0x0B93;
0106: /** OpenGL ES 1.1 constant. */
0107: int GL_STENCIL_FAIL = 0x0B94;
0108: /** OpenGL ES 1.1 constant. */
0109: int GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95;
0110: /** OpenGL ES 1.1 constant. */
0111: int GL_STENCIL_PASS_DEPTH_PASS = 0x0B96;
0112: /** OpenGL ES 1.1 constant. */
0113: int GL_STENCIL_REF = 0x0B97;
0114: /** OpenGL ES 1.1 constant. */
0115: int GL_STENCIL_WRITEMASK = 0x0B98;
0116: /** OpenGL ES 1.1 constant. */
0117: int GL_MATRIX_MODE = 0x0BA0;
0118: /** OpenGL ES 1.1 constant. */
0119: int GL_VIEWPORT = 0x0BA2;
0120: /** OpenGL ES 1.1 constant. */
0121: int GL_MODELVIEW_STACK_DEPTH = 0x0BA3;
0122: /** OpenGL ES 1.1 constant. */
0123: int GL_PROJECTION_STACK_DEPTH = 0x0BA4;
0124: /** OpenGL ES 1.1 constant. */
0125: int GL_TEXTURE_STACK_DEPTH = 0x0BA5;
0126: /** OpenGL ES 1.1 constant. */
0127: int GL_MODELVIEW_MATRIX = 0x0BA6;
0128: /** OpenGL ES 1.1 constant. */
0129: int GL_PROJECTION_MATRIX = 0x0BA7;
0130: /** OpenGL ES 1.1 constant. */
0131: int GL_TEXTURE_MATRIX = 0x0BA8;
0132: /** OpenGL ES 1.1 constant. */
0133: int GL_ALPHA_TEST_FUNC = 0x0BC1;
0134: /** OpenGL ES 1.1 constant. */
0135: int GL_ALPHA_TEST_REF = 0x0BC2;
0136: /** OpenGL ES 1.1 constant. */
0137: int GL_BLEND_DST = 0x0BE0;
0138: /** OpenGL ES 1.1 constant. */
0139: int GL_BLEND_SRC = 0x0BE1;
0140: /** OpenGL ES 1.1 constant. */
0141: int GL_LOGIC_OP_MODE = 0x0BF0;
0142: /** OpenGL ES 1.1 constant. */
0143: int GL_SCISSOR_BOX = 0x0C10;
0144: /** OpenGL ES 1.1 constant. */
0145: int GL_COLOR_CLEAR_VALUE = 0x0C22;
0146: /** OpenGL ES 1.1 constant. */
0147: int GL_COLOR_WRITEMASK = 0x0C23;
0148: /** OpenGL ES 1.1 constant. */
0149: int GL_MAX_CLIP_PLANES = 0x0D32;
0150: /** OpenGL ES 1.1 constant. */
0151: int GL_POLYGON_OFFSET_UNITS = 0x2A00;
0152: /** OpenGL ES 1.1 constant. */
0153: int GL_POLYGON_OFFSET_FACTOR = 0x8038;
0154: /** OpenGL ES 1.1 constant. */
0155: int GL_TEXTURE_BINDING_2D = 0x8069;
0156: /** OpenGL ES 1.1 constant. */
0157: int GL_VERTEX_ARRAY_SIZE = 0x807A;
0158: /** OpenGL ES 1.1 constant. */
0159: int GL_VERTEX_ARRAY_TYPE = 0x807B;
0160: /** OpenGL ES 1.1 constant. */
0161: int GL_VERTEX_ARRAY_STRIDE = 0x807C;
0162: /** OpenGL ES 1.1 constant. */
0163: int GL_NORMAL_ARRAY_TYPE = 0x807E;
0164: /** OpenGL ES 1.1 constant. */
0165: int GL_NORMAL_ARRAY_STRIDE = 0x807F;
0166: /** OpenGL ES 1.1 constant. */
0167: int GL_COLOR_ARRAY_SIZE = 0x8081;
0168: /** OpenGL ES 1.1 constant. */
0169: int GL_COLOR_ARRAY_TYPE = 0x8082;
0170: /** OpenGL ES 1.1 constant. */
0171: int GL_COLOR_ARRAY_STRIDE = 0x8083;
0172: /** OpenGL ES 1.1 constant. */
0173: int GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088;
0174: /** OpenGL ES 1.1 constant. */
0175: int GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089;
0176: /** OpenGL ES 1.1 constant. */
0177: int GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A;
0178:
0179: /** OpenGL ES 1.1 constant. */
0180: int GL_VERTEX_ARRAY_POINTER = 0x808E;
0181: /** OpenGL ES 1.1 constant. */
0182: int GL_NORMAL_ARRAY_POINTER = 0x808F;
0183: /** OpenGL ES 1.1 constant. */
0184: int GL_COLOR_ARRAY_POINTER = 0x8090;
0185: /** OpenGL ES 1.1 constant. */
0186: int GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092;
0187:
0188: /** OpenGL ES 1.1 constant. */
0189: int GL_SAMPLE_BUFFERS = 0x80A8;
0190: /** OpenGL ES 1.1 constant. */
0191: int GL_SAMPLES = 0x80A9;
0192: /** OpenGL ES 1.1 constant. */
0193: int GL_SAMPLE_COVERAGE_VALUE = 0x80AA;
0194: /** OpenGL ES 1.1 constant. */
0195: int GL_SAMPLE_COVERAGE_INVERT = 0x80AB;
0196:
0197: // HintTarget
0198:
0199: /** OpenGL ES 1.1 constant. */
0200: int GL_GENERATE_MIPMAP_HINT = 0x8192;
0201:
0202: // TextureParameterName
0203:
0204: /** OpenGL ES 1.1 constant. */
0205: int GL_GENERATE_MIPMAP = 0x8191;
0206:
0207: // TextureUnit
0208:
0209: /** OpenGL ES 1.1 constant. */
0210: int GL_ACTIVE_TEXTURE = 0x84E0;
0211: /** OpenGL ES 1.1 constant. */
0212: int GL_CLIENT_ACTIVE_TEXTURE = 0x84E1;
0213:
0214: // Buffer Objects
0215:
0216: /** OpenGL ES 1.1 constant. */
0217: int GL_ARRAY_BUFFER = 0x8892;
0218: /** OpenGL ES 1.1 constant. */
0219: int GL_ELEMENT_ARRAY_BUFFER = 0x8893;
0220:
0221: /** OpenGL ES 1.1 constant. */
0222: int GL_ARRAY_BUFFER_BINDING = 0x8894;
0223: /** OpenGL ES 1.1 constant. */
0224: int GL_ELEMENT_ARRAY_BUFFER_BINDING = 0x8895;
0225: /** OpenGL ES 1.1 constant. */
0226: int GL_VERTEX_ARRAY_BUFFER_BINDING = 0x8896;
0227: /** OpenGL ES 1.1 constant. */
0228: int GL_NORMAL_ARRAY_BUFFER_BINDING = 0x8897;
0229: /** OpenGL ES 1.1 constant. */
0230: int GL_COLOR_ARRAY_BUFFER_BINDING = 0x8898;
0231: /** OpenGL ES 1.1 constant. */
0232: int GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A;
0233:
0234: /** OpenGL ES 1.1 constant. */
0235: int GL_STATIC_DRAW = 0x88E4;
0236: /** OpenGL ES 1.1 constant. */
0237: int GL_DYNAMIC_DRAW = 0x88E8;
0238:
0239: /** OpenGL ES 1.1 constant. */
0240: int GL_WRITE_ONLY = 0x88B9;
0241:
0242: /** OpenGL ES 1.1 constant. */
0243: int GL_BUFFER_SIZE = 0x8764;
0244: /** OpenGL ES 1.1 constant. */
0245: int GL_BUFFER_USAGE = 0x8765;
0246: /** OpenGL ES 1.1 constant. */
0247: int GL_BUFFER_ACCESS = 0x88BB;
0248:
0249: // Texture combine + dot3
0250:
0251: /** OpenGL ES 1.1 constant. */
0252: int GL_SUBTRACT = 0x84E7;
0253: /** OpenGL ES 1.1 constant. */
0254: int GL_COMBINE = 0x8570;
0255: /** OpenGL ES 1.1 constant. */
0256: int GL_COMBINE_RGB = 0x8571;
0257: /** OpenGL ES 1.1 constant. */
0258: int GL_COMBINE_ALPHA = 0x8572;
0259: /** OpenGL ES 1.1 constant. */
0260: int GL_RGB_SCALE = 0x8573;
0261: /** OpenGL ES 1.1 constant. */
0262: int GL_ADD_SIGNED = 0x8574;
0263: /** OpenGL ES 1.1 constant. */
0264: int GL_INTERPOLATE = 0x8575;
0265: /** OpenGL ES 1.1 constant. */
0266: int GL_CONSTANT = 0x8576;
0267: /** OpenGL ES 1.1 constant. */
0268: int GL_PRIMARY_COLOR = 0x8577;
0269: /** OpenGL ES 1.1 constant. */
0270: int GL_PREVIOUS = 0x8578;
0271: /** OpenGL ES 1.1 constant. */
0272: int GL_OPERAND0_RGB = 0x8590;
0273: /** OpenGL ES 1.1 constant. */
0274: int GL_OPERAND1_RGB = 0x8591;
0275: /** OpenGL ES 1.1 constant. */
0276: int GL_OPERAND2_RGB = 0x8592;
0277: /** OpenGL ES 1.1 constant. */
0278: int GL_OPERAND0_ALPHA = 0x8598;
0279: /** OpenGL ES 1.1 constant. */
0280: int GL_OPERAND1_ALPHA = 0x8599;
0281: /** OpenGL ES 1.1 constant. */
0282: int GL_OPERAND2_ALPHA = 0x859A;
0283:
0284: /** OpenGL ES 1.1 constant. */
0285: int GL_ALPHA_SCALE = 0x0D1C;
0286:
0287: /** OpenGL ES 1.1 constant. */
0288: int GL_SRC0_RGB = 0x8580;
0289: /** OpenGL ES 1.1 constant. */
0290: int GL_SRC1_RGB = 0x8581;
0291: /** OpenGL ES 1.1 constant. */
0292: int GL_SRC2_RGB = 0x8582;
0293: /** OpenGL ES 1.1 constant. */
0294: int GL_SRC0_ALPHA = 0x8588;
0295: /** OpenGL ES 1.1 constant. */
0296: int GL_SRC1_ALPHA = 0x8589;
0297: /** OpenGL ES 1.1 constant. */
0298: int GL_SRC2_ALPHA = 0x858A;
0299:
0300: /** OpenGL ES 1.1 constant. */
0301: int GL_DOT3_RGB = 0x86AE;
0302: /** OpenGL ES 1.1 constant. */
0303: int GL_DOT3_RGBA = 0x86AF;
0304:
0305: // Functions
0306:
0307: // Buffers
0308:
0309: /**
0310: * Generate buffer object names.
0311: *
0312: * <p><code>glGenBuffers</code> returns <code>n</code> buffer object
0313: * names in <code>buffers</code>.
0314: *
0315: * <p>These names are marked as used, for the purposes of
0316: * <code>glGenBuffers</code> only, but they acquire buffer state
0317: * only when they are first bound, just as if they were unused.
0318: *
0319: * <h4>Errors</h4>
0320: *
0321: * <p>GL_INVALID_VALUE is generated if <code>n</code> is negative.
0322: *
0323: * @param n Specifies the number of buffer object names to be generated.
0324: * @param buffers Specifies an array in which the generated buffer
0325: * object names are stored.
0326: * @param offset the starting offset within the
0327: * <code>buffers</code> array.
0328: *
0329: * @exception IllegalArgumentException if <code>buffers</code> is
0330: * <code>null</code>.
0331: * @exception IllegalArgumentException if <code>offset</code> is
0332: * less than 0.
0333: * @exception IllegalArgumentException if
0334: * <code>buffers.length - offset</code> is less than <code>n</code>.
0335: */
0336: void glGenBuffers(int n, int[] buffers, int offset);
0337:
0338: /**
0339: * Integer <code>Buffer</code> version of
0340: * <code>glGenBuffers</code>.
0341: *
0342: * @see #glGenBuffers(int n, int[] buffers, int offset)
0343: *
0344: * @exception IllegalArgumentException if <code>buffers</code> is
0345: * <code>null</code>.
0346: * @exception IllegalArgumentException if
0347: * <code>buffers.remaining()</code> is less than <code>n</code>.
0348: */
0349: void glGenBuffers(int n, IntBuffer buffers);
0350:
0351: /**
0352: * Bind a named buffer to a target.
0353: *
0354: * <p><code>glBindBuffer</code> lets you create or use a named
0355: * buffer. Calling <code>glBindBuffer</code> with
0356: * <code>target</code> set to <code>GL_ARRAY_BUFFER</code> or
0357: * <code>GL_ELEMENT_ARRAY_BUFFER</code> and <code>buffer</code> set
0358: * to the buffer name, binds the buffer name to the target.
0359: *
0360: * <p>Buffer names are unsigned integers. The value 0 is reserved
0361: * for GL.
0362: *
0363: * <p>When a buffer is bound to a target, any previous binding for
0364: * that target is automatically broken.
0365: *
0366: * <p>If an unused buffer name is specified, a buffer object is
0367: * created. The resulting buffer object is a new state vector,
0368: * initialized with a zero-sized memory buffer, and with the
0369: * following state values.
0370: *
0371: * <p><code>GL_BUFFER_SIZE</code> initialized to 0.
0372: * <p><code>GL_BUFFER_USAGE</code> initialized to
0373: * <code>GL_STATIC_DRAW</code>.
0374: * <p><code>GL_BUFFER_ACCESS</code>
0375: * initialized to <code>GL_WRITE_ONLY</code>.
0376: * <p><code>glBindBuffer</code> may also be used to bind an existing
0377: * buffer object. If the bind is successful no change is made to the
0378: * state of the newly bound buffer object.
0379: *
0380: * <p>While a buffer is bound, GL operations on the target to which
0381: * it is bound affect the bound buffer object, and queries of the
0382: * target to which a buffer object is bound return state from the
0383: * bound object.
0384: *
0385: * <h4>Notes</h4>
0386: *
0387: * <p>In the initial state the reserved name zero is bound to
0388: * <code>GL_ARRAY_BUFFER</code> and
0389: * <code>GL_ELEMENT_ARRAY_BUFFER</code>. There is no buffer object
0390: * corresponding to the name zero, so client attempts to modify or
0391: * query buffer object state for the target
0392: * <code>GL_ARRAY_BUFFER</code> or
0393: * <code>GL_ELEMENT_ARRAY_BUFFER</code> while zero is bound will
0394: * generate GL errors.
0395: *
0396: * <p>While a buffer object is bound, any GL operations on that
0397: * object affect any other bindings of that object.
0398: *
0399: * <h4>Errors</h4>
0400: *
0401: * <p><code>GL_INVALID_ENUM</code> is generated if
0402: * <code>target</code> is not one of the allowable values.
0403: *
0404: * @param target Specifies the target to which the buffer is
0405: * bound. Which must be <code>GL_ARRAY_BUFFER</code> or
0406: * <code>GL_ELEMENT_ARRAY_BUFFER</code>.
0407: * @param buffer Specifies the name of a buffer.
0408: */
0409: void glBindBuffer(int target, int buffer);
0410:
0411: /**
0412: * Creates and initializes the data store of a buffer object.
0413: *
0414: * <code>glBufferData</code> lets you create and initialize the data
0415: * store of a buffer object.
0416: *
0417: * <p>If <code>data</code> is non-<code>null</code>, then the source
0418: * data is copied to the buffer object’s data store. If
0419: * <code>data</code> is <code>null</code>, then the contents of the
0420: * buffer object’s data store are undefined.
0421: *
0422: * <p>The options for <code>usage</code> are:
0423: *
0424: * <ul>
0425: *
0426: * <li><code>GL_STATIC_DRAW</code></li>
0427: *
0428: * <p> Where the data store contents will be specified once by the
0429: * application, and used many times as the source for GL drawing
0430: * commands.
0431: *
0432: * <li><code>GL_DYNAMIC_DRAW</code></li>
0433: *
0434: * <p> Where the data store contents will be respecified repeatedly
0435: * by the application, and used many times as the source for GL
0436: * drawing commands.
0437: *
0438: * </ul>
0439: *
0440: * <p><code>glBufferData</code> deletes any existing data store, and
0441: * sets the values of the buffer object’s state variables thus:
0442: *
0443: * <p><code>GL_BUFFER_SIZE</code> initialized to <code>size</code>.
0444: * <p><code>GL_BUFFER_USAGE</code> initialized to <code>usage</code>.
0445: * <p><code>GL_BUFFER_ACCESS</code> initialized to
0446: * <code>GL_WRITE_ONLY</code>.
0447: *
0448: * <p>Clients must align data elements consistent with the
0449: * requirements of the client platform, with an additional
0450: * base-level requirement that an offset within a buffer to a datum
0451: * comprising N basic machine units be a multiple of N.
0452: *
0453: * <h4>Notes</h4>
0454: *
0455: * <p><code>usage</code> is provided as a performance hint only. The
0456: * specified usage value does not constrain the actual usage pattern
0457: * of the data store.
0458: *
0459: * <h4>Errors</h4>
0460: *
0461: * <p><code>GL_INVALID_ENUM</code> is generated if
0462: * <code>target</code> is not one of the allowable values.
0463: *
0464: * <p><code>GL_INVALID_ENUM</code> is generated if
0465: * <code>usage</code> is not one of the allowable values.
0466: *
0467: * <p><code>GL_OUT_OF_MEMORY</code> is generated if the GL is unable
0468: * to create a data store of the requested size.
0469: *
0470: * @param target Specifies the buffer object target, which must be
0471: * <code>GL_ARRAY_BUFFER</code> or
0472: * <code>GL_ELEMENT_ARRAY_BUFFER</code>.
0473: * @param size Specifies the size of the data store in basic machine
0474: * units.
0475: * @param data Specifies the source data in client memory.
0476: * @param usage Specifies the expected application usage pattern of
0477: * the data store. Accepted values are <code>GL_STATIC_DRAW</code>
0478: * and <code>GL_DYNAMIC_DRAW</code>.
0479: *
0480: * @exception IllegalArgumentException if <code>data</code> is
0481: * <code>non-null</code> but is not a direct buffer.
0482: *
0483: * <!-- Need revisit - buffer type mixing - byte order issues -->
0484: */
0485: void glBufferData(int target, int size, Buffer data, int usage);
0486:
0487: /**
0488: * Modifies some or all of the data contained in a buffer object's
0489: * data store.
0490: *
0491: * <p><code>glBufferSubData</code> lets you modify some or all of
0492: * the data contained in a buffer object's data store.
0493: *
0494: * <h4>Errors</h4>
0495: *
0496: * <p>GL_INVALID_ENUM is generated if <code>target</code> is not one of the
0497: * allowable values.
0498: *
0499: * <p>GL_INVALID_VALUE is generated if <code>offset</code> or
0500: * <code>size</code> is less than zero, or if <code>offset +
0501: * size</code> is greater than the value of
0502: * <code>GL_BUFFER_SIZE</code>.
0503: *
0504: * @param target Specifies the buffer object <code>target</code>. Must be
0505: * <code>GL_ARRAY_BUFFER</code> or
0506: * <code>GL_ELEMENT_ARRAY_BUFFER</code>.
0507: * @param offset Specifies the starting offset of the data to be
0508: * replaced in bytes.
0509: * @param size Specifies the size of the data to be replaced in bytes.
0510: * @param data Specifies a region of client memory <code>size</code>
0511: * bytes in length, containing the data that replace the specified
0512: * buffer range.
0513: *
0514: * @exception IllegalArgumentException if <code>data</code> is
0515: * <code>null</code>.
0516: *
0517: * <!-- Need revisit - buffer type mixing - byte order issues -->
0518: */
0519: void glBufferSubData(int target, int offset, int size, Buffer data);
0520:
0521: /**
0522: * Delete named buffer objects.
0523: *
0524: * <p><code>glDeleteBuffers</code> deletes <code>n</code> buffer
0525: * objects named by the elements of the array buffers. After a
0526: * buffer object is deleted, it has no contents, and its name is
0527: * free for reuse.
0528: *
0529: * <p><code>glDeleteBuffers</code> silently ignores zero and names
0530: * that do not correspond to existing buffer objects.
0531: *
0532: * <h4>Notes</h4>
0533: *
0534: * <p>If a buffer object is deleted while it is bound, all bindings
0535: * to that object in the current context (i.e., in the thread that
0536: * called <code>glDeleteBuffers</code>) are reset to zero. Bindings
0537: * to that buffer in other contexts and other threads are not
0538: * affected, but attempting to use a deleted buffer in another
0539: * thread produces undefined results, including but not limited to
0540: * possible GL errors and rendering corruption. Using a deleted
0541: * buffer in another context or thread may not, however, result in
0542: * program termination.
0543: *
0544: * <h4>Errors</h4>
0545: *
0546: * <p><code>GL_INVALID_VALUE</code> is generated if <code>n</code>
0547: * is negative.
0548: *
0549: * @param n Specifies the number of buffer objects to be deleted.
0550: * @param buffers Specifies an array of buffer object names to be
0551: * deleted.
0552: * @param offset the starting offset within the
0553: * <code>buffers</code> array.
0554: *
0555: * @exception IllegalArgumentException if <code>buffers</code> is
0556: * <code>null</code>.
0557: * @exception IllegalArgumentException if <code>offset</code> is
0558: * less than 0.
0559: * @exception IllegalArgumentException if
0560: * <code>buffers.length - offset</code> is less than <code>n</code>.
0561: */
0562: void glDeleteBuffers(int n, int[] buffers, int offset);
0563:
0564: /**
0565: * Integer <code>Buffer</code> version of
0566: * <code>glDeleteBuffers</code>.
0567: *
0568: * @see #glDeleteBuffers(int n, int[] buffers, int offset)
0569: *
0570: * @exception IllegalArgumentException if <code>buffers</code> is
0571: * <code>null</code>.
0572: * @exception IllegalArgumentException if
0573: * <code>buffers.remaining()</code> is less than <code>n</code>.
0574: */
0575: void glDeleteBuffers(int n, IntBuffer buffers);
0576:
0577: // Clip Planes
0578:
0579: /**
0580: * Specify a plane against which all geometry is clipped.
0581: *
0582: * <p>Geometry is always clipped against the boundaries of a
0583: * six-plane frustum in x, y, and z. <code>glClipPlane</code> allows
0584: * the specification of additional planes, not necessarily
0585: * perpendicular to the x, y, or z axis, against which all geometry
0586: * is clipped. To determine the maximum number of additional
0587: * clipping planes, call <code>glGet</code> with argument
0588: * <code>GL_MAX_CLIP_PLANES</code>. All implementations support at
0589: * least one such clipping planes. Because the resulting clipping
0590: * region is the intersection of the defined half-spaces, it is
0591: * always convex.
0592: *
0593: * <p><code>glClipPlane</code> specifies a half-space using a
0594: * four-component plane equation. When <code>glClipPlane</code> is
0595: * called, equation is transformed by the inverse of the modelview
0596: * matrix and stored in the resulting eye coordinates. Subsequent
0597: * changes to the modelview matrix have no effect on the stored
0598: * plane-equation components. If the dot product of the eye
0599: * coordinates of a vertex with the stored plane equation components
0600: * is positive or zero, the vertex is in with respect to that
0601: * clipping plane. Otherwise, it is out.
0602: *
0603: * <p>To enable and disable clipping planes, call
0604: * <code>glEnable</code> and glDisable with the argument
0605: * <code>GL_CLIP_PLANE</code><i>i</i>, where <i>i</i> is the plane number.
0606: *
0607: * <p>All clipping planes are initially defined as (0, 0, 0, 0) in
0608: * eye coordinates and are disabled.
0609: *
0610: * <h4>Notes</h4>
0611: *
0612: * <p>It is always the case that <code>GL_CLIP_PLANE</code><i>i</i> =
0613: * <code>GL_CLIP_PLANE0</code> + <i>i</i>.
0614: *
0615: * <h4>Errors</h4>
0616: *
0617: * <p><code>GL_INVALID_ENUM</code> is generated if
0618: * <code>plane</code> is not an accepted value.
0619: *
0620: * <h4>Associated Gets</h4>
0621: *
0622: * <p><code>glGetClipPlane</code>, <code>glIsEnabled</code> with
0623: * argument <code>GL_CLIP_PLANE</code><i>i</i>.
0624: *
0625: * @param plane Specifies which clipping plane is being
0626: * positioned. Symbolic names of the form
0627: * <code>GL_CLIP_PLANE</code><i>i</i> where <code>0 < <i>i</i> <
0628: * GL_MAX_CLIP_PLANES</code> are accepted.
0629: * @param equation Specifies an array of four values. These values
0630: * are interpreted as a plane equation.
0631: * @param offset the starting offset within the
0632: * <code>equation</code> array.
0633: *
0634: * @exception IllegalArgumentException if <code>equation</code> is
0635: * <code>null</code>.
0636: * @exception IllegalArgumentException if <code>offset</code> is
0637: * less than 0.
0638: * @exception IllegalArgumentException if
0639: * <code>equation.length - offset</code> is less than 4.
0640: */
0641: void glClipPlanef(int plane, float[] equation, int offset);
0642:
0643: /**
0644: * Floating-point <code>Buffer</code> version of
0645: * <code>glClipPlane</code>.
0646: *
0647: * @see #glClipPlanef(int plane, float[] equation, int offset)
0648: *
0649: * @exception IllegalArgumentException if <code>equation</code> is
0650: * <code>null</code>.
0651: * @exception IllegalArgumentException if
0652: * <code>equation.remaining()</code> is less than 4.
0653: */
0654: void glClipPlanef(int plane, FloatBuffer equation);
0655:
0656: /**
0657: * Fixed-point array version of <code>glClipPlane</code>.
0658: *
0659: * @see #glClipPlanef(int plane, float[] equation, int offset)
0660: *
0661: * @exception IllegalArgumentException if <code>equation</code> is
0662: * <code>null</code>.
0663: * @exception IllegalArgumentException if <code>offset</code> is
0664: * less than 0.
0665: * @exception IllegalArgumentException if
0666: * <code>equation.length - offset</code> is less than 4.
0667: */
0668: void glClipPlanex(int plane, int[] equation, int offset);
0669:
0670: /**
0671: * Fixed-point <code>Buffer</code> version of
0672: * <code>glClipPlane</code>.
0673: *
0674: * @see #glClipPlanef(int plane, float[] equation, int offset)
0675: *
0676: * @exception IllegalArgumentException if <code>equation</code> is
0677: * <code>null</code>.
0678: * @exception IllegalArgumentException if
0679: * <code>equation.remaining()</code> is less than 4.
0680: */
0681: void glClipPlanex(int plane, IntBuffer equation);
0682:
0683: // Getters
0684:
0685: /**
0686: * Floating-point array version of <code>glGet</code>.
0687: *
0688: * @see #glGetIntegerv(int pname, int[] params, int offset)
0689: *
0690: * @exception IllegalArgumentException if <code>params</code> is
0691: * <code>null</code>.
0692: * @exception IllegalArgumentException if <code>offset</code> is
0693: * less than 0.
0694: * @exception IllegalArgumentException if <code>params.length -
0695: * offset</code> is smaller than the number of values required by
0696: * the parameter.
0697: */
0698: void glGetFloatv(int pname, float[] params, int offset);
0699:
0700: /**
0701: * Floating-point <code>Buffer</code> version of
0702: * <code>glGet</code>.
0703: *
0704: * @see #glGetIntegerv(int pname, int[] params, int offset)
0705: *
0706: * @exception IllegalArgumentException if <code>params</code> is
0707: * <code>null</code>.
0708: * @exception IllegalArgumentException if
0709: * <code>params.remaining()</code> is smaller than the number of
0710: * values required by the parameter.
0711: */
0712: void glGetFloatv(int pname, FloatBuffer params);
0713:
0714: /**
0715: * Boolean array version of <code>glGet</code>.
0716: *
0717: * @see #glGetIntegerv(int pname, int[] params, int offset)
0718: *
0719: * @exception IllegalArgumentException if <code>params</code> is
0720: * <code>null</code>.
0721: * @exception IllegalArgumentException if <code>offset</code> is
0722: * less than 0.
0723: * @exception IllegalArgumentException if <code>params.length -
0724: * offset</code> is smaller than the number of values required by
0725: * the parameter.
0726: */
0727: void glGetBooleanv(int pname, boolean[] params, int offset);
0728:
0729: /**
0730: * Boolean <code>Buffer</code> version of
0731: * <code>glGet</code>. A value of 0 represents <code>false</code>
0732: * and a value of 1 represents <code>true</code>.
0733: *
0734: * @see #glGetIntegerv(int pname, int[] params, int offset)
0735: *
0736: * @exception IllegalArgumentException if <code>params</code> is
0737: * <code>null</code>.
0738: * @exception IllegalArgumentException if
0739: * <code>params.remaining()</code> is smaller than the number of
0740: * values required by the parameter.
0741: */
0742: void glGetBooleanv(int pname, IntBuffer params);
0743:
0744: /**
0745: * Fixed-point array version of <code>glGet</code>.
0746: *
0747: * @see #glGetIntegerv(int pname, int[] params, int offset)
0748: *
0749: * @exception IllegalArgumentException if <code>params</code> is
0750: * <code>null</code>.
0751: * @exception IllegalArgumentException if <code>offset</code> is
0752: * less than 0.
0753: * @exception IllegalArgumentException if <code>params.length -
0754: * offset</code> is smaller than the number of values required by
0755: * the parameter.
0756: */
0757: void glGetFixedv(int pname, int[] params, int offset);
0758:
0759: /**
0760: * Fixed-point <code>Buffer</code> version of
0761: * <code>glGet</code>.
0762: *
0763: * @see #glGetIntegerv(int pname, int[] params, int offset)
0764: *
0765: * @exception IllegalArgumentException if <code>params</code> is
0766: * <code>null</code>.
0767: * @exception IllegalArgumentException if
0768: * <code>params.remaining()</code> is smaller than the number of
0769: * values required by the parameter.
0770: */
0771: void glGetFixedv(int pname, IntBuffer params);
0772:
0773: /**
0774: * Return buffer parameter values.
0775: *
0776: * <p><code>glGetBufferParameter</code> returns in
0777: * <code>params</code> the value or values of the buffer object
0778: * parameter specified as <code>pname</code>. <code>target</code>
0779: * defines the target buffer object, which must be
0780: * <code>GL_ARRAY_BUFFER</code>.
0781: *
0782: * <ul>
0783: *
0784: * <li><code>GL_BUFFER_SIZE</code></li>
0785: *
0786: * <p> Returns the size of the data store in bytes.
0787: *
0788: * <li><code>GL_BUFFER_USAGE</code></li>
0789: *
0790: * <p> Returns the expected application usage pattern of the data
0791: * store. Possible values are:
0792: *
0793: * <li><code>GL_STATIC_DRAW</code></li>
0794: *
0795: * <p> Where the data store contents will be specified once by the
0796: * application, and used many times as the source for GL drawing
0797: * commands.
0798: *
0799: * <li><code>GL_DYNAMIC_DRAW</code></li>
0800: *
0801: * <p> Where the data store contents will be respecified repeatedly
0802: * by the application, and used many times as the source for GL
0803: * drawing commands.
0804: *
0805: * <li><code>GL_BUFFER_ACCESS</code></li>
0806: *
0807: * <p> Returns the access capability for the data store. Will always
0808: * be <code>GL_WRITE_ONLY</code>.
0809: *
0810: * </ul>
0811: *
0812: * <h4>Errors</h4>
0813: *
0814: * <p><code>GL_INVALID_ENUM</code> is generated if
0815: * <code>target</code> or <code>pname</code> is not one of the
0816: * accepted defined values.
0817: *
0818: * @param target Specifies the buffer object target. Which must be
0819: * <code>GL_ARRAY_BUFFER</code>.
0820: * @param pname Specifies the symbolic name of a buffer object
0821: * parameter. Which can be either <code>GL_BUFFER_SIZE</code>,
0822: * <code>GL_BUFFER_USAGE</code>, or <code>GL_BUFFER_ACCESS</code>.
0823: * @param params returns the buffer object parameters.
0824: *
0825: * @exception IllegalArgumentException if <code>params</code> is
0826: * <code>null</code>.
0827: * @exception IllegalArgumentException if <code>offset</code> is
0828: * less than 0.
0829: * @exception IllegalArgumentException if <code>params.length -
0830: * offset</code> is smaller than the number of values required by
0831: * the parameter.
0832: */
0833: void glGetBufferParameteriv(int target, int pname, int[] params,
0834: int offset);
0835:
0836: /**
0837: * Integer <code>Buffer</code> version of
0838: * <code>glGetBufferParameter</code>.
0839: *
0840: * @see #glGetBufferParameteriv(int target, int pname, int[] params, int offset)
0841: *
0842: * @exception IllegalArgumentException if <code>params</code> is
0843: * <code>null</code>.
0844: * @exception IllegalArgumentException if
0845: * <code>params.remaining()</code> is smaller than the number of
0846: * values required by the parameter.
0847: */
0848: void glGetBufferParameteriv(int target, int pname, IntBuffer params);
0849:
0850: /**
0851: * Return the coefficients of the specified clipping
0852: * plane.
0853: *
0854: * <p><code>glGetClipPlane</code> returns in <code>equation</code>
0855: * the four coefficients of the plane equation for
0856: * <code>plane</code>.
0857: *
0858: * <h4>Notes</h4>
0859: *
0860: * <p>It is always the case that <code>GL_CLIP_PLANE</code><i>i</i> =
0861: * <code>GL_CLIP_PLANE0</code> + <i>i</i>.
0862: *
0863: * <p>If an error is generated, no change is made to the contents of
0864: * equation. <h4>Errors</h4>
0865: *
0866: * <p><code>GL_INVALID_ENUM</code> is generated if
0867: * <code>plane</code> is not an accepted value.
0868: *
0869: * @param plane Specifies a clipping plane. The number of clipping
0870: * planes depends on the implementation, but at least six clipping
0871: * planes are supported. They are identified by symbolic names of
0872: * the form <code>GL_CLIP_PLANE</code><i>i</i> where <code>0 <
0873: * <i>i</i> < GL_MAX_CLIP_PLANES</code>
0874: * @param equation Returns four values that are the coefficients of
0875: * the plane equation of plane in eye coordinates. The initial value
0876: * is (0, 0, 0, 0).
0877: * @param offset the starting offset within the
0878: * <code>equation</code> array.
0879: *
0880: * @exception IllegalArgumentException if <code>equation</code> is
0881: * <code>null</code>.
0882: * @exception IllegalArgumentException if <code>offset</code> is
0883: * less than 0.
0884: * @exception IllegalArgumentException if
0885: * <code>equation.length - offset</code> is less than 4.
0886: */
0887: void glGetClipPlanef(int plane, float[] equation, int offset);
0888:
0889: /**
0890: * Floating-point <code>Buffer</code> version of
0891: * <code>glGetClipPlane</code>.
0892: *
0893: * @see #glGetClipPlanef(int plane, float[] equation, int offset)
0894: *
0895: * @exception IllegalArgumentException if <code>equation</code> is
0896: * <code>null</code>.
0897: * @exception IllegalArgumentException if
0898: * <code>equation.remaining()</code> is less than 4.
0899: */
0900: void glGetClipPlanef(int plane, FloatBuffer equation);
0901:
0902: /**
0903: * Fixed-point array version of
0904: * <code>glGetClipPlane</code>.
0905: *
0906: * @see #glGetClipPlanef(int plane, float[] equation, int offset)
0907: *
0908: * @exception IllegalArgumentException if <code>equation</code> is
0909: * <code>null</code>.
0910: * @exception IllegalArgumentException if <code>offset</code> is
0911: * less than 0.
0912: * @exception IllegalArgumentException if <code>equation.length -
0913: * offset</code> is less than 4.
0914: */
0915: void glGetClipPlanex(int plane, int[] equation, int offset);
0916:
0917: /**
0918: * Fixed-point <code>Buffer</code> version of
0919: * <code>glGetClipPlane</code>.
0920: *
0921: * @see #glGetClipPlanef(int plane, float[] equation, int offset)
0922: *
0923: * @exception IllegalArgumentException if <code>equation</code> is
0924: * <code>null</code>.
0925: * @exception IllegalArgumentException if
0926: * <code>equation.remaining()</code> is less than 4.
0927: */
0928: void glGetClipPlanex(int plane, IntBuffer equation);
0929:
0930: /**
0931: * Return light source parameter values.
0932: *
0933: * <p><code>glGetLight</code> returns in params the value or values
0934: * of a light source parameter. light names the light and is a
0935: * symbolic name of the form <code>GL_LIGHT</code><i>i</i> for <code>0 < i
0936: * < GL_MAX_LIGHTS</code> where <code>GL_MAX_LIGHTS</code> is an
0937: * implementation dependent constant that is greater than or equal
0938: * to eight. <code>pname</code> specifies one of ten light source parameters,
0939: * again by symbolic name.
0940: *
0941: * The ten light parameters are defined:
0942: *
0943: * <ul>
0944: *
0945: * <li><code>GL_AMBIENT</code></li>
0946: *
0947: * <p> <code>params</code> returns four values that
0948: * specify the ambient RGBA intensity of the light. Both fixed-point
0949: * and floating-point values are mapped directly. Neither
0950: * fixed-point nor floating-point values are clamped. The initial
0951: * ambient light intensity is (0, 0, 0, 1).
0952: *
0953: * <li><code>GL_DIFFUSE</code></li>
0954: *
0955: * <p> <code>params</code> returns four values that
0956: * specify the diffuse RGBA intensity of the light. Both fixed-point
0957: * and floating-point values are mapped directly. Neither
0958: * fixed-point nor floating-point values are clamped. The initial
0959: * value for <code>GL_LIGHT0</code> is (1, 1, 1, 1). For other
0960: * lights, the initial value is (0, 0, 0, 0).
0961: *
0962: * <li><code>GL_SPECULAR</code></li>
0963: *
0964: * <p> <code>params</code> returns four values that
0965: * specify the specular RGBA intensity of the light. Both
0966: * fixed-point and floating-point values are mapped
0967: * directly. Neither fixed-point nor floating-point values are
0968: * clamped. The initial value for <code>GL_LIGHT0</code> is (1, 1,
0969: * 1, 1). For other lights, the initial value is (0, 0, 0, 0).
0970: *
0971: * <li><code>GL_EMISSION</code></li>
0972: *
0973: * <p> <code>params</code> returns four values
0974: * representing the emitted light intensity of the material. Both
0975: * fixed-point and floating-point values are mapped directly. The
0976: * initial value is (0, 0, 0, 1).
0977: *
0978: * <li><code>GL_SPOT_DIRECTION</code></li>
0979: *
0980: * <p> <code>params</code> returns three values
0981: * that specify the direction of the light in homogeneous object
0982: * coordinates. Both fixed-point and floating-point values are
0983: * mapped directly. Neither fixed-point nor floating-point values
0984: * are clamped. The initial direction is (0, 0, -1).
0985: *
0986: * <li><code>GL_SPOT_EXPONENT</code></li>
0987: *
0988: * <p> <code>params</code> returns a single value that specifies the
0989: * intensity distribution of the light. Fixed-point and
0990: * floating-point values are mapped directly. Only values in the
0991: * range <code>[0, 128]</code> are accepted. The initial spot
0992: * exponent is 0.
0993: *
0994: * <li><code>GL_SPOT_CUTOFF</code></li>
0995: *
0996: * <p> <code>params</code> returns a single value that specifies the
0997: * maximum spread angle of a light source. Fixed-point and
0998: * floating-point values are mapped directly. Only values in the
0999: * range <code>[0, 90]</code> and the special value 180 are
1000: * accepted. If the angle between the direction of the light and the
1001: * direction from the light to the vertex being lighted is greater
1002: * than the spot cutoff angle, the light is completely
1003: * masked. Otherwise, its intensity is controlled by the spot
1004: * exponent and the attenuation factors. The initial spot cutoff is
1005: * 180.
1006: *
1007: * <li><code>GL_CONSTANT_ATTENUATION</code>,
1008: * <code>GL_LINEAR_ATTENUATION</code>,
1009: * <code>GL_QUADRATIC_ATTENUATION</code></li>
1010: *
1011: * <p> <code>params</code> returns a single value
1012: * that specifies one of the three light attenuation
1013: * factors. Fixed-point and floating-point values are mapped
1014: * directly. Only nonnegative values are accepted. If the light is
1015: * positional, rather than directional, its intensity is attenuated
1016: * by the reciprocal of the sum of the constant factor, the linear
1017: * factor times the distance between the light and the vertex being
1018: * lighted, and the quadratic factor times the square of the same
1019: * distance. The initial attenuation factors are (1, 0, 0).
1020: *
1021: * </ul>
1022: *
1023: * <h4>Notes</h4>
1024: *
1025: * <p>It is always the case that <code>GL_LIGHT</code><i>i</i> =
1026: * <code>GL_LIGHT0</code> + <i>i</i>.
1027: *
1028: * <p>If an error is generated, no change is made to the contents of
1029: * params.
1030: *
1031: * <h4>Errors</h4>
1032: *
1033: * <p><code>GL_INVALID_ENUM</code> is generated if light or
1034: * <code>pname</code> is not an accepted value.
1035: *
1036: * @param light Specifies a light source. The number of possible
1037: * lights depends on the implementation, but at least eight lights
1038: * are supported. They are identified by symbolic names of the form
1039: * <code>GL_LIGHT</code><i>i</i> where <code>0 < <i>i</i> <
1040: * GL_MAX_LIGHTS</code>.
1041: * @param pname Specifies a light source parameter for
1042: * light. Accepted symbolic names are <code>GL_AMBIENT</code>,
1043: * <code>GL_DIFFUSE</code>, <code>GL_SPECULAR</code>,
1044: * <code>GL_EMISSION</code>, <code>GL_SPOT_DIRECTION</code>,
1045: * <code>GL_SPOT_EXPONENT</code>, <code>GL_SPOT_CUTOFF</code>,
1046: * <code>GL_CONSTANT_ATTENUATION</code>,
1047: * <code>GL_LINEAR_ATTENUATION</code>, and
1048: * <code>GL_QUADRATIC_ATTENUATION</code>.
1049: * @param params returns the requested data.
1050: * @param offset the starting offset within the
1051: * <code>params</code> array.
1052: *
1053: * @exception IllegalArgumentException if <code>params</code> is
1054: * <code>null</code>.
1055: * @exception IllegalArgumentException if <code>offset</code> is
1056: * less than 0.
1057: * @exception IllegalArgumentException if <code>params.length -
1058: * offset</code> is smaller than the number of values required by
1059: * the parameter.
1060: */
1061: void glGetLightfv(int light, int pname, float[] params, int offset);
1062:
1063: /**
1064: * Floating-point <code>Buffer</code> version of
1065: * <code>glGetLight</code>.
1066: *
1067: * @see #glGetLightfv(int light, int pname, float[] params, int offset)
1068: *
1069: * @exception IllegalArgumentException if <code>params</code> is
1070: * <code>null</code>.
1071: * @exception IllegalArgumentException if
1072: * <code>params.remaining()</code> is smaller than the number of
1073: * values required by the parameter.
1074: */
1075: void glGetLightfv(int light, int pname, FloatBuffer params);
1076:
1077: /**
1078: * Fixed-point array version of <code>glGetLight</code>.
1079: *
1080: * @see #glGetLightfv(int light, int pname, float[] params, int offset)
1081: *
1082: * @exception IllegalArgumentException if <code>params</code> is
1083: * <code>null</code>.
1084: * @exception IllegalArgumentException if <code>offset</code> is
1085: * less than 0.
1086: * @exception IllegalArgumentException if <code>params.length -
1087: * offset</code> is smaller than the number of values required by
1088: * the parameter.
1089: */
1090: void glGetLightxv(int light, int pname, int[] params, int offset);
1091:
1092: /**
1093: * Fixed-point <code>Buffer</code> version of
1094: * <code>glGetLight</code>.
1095: *
1096: * @see #glGetLightfv(int light, int pname, float[] params, int offset)
1097: *
1098: * @exception IllegalArgumentException if <code>params</code> is
1099: * <code>null</code>.
1100: * @exception IllegalArgumentException if
1101: * <code>params.remaining()</code> is smaller than the number of
1102: * values required by the parameter.
1103: */
1104: void glGetLightxv(int light, int pname, IntBuffer params);
1105:
1106: /**
1107: * Return material parameters values.
1108: *
1109: * <p><code>glGetMaterial</code> returns in <code>params</code> the
1110: * value or values of parameter <code>pname</code> of material
1111: * <code>face</code>.
1112: *
1113: * <p>Five parameters are defined:
1114: *
1115: * <ul>
1116: *
1117: * <li><code>GL_AMBIENT</code></li>
1118: *
1119: * <p> <code>params</code> returns four values that specify the ambient RGBA
1120: * reflectance of the material. The values are not clamped. The
1121: * initial ambient reflectance is (0.2, 0.2, 0.2, 1.0).
1122: *
1123: * <li><code>GL_DIFFUSE</code></li>
1124: *
1125: * <p> <code>params</code> returns four values that specify the diffuse RGBA
1126: * reflectance of the material. The values are not clamped. The
1127: * initial diffuse reflectance is (0.8, 0.8, 0.8, 1.0).
1128: *
1129: * <li><code>GL_SPECULAR</code></li>
1130: *
1131: * <p> <code>params</code> returns four values that specify the specular RGBA
1132: * reflectance of the material. The values are not clamped. The
1133: * initial specular reflectance is (0, 0, 0, 1).
1134: *
1135: * <li><code>GL_EMISSION</code></li>
1136: *
1137: * <p> <code>params</code> returns four values that specify the RGBA emitted
1138: * light intensity of the material. The values are not clamped. The
1139: * initial emission intensity is (0, 0, 0, 1).
1140: *
1141: * <li><code>GL_SHININESS</code></li>
1142: *
1143: * <p> <code>params</code> returns a single value that specifies the RGBA
1144: * specular exponent of the material. The initial specular exponent
1145: * is 0.
1146: *
1147: * </ul>
1148: *
1149: * <h4>Notes</h4>
1150: *
1151: * <p>If an error is generated, no change is made to the contents of
1152: * <code>params</code>.
1153: *
1154: * <h4>Errors</h4>
1155: *
1156: * <code>GL_INVALID_ENUM</code> is generated if <code>face</code> or
1157: * <code>pname</code> is not an accepted value.
1158: *
1159: * @param face Specifies which of the two materials is being
1160: * queried. <code>GL_FRONT</code> or <code>GL_BACK</code> are
1161: * accepted, representing the front and back materials,
1162: * respectively.
1163: * @param pname Specifies the material parameter to return. Accepted
1164: * symbolic names are <code>GL_AMBIENT</code>,
1165: * <code>GL_DIFFUSE</code>, <code>GL_SPECULAR</code>,
1166: * <code>GL_EMISSION</code>, and <code>GL_SHININESS</code>.
1167: * @param params returns the requested data.
1168: * @param offset the starting offset within the
1169: * <code>params</code> array.
1170: *
1171: * @exception IllegalArgumentException if <code>params</code> is
1172: * <code>null</code>.
1173: * @exception IllegalArgumentException if <code>offset</code> is
1174: * less than 0.
1175: * @exception IllegalArgumentException if <code>params.length -
1176: * offset</code> is smaller than the number of values required by
1177: * the parameter.
1178: */
1179: void glGetMaterialfv(int face, int pname, float[] params, int offset);
1180:
1181: /**
1182: * Floating-point <code>Buffer</code> version of
1183: * <code>glGetMaterial</code>.
1184: *
1185: * @see #glGetMaterialfv(int face, int pname, float[] params, int offset)
1186: *
1187: * @exception IllegalArgumentException if <code>params</code> is
1188: * <code>null</code>.
1189: * @exception IllegalArgumentException if
1190: * <code>params.remaining()</code> is smaller than the number of
1191: * values required by the parameter.
1192: */
1193: void glGetMaterialfv(int face, int pname, FloatBuffer params);
1194:
1195: /**
1196: * Fixed-point array version of
1197: * <code>glGetMaterial</code>.
1198: *
1199: * @see #glGetMaterialfv(int face, int pname, float[] params, int offset)
1200: *
1201: * @exception IllegalArgumentException if <code>params</code> is
1202: * <code>null</code>.
1203: * @exception IllegalArgumentException if <code>offset</code> is
1204: * less than 0.
1205: * @exception IllegalArgumentException if <code>params.length -
1206: * offset</code> is smaller than the number of values required by
1207: * the parameter.
1208: */
1209: void glGetMaterialxv(int face, int pname, int[] params, int offset);
1210:
1211: /**
1212: * Fixed-point <code>Buffer</code> version of
1213: * <code>glGetMaterial</code>.
1214: *
1215: * @see #glGetMaterialfv(int face, int pname, float[] params, int offset)
1216: *
1217: * @exception IllegalArgumentException if <code>params</code> is
1218: * <code>null</code>.
1219: * @exception IllegalArgumentException if
1220: * <code>params.remaining()</code> is smaller than the number of
1221: * values required by the parameter.
1222: */
1223: void glGetMaterialxv(int face, int pname, IntBuffer params);
1224:
1225: /**
1226: * Return the <code>Buffer</code> associated with the specified pointer.
1227: *
1228: * <p> <code>glGetPointer</code> returns pointer information in the
1229: * form of a <code>Buffer</code> reference. <code>pname</code> is a
1230: * symbolic constant indicating the pointer to be returned, and
1231: * <code>params</code> is an array of <code>Buffer</code>s in which
1232: * the returned data will be placed in element 0.
1233: *
1234: * <h4>Notes</h4>
1235: *
1236: * <p>The pointers are all client-side state.
1237: *
1238: * <p>The initial value for each pointer is <code>null</code>.
1239: * <h4>Errors</h4>
1240: *
1241: * <p> <code>GL_INVALID_ENUM</code> is generated if
1242: * <code>pname</code> is not an accepted value.
1243: *
1244: * @param pname Specifies the array or buffer pointer to be
1245: * returned. Accepted symbolic names are
1246: * <code>GL11.GL_COLOR_ARRAY_POINTER</code>,
1247: * <code>GL11.GL_NORMAL_ARRAY_POINTER</code>,
1248: * <code>GL11.GL_TEXTURE_COORD_ARRAY_POINTER</code>,
1249: * <code>GL11.GL_VERTEX_ARRAY_POINTER</code>,
1250: * <code>GL11.GL_POINT_SIZE_ARRAY_POINTER_OES</code>,
1251: * <code>GL11Ext.GL_MATRIX_INDEX_ARRAY_POINTER_OES</code>, and
1252: * <code>GL11Ext.GL_WEIGHT_ARRAY_POINTER_OES</code>.
1253: * @param params a non-<code>null</code> array of <code>Buffer</code>s
1254: * containing at least one element.
1255: *
1256: * @exception IllegalArgumentException if <code>params</code> is
1257: * <code>null</code> or has length less than 1.
1258: */
1259: void glGetPointerv(int pname, Buffer[] params);
1260:
1261: /**
1262: * Return texture environment parameters.
1263: *
1264: * <p><code>glGetTexParameter</code> returns in <code>params</code>
1265: * selected values of a texture environment that was specified with
1266: * <code>glTexEnv</code>. <code>target</code> specifies a texture
1267: * environment. Currently, only one texture environment is defined
1268: * and supported: <code>GL_TEXTURE_ENV</code>.
1269: *
1270: * <p><code>pname</code> names a specific texture environment parameter, as
1271: * follows:
1272: *
1273: * <li><code>GL_TEXTURE_ENV_MODE</code></li>
1274: *
1275: * <p> <code>params</code> returns the single-valued texture
1276: * environment mode, a symbolic constant. The initial value is
1277: * <code>GL_MODULATE</code>.
1278: *
1279: * <li><code>GL_TEXTURE_ENV_COLOR</code></li>
1280: *
1281: * <p> <code>params</code> returns four fixed or floating-point
1282: * values that are the texture environment color. The initial value
1283: * is (0, 0, 0, 0).
1284: *
1285: * <h4>Notes</h4>
1286: *
1287: * <p>If an error is generated, no change is made to the contents of
1288: * <code>params</code>.
1289: *
1290: * <h4>Errors</h4>
1291: *
1292: * <p><code>GL_INVALID_ENUM</code> is generated if
1293: * <code>target</code> or <code>pname</code> is not one of the
1294: * accepted defined values.
1295: *
1296: * @param env Specifies a texture environment, which must be
1297: * <code>GL_TEXTURE_ENV</code>.
1298: * @param pname Specifies the symbolic name of a texture environment
1299: * parameter. <code>pname</code> can be one of the following:
1300: * <code>GL_TEXTURE_ENV_MODE</code>,
1301: * <code>GL_TEXTURE_ENV_COLOR</code>,
1302: * <code>GL_TEXTURE_WRAP_S</code>, <code>GL_TEXTURE_WRAP_T</code>,
1303: * or <code>GL_GENERATE_MIPMAP</code>.
1304: * @param params returns the requested data.
1305: * @param offset the starting offset within the
1306: * <code>params</code> array.
1307: *
1308: * @exception IllegalArgumentException if <code>params</code> is
1309: * <code>null</code>.
1310: * @exception IllegalArgumentException if <code>offset</code> is
1311: * less than 0.
1312: * @exception IllegalArgumentException if <code>params.length -
1313: * offset</code> is smaller than the number of values required by
1314: * the parameter.
1315: */
1316: void glGetTexEnvfv(int env, int pname, float[] params, int offset);
1317:
1318: /**
1319: * Floating-point <code>Buffer</code> version of
1320: * <code>glGetTexEnv</code>.
1321: *
1322: * @see #glGetTexEnvfv(int env, int pname, float[] params, int offset)
1323: *
1324: * @exception IllegalArgumentException if <code>params</code> is
1325: * <code>null</code>.
1326: * @exception IllegalArgumentException if
1327: * <code>params.remaining()</code> is smaller than the number of
1328: * values required by the parameter.
1329: */
1330: void glGetTexEnvfv(int env, int pname, FloatBuffer params);
1331:
1332: /**
1333: * Integer array version of <code>glGetTexEnv</code>.
1334: *
1335: * @see #glGetTexEnvfv(int env, int pname, float[] params, int offset)
1336: *
1337: * @exception IllegalArgumentException if <code>params</code> is
1338: * <code>null</code>.
1339: * @exception IllegalArgumentException if <code>offset</code> is
1340: * less than 0.
1341: * @exception IllegalArgumentException if <code>params.length -
1342: * offset</code> is smaller than the number of values required by
1343: * the parameter.
1344: */
1345: void glGetTexEnviv(int env, int pname, int[] params, int offset);
1346:
1347: /**
1348: * Integer <code>Buffer</code> version of
1349: * <code>glGetTExEnv</code>.
1350: *
1351: * @see #glGetTexEnvfv(int env, int pname, float[] params, int offset)
1352: *
1353: * @exception IllegalArgumentException if <code>params</code> is
1354: * <code>null</code>.
1355: * @exception IllegalArgumentException if
1356: * <code>params.remaining()</code> is smaller than the number of
1357: * values required by the parameter.
1358: */
1359: void glGetTexEnviv(int env, int pname, IntBuffer params);
1360:
1361: /**
1362: * Fixed-point version of <code>glGetTexEnv</code>.
1363: *
1364: * @see #glGetTexEnvfv(int env, int pname, float[] params, int offset)
1365: *
1366: * @exception IllegalArgumentException if <code>params</code> is
1367: * <code>null</code>.
1368: * @exception IllegalArgumentException if <code>offset</code> is
1369: * less than 0.
1370: * @exception IllegalArgumentException if <code>params.length -
1371: * offset</code> is smaller than the number of values required by
1372: * the parameter.
1373: */
1374: void glGetTexEnvxv(int env, int pname, int[] params, int offset);
1375:
1376: /**
1377: * Fixed-point <code>Buffer</code> version of
1378: * <code>glGetTexEnv</code>.
1379: *
1380: * @see #glGetTexEnvfv(int env, int pname, float[] params, int offset)
1381: *
1382: * @exception IllegalArgumentException if <code>params</code> is
1383: * <code>null</code>.
1384: * @exception IllegalArgumentException if
1385: * <code>params.remaining()</code> is smaller than the number of
1386: * values required by the parameter.
1387: */
1388: void glGetTexEnvxv(int env, int pname, IntBuffer params);
1389:
1390: /**
1391: * Return texture parameter values.
1392: *
1393: * <p><code>glGetTexParameter</code> returns in <code>params</code>
1394: * the value or values of the texture parameter specified as
1395: * <code>pname</code>. <code>target</code> defines the target
1396: * texture, which must be <code>GL_TEXTURE_2D</code> which specifies
1397: * two-dimensional texturing. <code>pname</code> accepts the same
1398: * symbols as <code>glTexParameter</code>, with the same
1399: * interpretations:
1400: *
1401: * <ul>
1402: *
1403: * <li><code>GL_TEXTURE_MIN_FILTER</code></li>
1404: *
1405: * <p> Returns the texture minifying function. Which can one of the
1406: * following: <code>GL_NEAREST</code>, <code>GL_LINEAR</code>,
1407: * <code>GL_NEAREST_MIPMAP_NEAREST</code>,
1408: * <code>GL_LINEAR_MIPMAP_NEAREST</code>,
1409: * <code>GL_NEAREST_MIPMAP_LINEAR</code>, or
1410: * <code>GL_LINEAR_MIPMAP_LINEAR</code>. The initial value is
1411: * <code>GL_NEAREST_MIPMAP_LINEAR</code>.
1412: *
1413: * <li><code>GL_TEXTURE_MAG_FILTER</code></li>
1414: *
1415: * <p> Returns the texture magnification function. Which can be
1416: * either <code>GL_NEAREST</code> or <code>GL_LINEAR</code>. The
1417: * initial value is <code>GL_LINEAR</code>.
1418: *
1419: * <li><code>GL_TEXTURE_WRAP_S</code></li>
1420: *
1421: * <p> Returns the wrap parameter for texture coordinate s. Which
1422: * can be either: <code>GL_CLAMP</code>,
1423: * <code>GL_CLAMP_TO_EDGE</code>, or <code>GL_REPEAT</code>. The
1424: * initial value is <code>GL_REPEAT</code>.
1425: *
1426: * <li><code>GL_TEXTURE_WRAP_T</code></li>
1427: *
1428: * <p> Returns the wrap parameter for texture coordinate t. Which
1429: * can be either: <code>GL_CLAMP</code>,
1430: * <code>GL_CLAMP_TO_EDGE</code>, or <code>GL_REPEAT</code>. The
1431: * initial value is <code>GL_REPEAT</code>.
1432: *
1433: * <li><code>GL_GENERATE_MIPMAP</code></li>
1434: *
1435: * <p> Returns the automatic mipmap generation parameter. The
1436: * initial value is <code>GL_FALSE</code>.
1437: *
1438: * </ul>
1439: *
1440: * <h4>Notes</h4>
1441: *
1442: * <p>If an error is generated, no change is made to the contents of params.
1443: *
1444: * <h4>Errors</h4>
1445: *
1446: * <p><code>GL_INVALID_ENUM</code> is generated if
1447: * <code>target</code> or <code>pname</code> is not one of the
1448: * accepted defined values.
1449: *
1450: * @param target Specifies the target texture, which must be
1451: * <code>GL_TEXTURE_2D</code>.
1452: * @param pname Specifies the symbolic name of a texture
1453: * parameter. <code>pname</code> can be one of the following:
1454: * <code>GL_TEXTURE_MIN_FILTER</code>,
1455: * <code>GL_TEXTURE_MAG_FILTER</code>,
1456: * <code>GL_TEXTURE_WRAP_S</code>, <code>GL_TEXTURE_WRAP_T</code>,
1457: * or <code>GL_GENERATE_MIPMAP</code>.
1458: * @param params returns the texture parameters.
1459: * @param offset the starting offset within the
1460: * <code>params</code> array.
1461: *
1462: * @exception IllegalArgumentException if <code>params</code> is
1463: * <code>null</code>.
1464: * @exception IllegalArgumentException if <code>offset</code> is
1465: * less than 0.
1466: * @exception IllegalArgumentException if <code>params.length -
1467: * offset</code> is smaller than the number of values required by
1468: * the parameter.
1469: */
1470: void glGetTexParameterfv(int target, int pname, float[] params,
1471: int offset);
1472:
1473: /**
1474: * Floating-point <code>Buffer</code> version of
1475: * <code>glGetTexParameter</code>.
1476: *
1477: * @see #glGetTexParameterfv(int target, int pname, float[] params, int offset)
1478: *
1479: * @exception IllegalArgumentException if <code>params</code> is
1480: * <code>null</code>.
1481: * @exception IllegalArgumentException if
1482: * <code>params.remaining()</code> is smaller than the number of
1483: * values required by the parameter.
1484: */
1485: void glGetTexParameterfv(int target, int pname, FloatBuffer params);
1486:
1487: /**
1488: * Integer array version of
1489: * <code>glGetTexParameter</code>.
1490: *
1491: * @see #glGetTexParameterfv(int target, int pname, float[] params, int offset)
1492: *
1493: * @exception IllegalArgumentException if <code>params</code> is
1494: * <code>null</code>.
1495: * @exception IllegalArgumentException if <code>offset</code> is
1496: * less than 0.
1497: * @exception IllegalArgumentException if <code>params.length -
1498: * offset</code> is smaller than the number of values required by
1499: * the parameter.
1500: */
1501: void glGetTexParameteriv(int target, int pname, int[] params,
1502: int offset);
1503:
1504: /**
1505: * Integer <code>Buffer</code> version of
1506: * <code>glGetTexParameter</code>.
1507: *
1508: * @see #glGetTexParameterfv(int target, int pname, float[] params, int offset)
1509: *
1510: * @exception IllegalArgumentException if <code>params</code> is
1511: * <code>null</code>.
1512: * @exception IllegalArgumentException if
1513: * <code>params.remaining()</code> is smaller than the number of
1514: * values required by the parameter.
1515: */
1516: void glGetTexParameteriv(int target, int pname, IntBuffer params);
1517:
1518: /**
1519: * Fixed-point array version of
1520: * <code>glGetTexParameter</code>.
1521: *
1522: * @see #glGetTexParameterfv(int target, int pname, float[] params, int offset)
1523: *
1524: * @exception IllegalArgumentException if <code>params</code> is
1525: * <code>null</code>.
1526: * @exception IllegalArgumentException if <code>offset</code> is
1527: * less than 0.
1528: * @exception IllegalArgumentException if <code>params.length -
1529: * offset</code> is smaller than the number of values required by
1530: * the parameter.
1531: */
1532: void glGetTexParameterxv(int target, int pname, int[] params,
1533: int offset);
1534:
1535: /**
1536: * Fixed-point <code>Buffer</code> version of
1537: * <code>glGetTexParameter</code>.
1538: *
1539: * @see #glGetTexParameterfv(int target, int pname, float[] params, int offset)
1540: *
1541: * @exception IllegalArgumentException if <code>params</code> is
1542: * <code>null</code>.
1543: * @exception IllegalArgumentException if
1544: * <code>params.remaining()</code> is smaller than the number of
1545: * values required by the parameter.
1546: */
1547: void glGetTexParameterxv(int target, int pname, IntBuffer params);
1548:
1549: /**
1550: * Determine if a name corresponds to a buffer object.
1551: *
1552: * <p><code>glIsBuffer</code> returns <code>true</code> if
1553: * <code>buffer</code> is currently the name of a buffer object. If
1554: * buffer is zero, or is a non-zero value that is not currently the
1555: * name of a buffer object, <code>glIsBuffer</code> returns
1556: * <code>false</code>.
1557: *
1558: * @param buffer Specifies a value that may be the name of a buffer object.
1559: *
1560: * @return <code>true</code> if <code>buffer</code> is the name of a
1561: * buffer object.
1562: */
1563: boolean glIsBuffer(int buffer);
1564:
1565: /**
1566: * Test whether a capability is enabled.
1567: *
1568: * <p><code>glIsEnabled</code> returns <code>true</code> if
1569: * <code>cap</code> is an enabled capability and returns
1570: * <code>false</code> otherwise.
1571: *
1572: * <p>The following capabilities are accepted for cap:
1573: *
1574: * <pre>
1575: * Constant See function:
1576: *
1577: * GL_ALPHA_TEST glAlphaFunc
1578: * GL_ARRAY_BUFFER_BINDING glBindBuffer
1579: * GL_BLEND glBlendFunc, glLogicOp
1580: * GL_CLIP_PLANE glClipPlane
1581: * GL_COLOR_ARRAY glColorPointer
1582: * GL_COLOR_LOGIC_OP glLogicOp
1583: * GL_COLOR_MATERIAL glColorMaterial
1584: * GL_CULL_FACE glCullFace
1585: * GL_DEPTH_TEST glDepthFunc, glDepthRange
1586: * GL_DITHER glEnable
1587: * GL_FOG glFog
1588: * GL_LIGHT glLight, glLightModel
1589: * GL_LIGHTING glLight, glLightModel, glMaterial
1590: * GL_LINE_SMOOTH glLineWidth
1591: * GL_MATRIX_PALETTE_OES glMatrixMode
1592: * GL_MATRIX_INDEX_ARRAY_OES glEnableClientState
1593: * GL_MULTISAMPLE glEnable
1594: * GL_NORMAL_ARRAY glNormalPointer
1595: * GL_NORMALIZE glNormal
1596: * GL_POINT_SIZE_ARRAY_OES glEnableClientState
1597: * GL_POINT_SMOOTH glPointSize
1598: * GL_POINT_SPRITE_OES glEnable, glTexEnv
1599: * GL_POLYGON_OFFSET_FILL glPolygonOffset
1600: * GL_RESCALE_NORMAL glEnable
1601: * GL_SAMPLE_ALPHA_TO_COVERAGE glEnable
1602: * GL_SAMPLE_ALPHA_TO_ONE glEnable
1603: * GL_SAMPLE_COVERAGE glEnable
1604: * GL_SCISSOR_TEST glScissor
1605: * GL_STENCIL_TEST glStencilFunc, glStencilOp
1606: * GL_TEXTURE_2D glTexImage2D
1607: * GL_TEXTURE_COORD_ARRAY glTexCoordPointer
1608: * GL_WEIGHT_ARRAY_OES glEnableClientState
1609: * GL_VERTEX_ARRAY glVertexPointer
1610: * </pre>
1611: *
1612: * <h4>Notes</h4>
1613: *
1614: * <p>If an error is generated, <code>glIsEnabled</code> returns 0.
1615: *
1616: * <h4>Errors</h4>
1617: *
1618: * <p><code>GL_INVALID_ENUM</code> is generated if <code>cap</code>
1619: * is not an accepted value.
1620: *
1621: * @param cap Specifies a symbolic constant indicating a GL capability.
1622: *
1623: * @return <code>true</code> if the given capability is enabled.
1624: */
1625: boolean glIsEnabled(int cap);
1626:
1627: /**
1628: * Determine if a name corresponds to a texture.
1629: *
1630: * <p><code>glIsTexture</code> returns <code>true</code> if
1631: * <code>texture</code> is currently the name of a texture. If
1632: * <code>texture</code> is zero, or is a non-zero value that is not
1633: * currently the name of a texture, or if an error occurs,
1634: * glIsTexture returns <code>false</code>.
1635: *
1636: * @param texture Specifies a value that may be the name of a texture.
1637: *
1638: * @return <code>true</code> if <code>texture</code> is the name of a
1639: * texture object.
1640: */
1641: boolean glIsTexture(int texture);
1642:
1643: // Points
1644:
1645: /**
1646: * Specify parameters for point rasterization.
1647: *
1648: * <p><code>glPointParameter</code> assigns values to point parameters.
1649: *
1650: * <p><code>glPointParameter</code> takes two
1651: * arguments. <code>pname</code> specifies which of several
1652: * parameters will be modified. <code>param</code> specifies what
1653: * value will be assigned to the specified parameter.
1654: *
1655: * <p>The parameters that can be specified using
1656: * <code>glPointParameter</code>, and their interpretations are as
1657: * follows:
1658: *
1659: * <ul>
1660: *
1661: * <li><code>GL_POINT_SIZE_MIN</code></li>
1662: *
1663: * <p> <code>param</code> specifies the lower bound to which the
1664: * derived point size is clamped.
1665: *
1666: * <li><code>GL_POINT_SIZE_MAX</code></li>
1667: *
1668: * <p> <code>param</code> specifies the upper bound to which the
1669: * derived point size is clamped.
1670: *
1671: * <li><code>GL_POINT_FADE_THRESHOLD_SIZE</code></li>
1672: *
1673: * <p> <code>param</code> specifies to the point fade threshold.
1674: *
1675: * </ul>
1676: *
1677: * <h4>Notes</h4>
1678: *
1679: * <p>If the point size lower bound is greater than the upper bound, then
1680: * the point size after clamping is undefined.
1681: *
1682: * <h4>Errors</h4>
1683: *
1684: * <p><code>GL_INVALID_ENUM</code> is generated if
1685: * <code>pname</code> is not an accepted value.
1686: * <p><code>GL_INVALID_VALUE</code> is generated if assigned values
1687: * for <p><code>GL_POINT_SIZE_MIN</code>,
1688: * <code>GL_POINT_SIZE_MAX</code>, or
1689: * <code>GL_POINT_FADE_THRESHOLD_SIZE</code> are less then zero.
1690: *
1691: * @param pname Specifies the single-valued parameter to be
1692: * updated. Can be either <code>GL_POINT_SIZE_MIN</code>,
1693: * <code>GL_POINT_SIZE_MAX</code>, or
1694: * <code>GL_POINT_FADE_THRESHOLD_SIZE</code>.
1695: * @param param Specifies the value that the parameter will be set
1696: * to.
1697: */
1698: void glPointParameterf(int pname, float param);
1699:
1700: /**
1701: * Fixed-point version of <code>glPointParameter</code>.
1702: *
1703: * @see #glPointParameterf(int pname, float param)
1704: */
1705: void glPointParameterx(int pname, int param);
1706:
1707: /**
1708: * Specify parameters for point rasterization (array
1709: * version).
1710: *
1711: * <p><code>glPointParameter</code> assigns values to point parameters.
1712: *
1713: * <p><code>glPointParameter</code> takes two
1714: * arguments. <code>pname</code> specifies which of several
1715: * parameters will be modified. <code>params</code> specifies what
1716: * values will be assigned to the specified parameter.
1717: *
1718: * <p>The parameters that can be specified using
1719: * <code>glPointParameter</code>, and their interpretations are as
1720: * follows:
1721: *
1722: * <ul>
1723: *
1724: * <li><code>GL_POINT_SIZE_MIN</code></li>
1725: *
1726: * <p> <code>params</code> contains the lower bound to which the
1727: * derived point size is clamped.
1728: *
1729: * <li><code>GL_POINT_SIZE_MAX</code></li>
1730: *
1731: * <p> <code>params</code> contains the upper bound to which the
1732: * derived point size is clamped.
1733: *
1734: * <li><code>GL_POINT_FADE_THRESHOLD_SIZE</code></li>
1735: *
1736: * <p> <code>params</code> contains the point fade
1737: * threshold.
1738: *
1739: * <li><code>GL_POINT_DISTANCE_ATTENUATION</code></li>
1740: *
1741: * <p> <code>params</code> contains the distance attenuation
1742: * function coefficients a, b, and c.
1743: *
1744: * </ul>
1745: *
1746: * <h4>Notes</h4>
1747: *
1748: * <p>If the point size lower bound is greater than the upper bound,
1749: * then the point size after clamping is undefined.
1750: *
1751: * <h4>Errors</h4>
1752: *
1753: * <p><code>GL_INVALID_ENUM</code> is generated if
1754: * <code>pname</code> is not an accepted value.
1755: * <p><code>GL_INVALID_VALUE</code> is generated if assigned values
1756: * for <p><code>GL_POINT_SIZE_MIN</code>,
1757: * <code>GL_POINT_SIZE_MAX</code>, or
1758: * <code>GL_POINT_FADE_THRESHOLD_SIZE</code> are less then zero.
1759: *
1760: * @param pname Specifies the parameter to be updated. Can be either
1761: * <code>GL_POINT_SIZE_MIN</code>, <code>GL_POINT_SIZE_MAX</code>,
1762: * <code>GL_POINT_FADE_THRESHOLD_SIZE</code>, or
1763: * <code>GL_POINT_DISTANCE_ATTENUATION</code>.
1764: * @param params Specifies an array of values that
1765: * <code>pname</code> will be set to.
1766: *
1767: * @exception IllegalArgumentException if <code>params</code> is
1768: * <code>null</code>.
1769: * @exception IllegalArgumentException if <code>offset</code> is
1770: * less than 0.
1771: * @exception IllegalArgumentException if <code>params.length -
1772: * offset</code> is smaller than the number of values required by
1773: * the parameter.
1774: */
1775: void glPointParameterfv(int pname, float[] params, int offset);
1776:
1777: /**
1778: * Floating-point <code>Buffer</code> version of
1779: * <code>glPointParameter</code>.
1780: *
1781: * @see #glPointParameterfv(int pname, float[] params, int offset)
1782: *
1783: * @exception IllegalArgumentException if <code>params</code> is
1784: * <code>null</code>.
1785: * @exception IllegalArgumentException if
1786: * <code>params.remaining()</code> is smaller than the number of
1787: * values required by the parameter.
1788: */
1789: void glPointParameterfv(int pname, FloatBuffer params);
1790:
1791: /**
1792: * Fixed-point array version of
1793: * <code>glPointParameter</code>.
1794: *
1795: * @see #glPointParameterfv(int pname, float[] params, int offset)
1796: *
1797: * @exception IllegalArgumentException if <code>params</code> is
1798: * <code>null</code>.
1799: * @exception IllegalArgumentException if <code>offset</code> is
1800: * less than 0.
1801: * @exception IllegalArgumentException if <code>params.length -
1802: * offset</code> is smaller than the number of values required by
1803: * the parameter.
1804: */
1805: void glPointParameterxv(int pname, int[] params, int offset);
1806:
1807: /**
1808: * Fixed-point <code>Buffer</code> version of
1809: * <code>glPointParameterfv</code>.
1810: *
1811: * @see #glPointParameterfv(int pname, float[] params, int offset)
1812: *
1813: * @exception IllegalArgumentException if <code>params</code> is
1814: * <code>null</code>.
1815: * @exception IllegalArgumentException if
1816: * <code>params.remaining()</code> is smaller than the number of
1817: * values required by the parameter.
1818: */
1819: void glPointParameterxv(int pname, IntBuffer params);
1820:
1821: // Color
1822:
1823: /**
1824: * Byte version of <code>glColor</code>. The bytes are
1825: * interpreted as unsigned values by bitwise ANDing them with the
1826: * value <code>0xff</code>.
1827: *
1828: * @see #glColor4f(float red, float green, float blue, float alpha)
1829: */
1830: void glColor4ub(byte red, byte green, byte blue, byte alpha);
1831:
1832: // Textures
1833:
1834: /**
1835: * Integer version of <code>glTexEnv</code>.
1836: *
1837: * @see #glTexEnvf(int target, int pname, float param)
1838: */
1839: void glTexEnvi(int target, int pname, int param);
1840:
1841: /**
1842: * Integer array version of <code>glTexEnv</code>.
1843: *
1844: * @see #glTexEnvfv(int target, int pname, float[] params, int offset)
1845: *
1846: * @exception IllegalArgumentException if <code>params</code> is
1847: * <code>null</code>.
1848: * @exception IllegalArgumentException if <code>offset</code> is
1849: * less than 0.
1850: * @exception IllegalArgumentException if <code>params.length -
1851: * offset</code> is smaller than the number of values required by
1852: * the parameter.
1853: */
1854: void glTexEnviv(int target, int pname, int[] params, int offset);
1855:
1856: /**
1857: * Integer <code>Buffer</code> version of
1858: * <code>glTexEnvfv</code>.
1859: *
1860: * @see #glTexEnvfv(int target, int pname, float[] params, int offset)
1861: *
1862: * @exception IllegalArgumentException if <code>params</code> is
1863: * <code>null</code>.
1864: * @exception IllegalArgumentException if
1865: * <code>params.remaining()</code> is smaller than the number of
1866: * values required by the parameter.
1867: */
1868: void glTexEnviv(int target, int pname, IntBuffer params);
1869:
1870: /**
1871: * Floating-point array version of
1872: * <code>glTexParameter</code>.
1873: *
1874: * @see #glTexParameterf(int target, int pname, float param)
1875: *
1876: * @exception IllegalArgumentException if <code>params</code> is
1877: * <code>null</code>.
1878: * @exception IllegalArgumentException if <code>offset</code> is
1879: * less than 0.
1880: * @exception IllegalArgumentException if <code>params.length -
1881: * offset</code> is smaller than the number of values required by
1882: * the parameter.
1883: */
1884: void glTexParameterfv(int target, int pname, float[] params,
1885: int offset);
1886:
1887: /**
1888: * Floating-point <code>Buffer</code> version of
1889: * <code>glTexParameter</code>.
1890: *
1891: * @see #glTexParameterf(int target, int pname, float param)
1892: *
1893: * @exception IllegalArgumentException if <code>params</code> is
1894: * <code>null</code>.
1895: * @exception IllegalArgumentException if
1896: * <code>params.remaining()</code> is smaller than the number of
1897: * values required by the parameter.
1898: */
1899: void glTexParameterfv(int target, int pname, FloatBuffer params);
1900:
1901: /**
1902: * Integer version of <code>glTexParameter</code>.
1903: *
1904: * @see #glTexParameterf(int target, int pname, float param)
1905: */
1906: void glTexParameteri(int target, int pname, int param);
1907:
1908: /**
1909: * Integer array version of <code>glTexParameter</code>.
1910: *
1911: * @see #glTexParameterf(int target, int pname, float param)
1912: *
1913: * @exception IllegalArgumentException if <code>params</code> is
1914: * <code>null</code>.
1915: * @exception IllegalArgumentException if <code>offset</code> is
1916: * less than 0.
1917: * @exception IllegalArgumentException if <code>params.length -
1918: * offset</code> is smaller than the number of values required by
1919: * the parameter.
1920: */
1921: void glTexParameteriv(int target, int pname, int[] params,
1922: int offset);
1923:
1924: /**
1925: * Integer <code>Buffer</code> version of
1926: * <code>glTexParameter</code>.
1927: *
1928: * @see #glTexParameterf(int target, int pname, float param)
1929: *
1930: * @exception IllegalArgumentException if <code>params</code> is
1931: * <code>null</code>.
1932: * @exception IllegalArgumentException if
1933: * <code>params.remaining()</code> is smaller than the number of
1934: * values required by the parameter.
1935: */
1936: void glTexParameteriv(int target, int pname, IntBuffer params);
1937:
1938: /**
1939: * Fixed-point array version of
1940: * <code>glTexParameter</code>.
1941: *
1942: * @see #glTexParameterf(int target, int pname, float param)
1943: *
1944: * @exception IllegalArgumentException if <code>params</code> is
1945: * <code>null</code>.
1946: * @exception IllegalArgumentException if <code>offset</code> is
1947: * less than 0.
1948: * @exception IllegalArgumentException if <code>params.length -
1949: * offset</code> is smaller than the number of values required by
1950: * the parameter.
1951: */
1952: void glTexParameterxv(int target, int pname, int[] params,
1953: int offset);
1954:
1955: /**
1956: * Fixed-point <code>Buffer</code> version of
1957: * <code>glTexParameter</code>.
1958: *
1959: * @see #glTexParameterf(int target, int pname, float param)
1960: *
1961: * @exception IllegalArgumentException if <code>params</code> is
1962: * <code>null</code>.
1963: * @exception IllegalArgumentException if
1964: * <code>params.remaining()</code> is smaller than the number of
1965: * values required by the parameter.
1966: */
1967: void glTexParameterxv(int target, int pname, IntBuffer params);
1968:
1969: /**
1970: * VBO version of <code>glColorPointer</code>.
1971: *
1972: * @see #glBindBuffer
1973: * @see #glColorPointer(int size, int type, int stride, Buffer pointer)
1974: *
1975: * @exception IllegalStateException if VBOs are not enabled.
1976: * @exception ArrayIndexOutOfBoundsException if <code>offset</code>
1977: * is less than 0 or greater than or equal to the length of the
1978: * currently bound buffer.
1979: */
1980: void glColorPointer(int size, int type, int stride, int offset);
1981:
1982: /**
1983: * VBO version of <code>glNormalPointer</code>.
1984: *
1985: * @see #glBindBuffer
1986: * @see #glNormalPointer(int type, int stride, Buffer pointer)
1987: *
1988: * @exception IllegalStateException if VBOs are not enabled.
1989: * @exception ArrayIndexOutOfBoundsException if <code>offset</code>
1990: * is less than 0 or greater than or equal to the length of the
1991: * currently bound buffer.
1992: */
1993: void glNormalPointer(int type, int stride, int offset);
1994:
1995: /**
1996: * VBO version of <code>glTexCoordPointer</code>.
1997: *
1998: * @see #glBindBuffer
1999: * @see #glTexCoordPointer(int size, int type, int stride, Buffer pointer)
2000: *
2001: * @exception IllegalStateException if VBOs are not enabled.
2002: * @exception ArrayIndexOutOfBoundsException if <code>offset</code>
2003: * is less than 0 or greater than or equal to the length of the
2004: * currently bound buffer.
2005: */
2006: void glTexCoordPointer(int size, int type, int stride, int offset);
2007:
2008: /**
2009: * VBO version of <code>glVertexPointer</code>.
2010: *
2011: * @see #glBindBuffer
2012: * @see #glVertexPointer(int size, int type, int stride, Buffer pointer)
2013: *
2014: * @exception IllegalStateException if VBOs are not enabled.
2015: * @exception ArrayIndexOutOfBoundsException if <code>offset</code>
2016: * is less than 0 or greater than or equal to the length of the
2017: * currently bound buffer.
2018: */
2019: void glVertexPointer(int size, int type, int stride, int offset);
2020:
2021: /**
2022: * VBO version of <code>glDrawElements</code>.
2023: *
2024: * @see #glBindBuffer
2025: * @see #glDrawElements(int mode, int count, int type, Buffer indices)
2026: *
2027: * @exception IllegalStateException if the most recent call to
2028: * <code>glBindBuffer</code> for the
2029: * <code>GL_ELEMENT_ARRAY_BUFFER</code> target had a
2030: * <code>buffer</code> parameter of 0 (i.e., an index buffer is not
2031: * bound).
2032: * @exception ArrayIndexOutOfBoundsException if any index in the
2033: * sequence of indices from <code>offset</code> to <code>offset +
2034: * count - 1</code> would result in a reference to an entry outside
2035: * of the currently bound index or data (vertex, color, normal,
2036: * texture coordinate array, weight, matrix index, or point size)
2037: * array, where <code>indices</code> refers to the set of values
2038: * bound to the <code>GL_ELEMENT_ARRAY_BUFFER</code> target.
2039: */
2040: void glDrawElements(int mode, int count, int type, int offset);
2041:
2042: /// End 1.1
2043:
2044: /// Begin 1.1 core extensions
2045:
2046: /**
2047: * Constant for use with <code>glGet</code>
2048: * (<code>OES_matrix_get</code> extension).
2049: */
2050: int GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898D;
2051:
2052: /**
2053: * Constant for use with <code>glGet</code>
2054: * (<code>OES_matrix_get</code> extension).
2055: */
2056: int GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898E;
2057:
2058: /**
2059: * Constant for use with <code>glGet</code>
2060: * (<code>OES_matrix_get</code> extension).
2061: */
2062: int GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898F;
2063:
2064: // OES_point_sprite extension (required profile extension in 1.1)
2065:
2066: /**
2067: * Constant for use with <code>glTexEnv</code> and
2068: * <code>glEnable</code> (<code>OES_point_sprite</code>
2069: * extension).
2070: */
2071: int GL_POINT_SPRITE_OES = 0x8861;
2072:
2073: /**
2074: * Constant for use with <code>glTexEnv</code>
2075: * (<code>OES_point_sprite</code> extension).
2076: */
2077: int GL_COORD_REPLACE_OES = 0x8862;
2078:
2079: // OES_point_size_array extension (required profile extension in 1.1)
2080:
2081: /**
2082: * Constant for use with <code>glEnableClientState</code> and
2083: * <code>glDisableClientState</code>
2084: * (<code>OES_point_size_array</code> extension).
2085: */
2086: int GL_POINT_SIZE_ARRAY_OES = 0x8B9C;
2087:
2088: /**
2089: * Constant for use with <code>glGet</code>
2090: * (<code>OES_point_size_array</code> extension).
2091: */
2092: int GL_POINT_SIZE_ARRAY_TYPE_OES = 0x898A;
2093:
2094: /**
2095: * Constant for use with <code>glGet</code>
2096: * (<code>OES_point_size_array</code> extension).
2097: */
2098: int GL_POINT_SIZE_ARRAY_STRIDE_OES = 0x898B;
2099:
2100: /**
2101: * Constant for use with <code>glGetPointer</code>
2102: * (<code>OES_point_size_array</code> extension).
2103: */
2104: int GL_POINT_SIZE_ARRAY_POINTER_OES = 0x898C;
2105:
2106: /**
2107: * Constant for use with <code>glGet</code>
2108: * (<code>OES_point_size_array</code> extension).
2109: */
2110: int GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES = 0x8B9F;
2111:
2112: /**
2113: * (<code>OES_point_size_array</code> extension) Define an array of
2114: * point sizes.
2115: *
2116: * <p><code>glPointSizePointer</code> specifies the location and
2117: * data of an array of point sizes to use when rendering
2118: * points. <code>type</code> is the data type of the
2119: * coordinates. <code>stride</code> specifies the byte stride from
2120: * one point size to the next, allowing vertices and attributes to
2121: * be packed into a single array or stored in separate
2122: * arrays. (Single-array storage may be more efficient on some
2123: * implementations.)
2124: *
2125: * <p>The point sizes supplied in the point size arrays will be the
2126: * sizes used to render both points and point sprites.
2127: *
2128: * <p>Distance-based attenuation works in conjunction with
2129: * <code>GL_POINT_SIZE_ARRAY_OES</code>. If distance-based
2130: * attenuation is enabled the point size from the point size array
2131: * will be attenuated as defined by <code>glPointParameter</code>,
2132: * to compute the final point size.
2133: *
2134: * <p>When a point size array is specified, <code>type</code>,
2135: * <code>stride</code>, and <code>pointer</code> are saved as
2136: * client-side state.
2137: *
2138: * <p>If the point size array is enabled, it is used to control the
2139: * sizes used to render points and point sprites. To enable and
2140: * disable the point size array, call
2141: * <code>glEnableClientState</code> and
2142: * <code>glDisableClientState</code> with the argument
2143: * <code>GL_POINT_SIZE_ARRAY_OES</code>. The point size array is
2144: * initially disabled.
2145: *
2146: * <h4>Notes</h4>
2147: *
2148: * <p>If point size array is enabled, the point size defined by
2149: * <code>glPointSize</code> is ignored.
2150: *
2151: * <p><code>glPointSizePointer</code> is typically implemented on
2152: * the client side.
2153: *
2154: * <h4>Errors</h4>
2155: *
2156: * <p><code>GL_INVALID_ENUM</code> is generated if <code>type</code>
2157: * is is not an accepted value.
2158: *
2159: * <p><code>GL_INVALID_VALUE</code> is generated if
2160: * <code>stride</code> is negative.
2161: *
2162: * @param type Specifies the data type of each point size in the
2163: * array. Symbolic constants <code>GL_FIXED</code> and
2164: * <code>GL_FLOAT</code> are accepted. The initial value is
2165: * <code>GL_FLOAT</code>.
2166: * @param stride Specifies the byte offset between consecutive point
2167: * sizes. If <code>stride</code> is 0, the point sizes are
2168: * understood to be tightly packed in the array. The initial value
2169: * is 0.
2170: * @param pointer Specifies a <code>Buffer</code> containing the
2171: * point sizes starting at the first vertex in the array. The
2172: * initial value is 0.
2173: *
2174: * @exception IllegalArgumentException if <code>pointer</code> is
2175: * <code>null</code>.
2176: * @exception IllegalStateException if VBOs are enabled.
2177: */
2178: void glPointSizePointerOES(int type, int stride, Buffer pointer);
2179:
2180: /**
2181: * (<code>OES_point_size_array</code> extension) VBO version of
2182: * <code>glPointSizePointerOES</code>.
2183: *
2184: * @see #glPointSizePointerOES(int type, int stride, Buffer pointer)
2185: *
2186: * @exception IllegalStateException if VBOs are not enabled.
2187: */
2188: void glPointSizePointerOES(int type, int stride, int offset);
2189:
2190: // End 1.1 core extensions
2191:
2192: }
|