Source Code Cross Referenced for GL10.java in  » 6.0-JDK-Modules » j2me » javax » microedition » khronos » opengles » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » 6.0 JDK Modules » j2me » javax.microedition.khronos.opengles 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


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:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.