This class makes it easy and safe to work with direct buffers. It is the recommended way to allocate memory to use with LWJGL.
+ * + *LWJGL requires that all NIO buffers passed to it are direct buffers. Direct buffers essentially wrap an address that points to off-heap memory, i.e. a + * native pointer. This is the only way LWJGL can safely pass data from Java code to native code, and vice-versa, without a performance penalty. It does not + * support on-heap Java arrays (or plain NIO buffers, which wrap them) because arrays may be moved around in memory by the JVM's garbage collector while native + * code is accessing them. In addition, Java arrays have an unspecified layout, i.e. they are not necessarily contiguous in memory.
+ * + *When a direct buffer is passed as an argument to an LWJGL method, no data is copied. Instead, the current buffer position is added to the buffer's memory + * address and the resulting value is passed to native code. The native code interprets that value as a pointer and reads or copies from it as necessary. LWJGL + * will often also use the current buffer limit (via {@link Buffer#remaining()}) to automatically pass length/maxlength arguments. This means that, just like + * other APIs that use NIO buffers, the current {@link Buffer#position()} and {@link Buffer#limit()} at the time of the call is very important. Contrary to + * other APIs, LWJGL never modifies the current position, it will be the same value before and after the call.
+ * + *In addition to the standard NIO buffer classes, LWJGL provides a {@link PointerBuffer} class for storing pointer data in an architecture independent way. + * It is used in bindings for pointer-to-pointers arguments, usually to provide arrays of data (input parameter) or to store returned pointer values (output + * parameter). Also, there's the {@link CLongBuffer} class which is similar to {@code PointerBuffer}, but for C {@code long} data.
+ * + *Using NIO buffers for off-heap memory has some drawbacks:
+ *An alternative API for allocating off-heap memory can be found in the {@link MemoryUtil} class. This has none of the above drawbacks, + * but requires allocated memory to be explictly freed when not used anymore.
+ * + *Allocations done via this class have a guaranteed alignment of 8 bytes. If higher alignment values are required, use the explicit memory management API + * or pad the requested memory with extra bytes and align manually.
+ * + *Java does not support struct value types, so LWJGL requires struct values that are backed by off-heap memory. Each struct type defined in a binding + * has a corresponding class in LWJGL that can be used to access its members. Each struct class also has a {@code Buffer} inner class that can be used to + * access (packed) arrays of struct values. Both struct and struct buffer classes may be backed by direct {@link ByteBuffer}s allocated from this class, but it + * is highly recommended to use explicit memory management for performance.
+ */ +public final class BufferUtils { + + private BufferUtils() {} + + /** + * Allocates a direct native-ordered {@code ByteBuffer} with the specified capacity. + * + * @param capacity the capacity, in bytes + * + * @return a {@code ByteBuffer} + */ + public static ByteBuffer createByteBuffer(int capacity) { + return ByteBuffer.allocateDirect(capacity).order(ByteOrder.nativeOrder()); + } + + static int getAllocationSize(int elements, int elementShift) { + apiCheckAllocation(elements, apiGetBytes(elements, elementShift), 0x7FFF_FFFFL); + return elements << elementShift; + } + + /** + * Allocates a direct native-order {@code ShortBuffer} with the specified number of elements. + * + * @param capacity the capacity, in shorts + * + * @return a {@code ShortBuffer} + */ + public static ShortBuffer createShortBuffer(int capacity) { + return createByteBuffer(getAllocationSize(capacity, 1)).asShortBuffer(); + } + + /** + * Allocates a direct native-order {@code CharBuffer} with the specified number of elements. + * + * @param capacity the capacity, in chars + * + * @return a {@code CharBuffer} + */ + public static CharBuffer createCharBuffer(int capacity) { + return createByteBuffer(getAllocationSize(capacity, 1)).asCharBuffer(); + } + + /** + * Allocates a direct native-order {@code IntBuffer} with the specified number of elements. + * + * @param capacity the capacity, in ints + * + * @return an {@code IntBuffer} + */ + public static IntBuffer createIntBuffer(int capacity) { + return createByteBuffer(getAllocationSize(capacity, 2)).asIntBuffer(); + } + + /** + * Allocates a direct native-order {@code LongBuffer} with the specified number of elements. + * + * @param capacity the capacity, in longs + * + * @return a {@code LongBuffer} + */ + public static LongBuffer createLongBuffer(int capacity) { + return createByteBuffer(getAllocationSize(capacity, 3)).asLongBuffer(); + } + + /** + * Allocates a {@code CLongBuffer} with the specified number of elements. + * + * @param capacity the capacity, in memory addresses + * + * @return a {@code CLongBuffer} + */ + public static CLongBuffer createCLongBuffer(int capacity) { + return CLongBuffer.allocateDirect(capacity); + } + + /** + * Allocates a direct native-order {@code FloatBuffer} with the specified number of elements. + * + * @param capacity the capacity, in floats + * + * @return a FloatBuffer + */ + public static FloatBuffer createFloatBuffer(int capacity) { + return createByteBuffer(getAllocationSize(capacity, 2)).asFloatBuffer(); + } + + /** + * Allocates a direct native-order {@code DoubleBuffer} with the specified number of elements. + * + * @param capacity the capacity, in doubles + * + * @return a {@code DoubleBuffer} + */ + public static DoubleBuffer createDoubleBuffer(int capacity) { + return createByteBuffer(getAllocationSize(capacity, 3)).asDoubleBuffer(); + } + + /** + * Allocates a {@code PointerBuffer} with the specified number of elements. + * + * @param capacity the capacity, in memory addresses + * + * @return a {@code PointerBuffer} + */ + public static PointerBuffer createPointerBuffer(int capacity) { + return PointerBuffer.allocateDirect(capacity); + } + + // memsets + + /** + * Fills the specified buffer with zeros from the current position to the current limit. + * + * @param buffer the buffer to fill with zeros + */ + public static void zeroBuffer(ByteBuffer buffer) { memSet(buffer, 0); } + + /** + * Fills the specified buffer with zeros from the current position to the current limit. + * + * @param buffer the buffer to fill with zeros + */ + public static void zeroBuffer(ShortBuffer buffer) { memSet(buffer, 0); } + + /** + * Fills the specified buffer with zeros from the current position to the current limit. + * + * @param buffer the buffer to fill with zeros + */ + public static void zeroBuffer(CharBuffer buffer) { memSet(buffer, 0); } + + /** + * Fills the specified buffer with zeros from the current position to the current limit. + * + * @param buffer the buffer to fill with zeros + */ + public static void zeroBuffer(IntBuffer buffer) { memSet(buffer, 0); } + + /** + * Fills the specified buffer with zeros from the current position to the current limit. + * + * @param buffer the buffer to fill with zeros + */ + public static void zeroBuffer(FloatBuffer buffer) { memSet(buffer, 0); } + + /** + * Fills the specified buffer with zeros from the current position to the current limit. + * + * @param buffer the buffer to fill with zeros + */ + public static void zeroBuffer(LongBuffer buffer) { memSet(buffer, 0); } + + /** + * Fills the specified buffer with zeros from the current position to the current limit. + * + * @param buffer the buffer to fill with zeros + */ + public static void zeroBuffer(DoubleBuffer buffer) { memSet(buffer, 0); } + + /** + * Fills the specified buffer with zeros from the current position to the current limit. + * + * @param buffer the buffer to fill with zeros + */ + public staticThe size of the C {@code long} type depends on the platform and CPU architecture. On Windows it is always 32-bit. On other platforms, it is 32-bit on + * 32-bit architectures and 64-bit on 64-bit architectures. Most APIs prefer portable sizes, so this class is rarely needed.
+ */ +public class CLongBuffer extends CustomBufferThe new buffer's position will be zero, its limit will be its capacity, and its mark will be undefined.
+ * + * @param capacity the new buffer's capacity, in longs + * + * @return the new long buffer + * + * @throws IllegalArgumentException If the {@code capacity} is a negative integer + */ + public static CLongBuffer allocateDirect(int capacity) { + ByteBuffer source = BufferUtils.createByteBuffer(BufferUtils.getAllocationSize(capacity, CLONG_SHIFT)); + return wrap(CLongBuffer.class, memAddress(source), capacity, source); + } + + /** + * Creates a new {@code CLongBuffer} that starts at the specified memory address and has the specified capacity. + * + * @param address the starting memory address + * @param capacity the buffer capacity, in number of longs + */ + public static CLongBuffer create(long address, int capacity) { + return wrap(CLongBuffer.class, address, capacity); + } + + /** + * Creates a new {@code CLongBuffer} using the specified ByteBuffer as its long data source. + * + * @param source the source buffer + */ + public static CLongBuffer create(ByteBuffer source) { + int capacity = source.remaining() >> CLONG_SHIFT; + return wrap(CLongBuffer.class, memAddress(source), capacity, source); + } + + @Override + protected CLongBuffer self() { + return this; + } + + @Override + public int sizeof() { + return CLONG_SIZE; + } + + /** + * Relative get method. Reads the long at this buffer's current position, and then increments the position. + * + * @return the long at the buffer's current position + * + * @throws BufferUnderflowException If the buffer's current position is not smaller than its limit + */ + public long get() { + return memGetCLong(address + Integer.toUnsignedLong(nextGetIndex()) * CLONG_SIZE); + } + + /** + * Convenience relative get from a source ByteBuffer. + * + * @param source the source ByteBuffer + */ + public static long get(ByteBuffer source) { + if (source.remaining() < CLONG_SIZE) { + throw new BufferUnderflowException(); + } + + try { + return memGetCLong(memAddress(source)); + } finally { + source.position(source.position() + CLONG_SIZE); + } + } + + /** + * Relative put method (optional operation). + * + *Writes the specified long into this buffer at the current position, and then increments the position.
+ * + * @param p the long to be written + * + * @return This buffer + * + * @throws BufferOverflowException If this buffer's current position is not smaller than its limit + */ + public CLongBuffer put(long p) { + memPutCLong(address + Integer.toUnsignedLong(nextPutIndex()) * CLONG_SIZE, p); + return this; + } + + /** + * Convenience relative put on a target ByteBuffer. + * + * @param target the target ByteBuffer + * @param p the long value to be written + */ + public static void put(ByteBuffer target, long p) { + if (target.remaining() < CLONG_SIZE) { + throw new BufferOverflowException(); + } + + try { + memPutCLong(memAddress(target), p); + } finally { + target.position(target.position() + CLONG_SIZE); + } + } + + /** + * Absolute get method. Reads the long at the specified {@code index}. + * + * @param index the index from which the long will be read + * + * @return the long at the specified {@code index} + * + * @throws IndexOutOfBoundsException If {@code index} is negative or not smaller than the buffer's limit + */ + public long get(int index) { + return memGetCLong(address + check(index, limit) * CLONG_SIZE); + } + + /** + * Convenience absolute get from a source ByteBuffer. + * + * @param source the source ByteBuffer + * @param index the index at which the long will be read + */ + public static long get(ByteBuffer source, int index) { + checkFromIndexSize(index, CLONG_SIZE, source.limit()); + return memGetCLong(memAddress0(source) + index); + } + + /** + * Absolute put method (optional operation). + * + *Writes the specified long into this buffer at the specified {@code index}.
+ * + * @param index the index at which the long will be written + * @param p the long value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException If {@code index} is negative or not smaller than the buffer's limit + */ + public CLongBuffer put(int index, long p) { + memPutCLong(address + check(index, limit) * CLONG_SIZE, p); + return this; + } + + /** + * Convenience absolute put on a target ByteBuffer. + * + * @param target the target ByteBuffer + * @param index the index at which the long will be written + * @param p the long value to be written + */ + public static void put(ByteBuffer target, int index, long p) { + checkFromIndexSize(index, CLONG_SIZE, target.limit()); + memPutCLong(memAddress0(target) + index, p); + } + + // -- Bulk get operations -- + + /** + * Relative bulk get method. + * + *This method transfers longs from this buffer into the specified destination array. An invocation of this method of the form {@code src.get(a)} + * behaves in exactly the same way as the invocation + * + *
+ * src.get(a, 0, a.length)+ * + * @return This buffer + * + * @throws BufferUnderflowException If there are fewer than {@code length} longs remaining in this buffer + */ + public CLongBuffer get(long[] dst) { + return get(dst, 0, dst.length); + } + + /** + * Relative bulk get method. + * + *
This method transfers longs from this buffer into the specified destination array. If there are fewer longs remaining in the buffer than are + * required to satisfy the request, that is, if {@code length} {@code >} {@code remaining()}, then no longs are transferred and a + * {@link BufferUnderflowException} is thrown. + * + *
Otherwise, this method copies {@code length} longs from this buffer into the specified array, starting at the current position of this buffer and + * at the specified offset in the array. The position of this buffer is then incremented by {@code length}. + * + *
In other words, an invocation of this method of the form {@code src.get(dst, off, len)} has exactly the same effect as the loop
+ * + *+ * for (int i = off; i < off + len; i++) + * dst[i] = src.get();+ * + *
except that it first checks that there are sufficient longs in this buffer and it is potentially much more efficient.
+ * + * @param dst the array into which longs are to be written + * @param offset the offset within the array of the first long to be written; must be non-negative and no larger than {@code dst.length} + * @param length the maximum number of longs to be written to the specified array; must be non-negative and no larger than {@code dst.length - offset} + * + * @return This buffer + * + * @throws BufferUnderflowException If there are fewer than {@code length} longs remaining in this buffer + * @throws IndexOutOfBoundsException If the preconditions on the {@code offset} and {@code length} parameters do not hold + */ + public CLongBuffer get(long[] dst, int offset, int length) { + if (CLONG_SIZE == 8) { + memLongBuffer(address(), remaining()).get(dst, offset, length); + position(position() + length); + } else { + get32(dst, offset, length); + } + + return this; + } + + private void get32(long[] dst, int offset, int length) { + checkFromIndexSize(offset, length, dst.length); + if (remaining() < length) { + throw new BufferUnderflowException(); + } + for (int i = offset, end = offset + length; i < end; i++) { + dst[i] = get(); + } + } + + /** + * Relative bulk put method (optional operation). + * + *This method transfers the entire content of the specified source long array into this buffer. An invocation of this method of the form + * {@code dst.put(a)} behaves in exactly the same way as the invocation
+ * + *+ * dst.put(a, 0, a.length)+ * + * @return This buffer + * + * @throws BufferOverflowException If there is insufficient space in this buffer + */ + public CLongBuffer put(long[] src) { + return put(src, 0, src.length); + } + + /** + * Relative bulk put method (optional operation). + * + *
This method transfers longs into this buffer from the specified source array. If there are more longs to be copied from the array than remain + * in this buffer, that is, if {@code length} {@code >} {@code remaining()}, then no longs are transferred and a + * {@link BufferOverflowException} is thrown. + * + *
Otherwise, this method copies {@code length} longs from the specified array into this buffer, starting at the specified offset in the array and + * at the current position of this buffer. The position of this buffer is then incremented by {@code length}.
+ * + *In other words, an invocation of this method of the form {@code dst.put(src, off, len)} has exactly the same effect as the loop
+ * + *+ * for (int i = off; i < off + len; i++) + * dst.put(a[i]);+ * + *
except that it first checks that there is sufficient space in this buffer and it is potentially much more efficient.
+ * + * @param src the array from which longs are to be read + * @param offset the offset within the array of the first long to be read; must be non-negative and no larger than {@code array.length} + * @param length the number of longs to be read from the specified array; must be non-negative and no larger than {@code array.length - offset} + * + * @return This buffer + * + * @throws BufferOverflowException If there is insufficient space in this buffer + * @throws IndexOutOfBoundsException If the preconditions on the {@code offset} and {@code length} parameters do not hold + */ + public CLongBuffer put(long[] src, int offset, int length) { + if (CLONG_SIZE == 8) { + memLongBuffer(address(), remaining()).put(src, offset, length); + position(position() + length); + } else { + put32(src, offset, length); + } + + return this; + } + + private void put32(long[] src, int offset, int length) { + checkFromIndexSize(offset, length, src.length); + if (remaining() < length) { + throw new BufferOverflowException(); + } + int end = offset + length; + for (int i = offset; i < end; i++) { + put(src[i]); + } + } + + /** + * Returns the current hash code of this buffer. + * + *The hash code of a long buffer depends only upon its remaining elements; that is, upon the elements from {@code position()} up to, and including, + * the element at {@code limit()} - {@code 1}.
+ * + *Because buffer hash codes are content-dependent, it is inadvisable to use buffers as keys in hash maps or similar data structures unless it is known + * that their contents will not change.
+ * + * @return the current hash code of this buffer + */ + public int hashCode() { + int h = 1; + int p = position(); + for (int i = limit() - 1; i >= p; i--) { + h = 31 * h + (int)get(i); + } + return h; + } + + /** + * Tells whether or not this buffer is equal to another object. + * + *Two long buffers are equal if, and only if,
+ * + *A long buffer is not equal to any other type of object.
+ * + * @param ob the object to which this buffer is to be compared + * + * @return {@code true} if, and only if, this buffer is equal to the + * given object + */ + public boolean equals(Object ob) { + if (!(ob instanceof CLongBuffer)) { + return false; + } + CLongBuffer that = (CLongBuffer)ob; + if (this.remaining() != that.remaining()) { + return false; + } + int p = this.position(); + for (int i = this.limit() - 1, j = that.limit() - 1; i >= p; i--, j--) { + long v1 = this.get(i); + long v2 = that.get(j); + if (v1 != v2) { + return false; + } + } + return true; + } + + /** + * Compares this buffer to another. + * + *Two long buffers are compared by comparing their sequences of remaining elements lexicographically, without regard to the starting position of + * each sequence within its corresponding buffer.
+ * + *A long buffer is not comparable to any other type of object.
+ * + * @return A negative integer, zero, or a positive integer as this buffer is less than, equal to, or greater than the specified buffer + */ + @Override + public int compareTo(CLongBuffer that) { + int n = this.position() + Math.min(this.remaining(), that.remaining()); + for (int i = this.position(), j = that.position(); i < n; i++, j++) { + long v1 = this.get(i); + long v2 = that.get(j); + if (v1 == v2) { + continue; + } + if (v1 < v2) { + return -1; + } + return +1; + } + return this.remaining() - that.remaining(); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/PointerBuffer.java b/lwjgl3-fcl/src/main/java/org/lwjgl/PointerBuffer.java new file mode 100644 index 00000000..be628e12 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/PointerBuffer.java @@ -0,0 +1,674 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + */ +package org.lwjgl; + +import org.lwjgl.system.*; + +import javax.annotation.*; +import java.nio.*; + +import static org.lwjgl.system.CheckIntrinsics.*; +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** This class is a container for architecture-independent pointer data. Its interface mirrors the {@link LongBuffer} API for convenience. */ +public class PointerBuffer extends CustomBufferThe new buffer's position will be zero, its limit will be its capacity, and its mark will be undefined.
+ * + * @param capacity the new buffer's capacity, in pointers + * + * @return the new pointer buffer + * + * @throws IllegalArgumentException If the {@code capacity} is a negative integer + */ + public static PointerBuffer allocateDirect(int capacity) { + ByteBuffer source = BufferUtils.createByteBuffer(BufferUtils.getAllocationSize(capacity, POINTER_SHIFT)); + return wrap(PointerBuffer.class, memAddress(source), capacity, source); + } + + /** + * Creates a new PointerBuffer that starts at the specified memory address and has the specified capacity. + * + * @param address the starting memory address + * @param capacity the buffer capacity, in number of pointers + */ + public static PointerBuffer create(long address, int capacity) { + return wrap(PointerBuffer.class, address, capacity); + } + + /** + * Creates a new PointerBuffer using the specified ByteBuffer as its pointer data source. + * + * @param source the source buffer + */ + public static PointerBuffer create(ByteBuffer source) { + int capacity = source.remaining() >> POINTER_SHIFT; + return wrap(PointerBuffer.class, memAddress(source), capacity, source); + } + + @Override + protected PointerBuffer self() { + return this; + } + + @Override + public int sizeof() { + return POINTER_SIZE; + } + + /** + * Relative get method. Reads the pointer at this buffer's current position, and then increments the position. + * + * @return the pointer at the buffer's current position + * + * @throws BufferUnderflowException If the buffer's current position is not smaller than its limit + */ + public long get() { + return memGetAddress(address + Integer.toUnsignedLong(nextGetIndex()) * POINTER_SIZE); + } + + /** + * Convenience relative get from a source ByteBuffer. + * + * @param source the source ByteBuffer + */ + public static long get(ByteBuffer source) { + if (source.remaining() < POINTER_SIZE) { + throw new BufferUnderflowException(); + } + + try { + return memGetAddress(memAddress(source)); + } finally { + source.position(source.position() + POINTER_SIZE); + } + } + + /** + * Relative put method (optional operation). + * + *Writes the specified pointer into this buffer at the current position, and then increments the position.
+ * + * @param p the pointer to be written + * + * @return This buffer + * + * @throws BufferOverflowException If this buffer's current position is not smaller than its limit + */ + public PointerBuffer put(long p) { + memPutAddress(address + Integer.toUnsignedLong(nextPutIndex()) * POINTER_SIZE, p); + return this; + } + + /** + * Convenience relative put on a target ByteBuffer. + * + * @param target the target ByteBuffer + * @param p the pointer value to be written + */ + public static void put(ByteBuffer target, long p) { + if (target.remaining() < POINTER_SIZE) { + throw new BufferOverflowException(); + } + + try { + memPutAddress(memAddress(target), p); + } finally { + target.position(target.position() + POINTER_SIZE); + } + } + + /** + * Absolute get method. Reads the pointer at the specified {@code index}. + * + * @param index the index from which the pointer will be read + * + * @return the pointer at the specified {@code index} + * + * @throws IndexOutOfBoundsException If {@code index} is negative or not smaller than the buffer's limit + */ + public long get(int index) { + return memGetAddress(address + check(index, limit) * POINTER_SIZE); + } + + /** + * Convenience absolute get from a source ByteBuffer. + * + * @param source the source ByteBuffer + * @param index the index at which the pointer will be read + */ + public static long get(ByteBuffer source, int index) { + checkFromIndexSize(index, POINTER_SIZE, source.limit()); + return memGetAddress(memAddress0(source) + index); + } + + /** + * Absolute put method (optional operation). + * + *Writes the specified pointer into this buffer at the specified {@code index}.
+ * + * @param index the index at which the pointer will be written + * @param p the pointer value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException If {@code index} is negative or not smaller than the buffer's limit + */ + public PointerBuffer put(int index, long p) { + memPutAddress(address + check(index, limit) * POINTER_SIZE, p); + return this; + } + + /** + * Convenience absolute put on a target ByteBuffer. + * + * @param target the target ByteBuffer + * @param index the index at which the pointer will be written + * @param p the pointer value to be written + */ + public static void put(ByteBuffer target, int index, long p) { + checkFromIndexSize(index, POINTER_SIZE, target.limit()); + memPutAddress(memAddress0(target) + index, p); + } + + // -- PointerWrapper operations -- + + /** Puts the pointer value of the specified {@link Pointer} at the current position and then increments the position. */ + public PointerBuffer put(Pointer pointer) { + put(pointer.address()); + return this; + } + + /** Puts the pointer value of the specified {@link Pointer} at the specified {@code index}. */ + public PointerBuffer put(int index, Pointer pointer) { + put(index, pointer.address()); + return this; + } + + // -- Buffer address operations -- + + /** + *Writes the address of the specified {@code buffer} into this buffer at the current position, and then increments the position.
+ * + * @param buffer the pointer to be written + * + * @return this buffer + * + * @throws BufferOverflowException If this buffer's current position is not smaller than its limit + */ + public PointerBuffer put(ByteBuffer buffer) { + put(memAddress(buffer)); + return this; + } + + /** + *Writes the address of the specified {@code buffer} into this buffer at the current position, and then increments the position.
+ * + * @param buffer the pointer to be written + * + * @return this buffer + * + * @throws BufferOverflowException If this buffer's current position is not smaller than its limit + */ + public PointerBuffer put(ShortBuffer buffer) { + put(memAddress(buffer)); + return this; + } + + /** + *Writes the address of the specified {@code buffer} into this buffer at the current position, and then increments the position.
+ * + * @param buffer the pointer to be written + * + * @return this buffer + * + * @throws BufferOverflowException If this buffer's current position is not smaller than its limit + */ + public PointerBuffer put(IntBuffer buffer) { + put(memAddress(buffer)); + return this; + } + + /** + *Writes the address of the specified {@code buffer} into this buffer at the current position, and then increments the position.
+ * + * @param buffer the pointer to be written + * + * @return this buffer + * + * @throws BufferOverflowException If this buffer's current position is not smaller than its limit + */ + public PointerBuffer put(LongBuffer buffer) { + put(memAddress(buffer)); + return this; + } + + /** + *Writes the address of the specified {@code buffer} into this buffer at the current position, and then increments the position.
+ * + * @param buffer the pointer to be written + * + * @return this buffer + * + * @throws BufferOverflowException If this buffer's current position is not smaller than its limit + */ + public PointerBuffer put(FloatBuffer buffer) { + put(memAddress(buffer)); + return this; + } + + /** + *Writes the address of the specified {@code buffer} into this buffer at the current position, and then increments the position.
+ * + * @param buffer the pointer to be written + * + * @return this buffer + * + * @throws BufferOverflowException If this buffer's current position is not smaller than its limit + */ + public PointerBuffer put(DoubleBuffer buffer) { + put(memAddress(buffer)); + return this; + } + + /** + *Writes the address of the specified {@code buffer} into this buffer at the current position, and then increments the position.
+ * + * @param buffer the pointer to be written + * + * @return this buffer + * + * @throws BufferOverflowException If this buffer's current position is not smaller than its limit + */ + public PointerBuffer putAddressOf(CustomBuffer buffer) { + put(memAddress(buffer)); + return this; + } + + // --- + + /** Puts the address of the specified {@code buffer} at the specified {@code index}. */ + public PointerBuffer put(int index, ByteBuffer buffer) { + put(index, memAddress(buffer)); + return this; + } + + /** Puts the address of the specified {@code buffer} at the specified {@code index}. */ + public PointerBuffer put(int index, ShortBuffer buffer) { + put(index, memAddress(buffer)); + return this; + } + + /** Puts the address of the specified {@code buffer} at the specified {@code index}. */ + public PointerBuffer put(int index, IntBuffer buffer) { + put(index, memAddress(buffer)); + return this; + } + + /** Puts the address of the specified {@code buffer} at the specified {@code index}. */ + public PointerBuffer put(int index, LongBuffer buffer) { + put(index, memAddress(buffer)); + return this; + } + + /** Puts the address of the specified {@code buffer} at the specified {@code index}. */ + public PointerBuffer put(int index, FloatBuffer buffer) { + put(index, memAddress(buffer)); + return this; + } + + /** Puts the address of the specified {@code buffer} at the specified {@code index}. */ + public PointerBuffer put(int index, DoubleBuffer buffer) { + put(index, memAddress(buffer)); + return this; + } + + /** Puts the address of the specified {@code buffer} at the specified {@code index}. */ + public PointerBuffer putAddressOf(int index, CustomBuffer buffer) { + put(index, memAddress(buffer)); + return this; + } + + // --- + + /** + * Reads the pointer at this buffer's current position, and then increments the position. The pointer is returned as a {@link ByteBuffer} instance that + * starts at the pointer address and has capacity equal to the specified {@code size}. + * + * @throws BufferUnderflowException If the buffer's current position is not smaller than its limit + */ + public ByteBuffer getByteBuffer(int size) { return memByteBuffer(get(), size); } + + /** + * Reads the pointer at this buffer's current position, and then increments the position. The pointer is returned as a {@link ShortBuffer} instance that + * starts at the pointer address and has capacity equal to the specified {@code size}. + * + * @throws BufferUnderflowException If the buffer's current position is not smaller than its limit + */ + public ShortBuffer getShortBuffer(int size) { return memShortBuffer(get(), size); } + + /** + * Reads the pointer at this buffer's current position, and then increments the position. The pointer is returned as a {@link IntBuffer} instance that + * starts at the pointer address and has capacity equal to the specified {@code size}. + * + * @throws BufferUnderflowException If the buffer's current position is not smaller than its limit + */ + public IntBuffer getIntBuffer(int size) { return memIntBuffer(get(), size); } + + /** + * Reads the pointer at this buffer's current position, and then increments the position. The pointer is returned as a {@link LongBuffer} instance that + * starts at the pointer address and has capacity equal to the specified {@code size}. + * + * @throws BufferUnderflowException If the buffer's current position is not smaller than its limit + */ + public LongBuffer getLongBuffer(int size) { return memLongBuffer(get(), size); } + + /** + * Reads the pointer at this buffer's current position, and then increments the position. The pointer is returned as a {@link FloatBuffer} instance that + * starts at the pointer address and has capacity equal to the specified {@code size}. + * + * @throws BufferUnderflowException If the buffer's current position is not smaller than its limit + */ + public FloatBuffer getFloatBuffer(int size) { return memFloatBuffer(get(), size); } + + /** + * Reads the pointer at this buffer's current position, and then increments the position. The pointer is returned as a {@link DoubleBuffer} instance that + * starts at the pointer address and has capacity equal to the specified {@code size}. + * + * @throws BufferUnderflowException If the buffer's current position is not smaller than its limit + */ + public DoubleBuffer getDoubleBuffer(int size) { return memDoubleBuffer(get(), size); } + + /** + * Reads the pointer at this buffer's current position, and then increments the position. The pointer is returned as a {@code PointerBuffer} instance that + * starts at the pointer address and has capacity equal to the specified {@code size}. + * + * @throws BufferUnderflowException If the buffer's current position is not smaller than its limit + */ + public PointerBuffer getPointerBuffer(int size) { return memPointerBuffer(get(), size); } + + /** + * Reads the pointer at this buffer's current position, and then increments the position. The pointer is evaluated as a null-terminated ASCII string, which + * is decoded and returned as a {@link String} instance. + * + * @throws BufferUnderflowException If the buffer's current position is not smaller than its limit + */ + public String getStringASCII() { return memASCII(get()); } + + /** + * Reads the pointer at this buffer's current position, and then increments the position. The pointer is evaluated as a null-terminated UTF-8 string, which + * is decoded and returned as a {@link String} instance. + * + * @throws BufferUnderflowException If the buffer's current position is not smaller than its limit + */ + public String getStringUTF8() { return memUTF8(get()); } + + /** + * Reads the pointer at this buffer's current position, and then increments the position. The pointer is evaluated as a null-terminated UTF-16 string, + * which is decoded and returned as a {@link String} instance. + * + * @throws BufferUnderflowException If the buffer's current position is not smaller than its limit + */ + public String getStringUTF16() { return memUTF16(get()); } + + // --- + + /** Returns a {@link ByteBuffer} instance that starts at the address found at the specified {@code index} and has capacity equal to the specified size. */ + public ByteBuffer getByteBuffer(int index, int size) { return memByteBuffer(get(index), size); } + + /** Returns a {@link ShortBuffer} instance that starts at the address found at the specified {@code index} and has capacity equal to the specified size. */ + public ShortBuffer getShortBuffer(int index, int size) { return memShortBuffer(get(index), size); } + + /** Returns a {@link IntBuffer} instance that starts at the address found at the specified {@code index} and has capacity equal to the specified size. */ + public IntBuffer getIntBuffer(int index, int size) { return memIntBuffer(get(index), size); } + + /** Returns a {@link LongBuffer} instance that starts at the address found at the specified {@code index} and has capacity equal to the specified size. */ + public LongBuffer getLongBuffer(int index, int size) { return memLongBuffer(get(index), size); } + + /** Returns a {@link FloatBuffer} instance that starts at the address found at the specified {@code index} and has capacity equal to the specified size. */ + public FloatBuffer getFloatBuffer(int index, int size) { return memFloatBuffer(get(index), size); } + + /** Returns a {@link DoubleBuffer} instance that starts at the address found at the specified {@code index} and has capacity equal to the specified size. */ + public DoubleBuffer getDoubleBuffer(int index, int size) { return memDoubleBuffer(get(index), size); } + + /** Returns a {@code PointerBuffer} instance that starts at the address found at the specified {@code index} and has capacity equal to the specified size. */ + public PointerBuffer getPointerBuffer(int index, int size) { return memPointerBuffer(get(index), size); } + + /** Decodes the ASCII string that starts at the address found at the specified {@code index}. */ + public String getStringASCII(int index) { return memASCII(get(index)); } + + /** Decodes the UTF-8 string that starts at the address found at the specified {@code index}. */ + public String getStringUTF8(int index) { return memUTF8(get(index)); } + + /** Decodes the UTF-16 string that starts at the address found at the specified {@code index}. */ + public String getStringUTF16(int index) { return memUTF16(get(index)); } + + // -- Bulk get operations -- + + /** + * Relative bulk get method. + * + *This method transfers pointers from this buffer into the specified destination array. An invocation of this method of the form {@code src.get(a)} + * behaves in exactly the same way as the invocation + * + *
+ * src.get(a, 0, a.length)+ * + * @return This buffer + * + * @throws BufferUnderflowException If there are fewer than {@code length} pointers remaining in this buffer + */ + public PointerBuffer get(long[] dst) { + return get(dst, 0, dst.length); + } + + /** + * Relative bulk get method. + * + *
This method transfers pointers from this buffer into the specified destination array. If there are fewer pointers remaining in the buffer than are + * required to satisfy the request, that is, if {@code length} {@code >} {@code remaining()}, then no pointers are transferred and a + * {@link BufferUnderflowException} is thrown. + * + *
Otherwise, this method copies {@code length} pointers from this buffer into the specified array, starting at the current position of this buffer and + * at the specified offset in the array. The position of this buffer is then incremented by {@code length}. + * + *
In other words, an invocation of this method of the form {@code src.get(dst, off, len)} has exactly the same effect as the loop
+ * + *+ * for (int i = off; i < off + len; i++) + * dst[i] = src.get();+ * + *
except that it first checks that there are sufficient pointers in this buffer and it is potentially much more efficient.
+ * + * @param dst the array into which pointers are to be written + * @param offset the offset within the array of the first pointer to be written; must be non-negative and no larger than {@code dst.length} + * @param length the maximum number of pointers to be written to the specified array; must be non-negative and no larger than {@code dst.length - offset} + * + * @return This buffer + * + * @throws BufferUnderflowException If there are fewer than {@code length} pointers remaining in this buffer + * @throws IndexOutOfBoundsException If the preconditions on the {@code offset} and {@code length} parameters do not hold + */ + public PointerBuffer get(long[] dst, int offset, int length) { + if (BITS64) { + memLongBuffer(address(), remaining()).get(dst, offset, length); + position(position() + length); + } else { + get32(dst, offset, length); + } + + return this; + } + + private void get32(long[] dst, int offset, int length) { + checkFromIndexSize(offset, length, dst.length); + if (remaining() < length) { + throw new BufferUnderflowException(); + } + for (int i = offset, end = offset + length; i < end; i++) { + dst[i] = get(); + } + } + + /** + * Relative bulk put method (optional operation). + * + *This method transfers the entire content of the specified source pointer array into this buffer. An invocation of this method of the form + * {@code dst.put(a)} behaves in exactly the same way as the invocation
+ * + *+ * dst.put(a, 0, a.length)+ * + * @return This buffer + * + * @throws BufferOverflowException If there is insufficient space in this buffer + */ + public PointerBuffer put(long[] src) { + return put(src, 0, src.length); + } + + /** + * Relative bulk put method (optional operation). + * + *
This method transfers pointers into this buffer from the specified source array. If there are more pointers to be copied from the array than remain + * in this buffer, that is, if {@code length} {@code >} {@code remaining()}, then no pointers are transferred and a + * {@link BufferOverflowException} is thrown. + * + *
Otherwise, this method copies {@code length} pointers from the specified array into this buffer, starting at the specified offset in the array and + * at the current position of this buffer. The position of this buffer is then incremented by {@code length}.
+ * + *In other words, an invocation of this method of the form {@code dst.put(src, off, len)} has exactly the same effect as the loop
+ * + *+ * for (int i = off; i < off + len; i++) + * dst.put(a[i]);+ * + *
except that it first checks that there is sufficient space in this buffer and it is potentially much more efficient.
+ * + * @param src the array from which pointers are to be read + * @param offset the offset within the array of the first pointer to be read; must be non-negative and no larger than {@code array.length} + * @param length the number of pointers to be read from the specified array; must be non-negative and no larger than {@code array.length - offset} + * + * @return This buffer + * + * @throws BufferOverflowException If there is insufficient space in this buffer + * @throws IndexOutOfBoundsException If the preconditions on the {@code offset} and {@code length} parameters do not hold + */ + public PointerBuffer put(long[] src, int offset, int length) { + if (BITS64) { + memLongBuffer(address(), remaining()).put(src, offset, length); + position(position() + length); + } else { + put32(src, offset, length); + } + + return this; + } + + private void put32(long[] src, int offset, int length) { + checkFromIndexSize(offset, length, src.length); + if (remaining() < length) { + throw new BufferOverflowException(); + } + int end = offset + length; + for (int i = offset; i < end; i++) { + put(src[i]); + } + } + + /** + * Returns the current hash code of this buffer. + * + *The hash code of a pointer buffer depends only upon its remaining elements; that is, upon the elements from {@code position()} up to, and including, + * the element at {@code limit()} - {@code 1}.
+ * + *Because buffer hash codes are content-dependent, it is inadvisable to use buffers as keys in hash maps or similar data structures unless it is known + * that their contents will not change.
+ * + * @return the current hash code of this buffer + */ + public int hashCode() { + int h = 1; + int p = position(); + for (int i = limit() - 1; i >= p; i--) { + h = 31 * h + (int)get(i); + } + return h; + } + + /** + * Tells whether or not this buffer is equal to another object. + * + *Two pointer buffers are equal if, and only if,
+ * + *A pointer buffer is not equal to any other type of object.
+ * + * @param ob the object to which this buffer is to be compared + * + * @return {@code true} if, and only if, this buffer is equal to the + * given object + */ + public boolean equals(Object ob) { + if (!(ob instanceof PointerBuffer)) { + return false; + } + PointerBuffer that = (PointerBuffer)ob; + if (this.remaining() != that.remaining()) { + return false; + } + int p = this.position(); + for (int i = this.limit() - 1, j = that.limit() - 1; i >= p; i--, j--) { + long v1 = this.get(i); + long v2 = that.get(j); + if (v1 != v2) { + return false; + } + } + return true; + } + + /** + * Compares this buffer to another. + * + *Two pointer buffers are compared by comparing their sequences of remaining elements lexicographically, without regard to the starting position of + * each sequence within its corresponding buffer.
+ * + *A pointer buffer is not comparable to any other type of object.
+ * + * @return A negative integer, zero, or a positive integer as this buffer is less than, equal to, or greater than the specified buffer + */ + @Override + public int compareTo(PointerBuffer that) { + int n = this.position() + Math.min(this.remaining(), that.remaining()); + for (int i = this.position(), j = that.position(); i < n; i++, j++) { + long v1 = this.get(i); + long v2 = that.get(j); + if (v1 == v2) { + continue; + } + if (v1 < v2) { + return -1; + } + return +1; + } + return this.remaining() - that.remaining(); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/Version.java b/lwjgl3-fcl/src/main/java/org/lwjgl/Version.java new file mode 100644 index 00000000..c576dff7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/Version.java @@ -0,0 +1,55 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + */ +package org.lwjgl; + +import static org.lwjgl.system.APIUtil.*; + +/** This class can be used to query the LWJGL version. */ +public final class Version { + + /** Current version of library. */ + public static final int + VERSION_MAJOR = 3, + VERSION_MINOR = 2, + VERSION_REVISION = 3; + + /** The development state of the current build. */ + public static final BuildType BUILD_TYPE = BuildType.STABLE; + + private static final String version = + String.valueOf(VERSION_MAJOR) + + '.' + VERSION_MINOR + + '.' + VERSION_REVISION + BUILD_TYPE.postfix + + ' ' + apiGetManifestValue("Implementation-Version").orElse("SNAPSHOT"); + + private Version() { + } + + public static void main(String[] args) { + System.out.println(getVersion()); + } + + /** Returns the LWJGL version. */ + public static String getVersion() { + return version; + } + + /** The development state of the current build. */ + public enum BuildType { + /** Work in progress, unstable. */ + ALPHA("a"), + /** Feature complete, unstable. */ + BETA("b"), + /** Feature complete, stable, official release. */ + STABLE(""); + + public final String postfix; + + BuildType(String postfix) { + this.postfix = postfix; + } + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/Callbacks.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/Callbacks.java new file mode 100644 index 00000000..375d896f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/Callbacks.java @@ -0,0 +1,60 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + */ +package org.lwjgl.glfw; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** Utility class for GLFW callbacks. */ +public final class Callbacks { + + private Callbacks() {} + + /** + * Resets all callbacks for the specified GLFW window to {@code NULL} and {@link Callback#free frees} all previously set callbacks. + * + *This method resets only callbacks registered with a GLFW window. Non-window callbacks (registered with + * {@link GLFW#glfwSetErrorCallback SetErrorCallback}, {@link GLFW#glfwSetMonitorCallback SetMonitorCallback}, etc.) must be reset and freed + * separately.
+ * + *This method is not official GLFW API. It exists in LWJGL to simplify window callback cleanup.
+ * + * @param window the GLFW window + */ + public static void glfwFreeCallbacks(@NativeType("GLFWwindow *") long window) { + if (Checks.CHECKS) { + check(window); + } + + for (long callback : new long[] { + GLFW.Functions.SetWindowPosCallback, + GLFW.Functions.SetWindowSizeCallback, + GLFW.Functions.SetWindowCloseCallback, + GLFW.Functions.SetWindowRefreshCallback, + GLFW.Functions.SetWindowFocusCallback, + GLFW.Functions.SetWindowIconifyCallback, + GLFW.Functions.SetWindowMaximizeCallback, + GLFW.Functions.SetFramebufferSizeCallback, + GLFW.Functions.SetWindowContentScaleCallback, + GLFW.Functions.SetKeyCallback, + GLFW.Functions.SetCharCallback, + GLFW.Functions.SetCharModsCallback, + GLFW.Functions.SetMouseButtonCallback, + GLFW.Functions.SetCursorPosCallback, + GLFW.Functions.SetCursorEnterCallback, + GLFW.Functions.SetScrollCallback, + GLFW.Functions.SetDropCallback + }) { + long prevCB = invokePPP(window, NULL, callback); + if (prevCB != NULL) { + Callback.free(prevCB); + } + } + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/EventLoop.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/EventLoop.java new file mode 100644 index 00000000..b174c204 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/EventLoop.java @@ -0,0 +1,97 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + */ +package org.lwjgl.glfw; + +import org.lwjgl.system.*; +import org.lwjgl.system.macosx.*; + +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.macosx.LibC.*; +import static org.lwjgl.system.macosx.ObjCRuntime.*; + +/** + * Contains checks for the event loop issues on OS X. + * + *On-screen GLFW windows can only be used in the main thread and only if that thread is the first thread in the process. This requires running the JVM with + * {@code -XstartOnFirstThread}, which means that other window toolkits (AWT/Swing, JavaFX, etc.) cannot be used at the same time.
+ * + *Another window toolkit can be used if GLFW windows are never shown (created with {@link GLFW#GLFW_VISIBLE GLFW_VISIBLE} equal to + * {@link GLFW#GLFW_FALSE GLFW_FALSE}) and only used as contexts for offscreen rendering. This is possible if the window toolkit has initialized and created + * the shared application (NSApp) before a GLFW window is created.
+ */ +final class EventLoop { + + static final class OffScreen { + static { + if (Platform.get() == Platform.MACOSX && !isMainThread()) { + // The only way to avoid a crash is if the shared application (NSApp) has been created by something else + SharedLibrary AppKit = MacOSXLibrary.getWithIdentifier("com.apple.AppKit"); + try { + long NSApp = AppKit.getFunctionAddress("NSApp"); // The NSApp global variable is an exported symbol + if (memGetAddress(NSApp) == NULL) { + throw new IllegalStateException( + isJavaStartedOnFirstThread() + ? "GLFW windows may only be created on the main thread." + : "GLFW windows may only be created on the main thread and that thread must be the first thread in the process. Please run " + + "the JVM with -XstartOnFirstThread. For offscreen rendering, make sure another window toolkit (e.g. AWT or JavaFX) is " + + "initialized before GLFW." + ); + } + + apiLog("GLFW can only be used for offscreen rendering."); + } finally { + AppKit.free(); + } + } + } + + private OffScreen() { + } + + static void check() { + // intentionally empty to trigger the static initializer + } + } + + static final class OnScreen { + static { + if (Platform.get() == Platform.MACOSX && !isMainThread()) { + throw new IllegalStateException( + "Please run the JVM with -XstartOnFirstThread and make sure a window toolkit other than GLFW (e.g. AWT or JavaFX) is not initialized." + ); + } + } + + private OnScreen() { + } + + static void check() { + // intentionally empty to trigger the static initializer + } + } + + private EventLoop() { + } + + private static boolean isMainThread() { + if (!Configuration.GLFW_CHECK_THREAD0.get(true)) { + return true; + } + + long objc_msgSend = ObjCRuntime.getLibrary().getFunctionAddress("objc_msgSend"); + + long NSThread = objc_getClass("NSThread"); + long currentThread = invokePPP(NSThread, sel_getUid("currentThread"), objc_msgSend); + + return invokePPZ(currentThread, sel_getUid("isMainThread"), objc_msgSend); + } + + private static boolean isJavaStartedOnFirstThread() { + return "1".equals(System.getenv().get("JAVA_STARTED_ON_FIRST_THREAD_" + getpid())); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/FCLInjector.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/FCLInjector.java new file mode 100644 index 00000000..40fea7dd --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/FCLInjector.java @@ -0,0 +1,142 @@ +package org.lwjgl.glfw; + +import org.lwjgl.system.*; + +import javax.annotation.Nullable; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import static org.lwjgl.system.APIUtil.apiGetFunctionAddress; +import static org.lwjgl.system.APIUtil.apiLog; + +/** + * By Tungsten + * This class is for Fold Craft Launcher. + */ +public class FCLInjector { + + public static final long GetInjectorMode = apiGetFunctionAddress(GLFW.GLFW, "glfwGetInjectorMode"); + public static final long SetInjectorMode = apiGetFunctionAddress(GLFW.GLFW, "glfwSetInjectorMode"); + public static final long SetHitResultType = apiGetFunctionAddress(GLFW.GLFW, "glfwSetHitResultType"); + + private static boolean get = false; + private static ClassLoader classLoader; + + private static final String HIT_RESULT_TYPE_UNKNOWN = "UNKNOWN"; + private static final String HIT_RESULT_TYPE_MISS = "MISS"; + private static final String HIT_RESULT_TYPE_BLOCK = "BLOCK"; + private static final String HIT_RESULT_TYPE_ENTITY = "ENTITY"; + + private static final int INJECTOR_MODE_ENABLE = 1; + private static final int INJECTOR_MODE_DISABLE = 0; + + private static boolean highVersion = false; + @Nullable + private static String param0 = null; + @Nullable + private static String param1 = null; + @Nullable + private static String param2 = null; + @Nullable + private static String param3 = null; + + public static void setClassLoader(ClassLoader classLoader) { + String prop = System.getProperty("fcl.injector"); + if (!get && prop != null && !prop.isEmpty()) { + FCLInjector.classLoader = classLoader; + String[] props = prop.split(":"); + if (props.length == 5 && (props[0].equals("true") || props[0].equals("false"))) { + boolean highVersion = Boolean.parseBoolean(props[0]); + String param0 = props[1]; + String param1 = props[2]; + String param2 = props[3]; + String param3 = props[4]; + setup(highVersion, param0, param1, param2, param3); + } + } + } + + public static void setup(boolean highVersion, String param0, String param1, String param2, String param3) { + FCLInjector.highVersion = highVersion; + FCLInjector.param0 = param0; + FCLInjector.param1 = param1; + FCLInjector.param2 = param2; + FCLInjector.param3 = param3; + get = true; + new Thread(() -> { + while (true) { + if (nglfwGetInjectorMode() == INJECTOR_MODE_ENABLE) { + getHitResultType(); + nglfwSetInjectorMode(INJECTOR_MODE_DISABLE); + } + } + }).start(); + } + + public static int nglfwGetInjectorMode() { + return JNI.invokeI(GetInjectorMode); + } + + public static void nglfwSetInjectorMode(int mode) { + JNI.invokeV(mode, SetInjectorMode); + } + + public static void nglfwSetHitResultType(String type) { + int typeInt; + switch (type) { + case HIT_RESULT_TYPE_MISS: + typeInt = 1; + break; + case HIT_RESULT_TYPE_BLOCK: + typeInt = 2; + break; + case HIT_RESULT_TYPE_ENTITY: + typeInt = 3; + break; + default: + typeInt = 0; + break; + }; + JNI.invokeV(typeInt, FCLInjector.SetHitResultType); + } + + public static void getHitResultType() { + if (!get) { + nglfwSetHitResultType(HIT_RESULT_TYPE_UNKNOWN); + apiLog("FCL Injector not initialized!"); + return; + } + if (param0 != null && param1 != null && param2 != null && param3 != null) { + Object type = null; + try { + Class minecraftClass = Class.forName(param0, true, classLoader); + Method method = minecraftClass.getDeclaredMethod(param1); + method.setAccessible(true); + Object minecraft = method.invoke(null); + Field targetField = minecraftClass.getDeclaredField(param2); + targetField.setAccessible(true); + Object target = targetField.get(minecraft); + if (target != null) { + if (!highVersion) { + Field typeField = target.getClass().getDeclaredField(param3); + typeField.setAccessible(true); + type = typeField.get(target); + } else { + Method typeMethod = target.getClass().getDeclaredMethod(param3); + typeMethod.setAccessible(true); + type = typeMethod.invoke(target); + } + } + } catch (ClassNotFoundException | NoSuchFieldException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { + apiLog(e.getMessage()); + } + if (type != null && (type.toString().equals(HIT_RESULT_TYPE_MISS) || type.toString().equals(HIT_RESULT_TYPE_BLOCK) || type.toString().equals(HIT_RESULT_TYPE_ENTITY))) { + nglfwSetHitResultType(type.toString()); + } else { + nglfwSetHitResultType(HIT_RESULT_TYPE_UNKNOWN); + } + } + } + +} diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFW.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFW.java new file mode 100644 index 00000000..6fd39c55 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFW.java @@ -0,0 +1,4758 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the GLFW library. + * + *GLFW is a free, Open Source, multi-platform library for opening a window, creating an OpenGL context and managing input. It is easy to integrate into + * existing applications and does not lay claim to the main loop.
+ */ +public class GLFW { + + /** The major version number of the GLFW library. This is incremented when the API is changed in non-compatible ways. */ + public static final int GLFW_VERSION_MAJOR = 3; + + /** The minor version number of the GLFW library. This is incremented when features are added to the API but it remains backward-compatible. */ + public static final int GLFW_VERSION_MINOR = 4; + + /** The revision number of the GLFW library. This is incremented when a bug fix release is made that does not contain any API changes. */ + public static final int GLFW_VERSION_REVISION = 0; + + /** Boolean values. */ + public static final int + GLFW_TRUE = 1, + GLFW_FALSE = 0; + + /** The key or button was released. */ + public static final int GLFW_RELEASE = 0; + + /** The key or button was pressed. */ + public static final int GLFW_PRESS = 1; + + /** The key was held down until it repeated. */ + public static final int GLFW_REPEAT = 2; + + /** Joystick hat states. */ + public static final int + GLFW_HAT_CENTERED = 0, + GLFW_HAT_UP = 1, + GLFW_HAT_RIGHT = 2, + GLFW_HAT_DOWN = 4, + GLFW_HAT_LEFT = 8, + GLFW_HAT_RIGHT_UP = (GLFW_HAT_RIGHT | GLFW_HAT_UP), + GLFW_HAT_RIGHT_DOWN = (GLFW_HAT_RIGHT | GLFW_HAT_DOWN), + GLFW_HAT_LEFT_UP = (GLFW_HAT_LEFT | GLFW_HAT_UP), + GLFW_HAT_LEFT_DOWN = (GLFW_HAT_LEFT | GLFW_HAT_DOWN); + + /** The unknown key. */ + public static final int GLFW_KEY_UNKNOWN = -1; + + /** Printable keys. */ + public static final int + GLFW_KEY_SPACE = 32, + GLFW_KEY_APOSTROPHE = 39, + GLFW_KEY_COMMA = 44, + GLFW_KEY_MINUS = 45, + GLFW_KEY_PERIOD = 46, + GLFW_KEY_SLASH = 47, + GLFW_KEY_0 = 48, + GLFW_KEY_1 = 49, + GLFW_KEY_2 = 50, + GLFW_KEY_3 = 51, + GLFW_KEY_4 = 52, + GLFW_KEY_5 = 53, + GLFW_KEY_6 = 54, + GLFW_KEY_7 = 55, + GLFW_KEY_8 = 56, + GLFW_KEY_9 = 57, + GLFW_KEY_SEMICOLON = 59, + GLFW_KEY_EQUAL = 61, + GLFW_KEY_A = 65, + GLFW_KEY_B = 66, + GLFW_KEY_C = 67, + GLFW_KEY_D = 68, + GLFW_KEY_E = 69, + GLFW_KEY_F = 70, + GLFW_KEY_G = 71, + GLFW_KEY_H = 72, + GLFW_KEY_I = 73, + GLFW_KEY_J = 74, + GLFW_KEY_K = 75, + GLFW_KEY_L = 76, + GLFW_KEY_M = 77, + GLFW_KEY_N = 78, + GLFW_KEY_O = 79, + GLFW_KEY_P = 80, + GLFW_KEY_Q = 81, + GLFW_KEY_R = 82, + GLFW_KEY_S = 83, + GLFW_KEY_T = 84, + GLFW_KEY_U = 85, + GLFW_KEY_V = 86, + GLFW_KEY_W = 87, + GLFW_KEY_X = 88, + GLFW_KEY_Y = 89, + GLFW_KEY_Z = 90, + GLFW_KEY_LEFT_BRACKET = 91, + GLFW_KEY_BACKSLASH = 92, + GLFW_KEY_RIGHT_BRACKET = 93, + GLFW_KEY_GRAVE_ACCENT = 96, + GLFW_KEY_WORLD_1 = 161, + GLFW_KEY_WORLD_2 = 162; + + /** Function keys. */ + public static final int + GLFW_KEY_ESCAPE = 256, + GLFW_KEY_ENTER = 257, + GLFW_KEY_TAB = 258, + GLFW_KEY_BACKSPACE = 259, + GLFW_KEY_INSERT = 260, + GLFW_KEY_DELETE = 261, + GLFW_KEY_RIGHT = 262, + GLFW_KEY_LEFT = 263, + GLFW_KEY_DOWN = 264, + GLFW_KEY_UP = 265, + GLFW_KEY_PAGE_UP = 266, + GLFW_KEY_PAGE_DOWN = 267, + GLFW_KEY_HOME = 268, + GLFW_KEY_END = 269, + GLFW_KEY_CAPS_LOCK = 280, + GLFW_KEY_SCROLL_LOCK = 281, + GLFW_KEY_NUM_LOCK = 282, + GLFW_KEY_PRINT_SCREEN = 283, + GLFW_KEY_PAUSE = 284, + GLFW_KEY_F1 = 290, + GLFW_KEY_F2 = 291, + GLFW_KEY_F3 = 292, + GLFW_KEY_F4 = 293, + GLFW_KEY_F5 = 294, + GLFW_KEY_F6 = 295, + GLFW_KEY_F7 = 296, + GLFW_KEY_F8 = 297, + GLFW_KEY_F9 = 298, + GLFW_KEY_F10 = 299, + GLFW_KEY_F11 = 300, + GLFW_KEY_F12 = 301, + GLFW_KEY_F13 = 302, + GLFW_KEY_F14 = 303, + GLFW_KEY_F15 = 304, + GLFW_KEY_F16 = 305, + GLFW_KEY_F17 = 306, + GLFW_KEY_F18 = 307, + GLFW_KEY_F19 = 308, + GLFW_KEY_F20 = 309, + GLFW_KEY_F21 = 310, + GLFW_KEY_F22 = 311, + GLFW_KEY_F23 = 312, + GLFW_KEY_F24 = 313, + GLFW_KEY_F25 = 314, + GLFW_KEY_KP_0 = 320, + GLFW_KEY_KP_1 = 321, + GLFW_KEY_KP_2 = 322, + GLFW_KEY_KP_3 = 323, + GLFW_KEY_KP_4 = 324, + GLFW_KEY_KP_5 = 325, + GLFW_KEY_KP_6 = 326, + GLFW_KEY_KP_7 = 327, + GLFW_KEY_KP_8 = 328, + GLFW_KEY_KP_9 = 329, + GLFW_KEY_KP_DECIMAL = 330, + GLFW_KEY_KP_DIVIDE = 331, + GLFW_KEY_KP_MULTIPLY = 332, + GLFW_KEY_KP_SUBTRACT = 333, + GLFW_KEY_KP_ADD = 334, + GLFW_KEY_KP_ENTER = 335, + GLFW_KEY_KP_EQUAL = 336, + GLFW_KEY_LEFT_SHIFT = 340, + GLFW_KEY_LEFT_CONTROL = 341, + GLFW_KEY_LEFT_ALT = 342, + GLFW_KEY_LEFT_SUPER = 343, + GLFW_KEY_RIGHT_SHIFT = 344, + GLFW_KEY_RIGHT_CONTROL = 345, + GLFW_KEY_RIGHT_ALT = 346, + GLFW_KEY_RIGHT_SUPER = 347, + GLFW_KEY_MENU = 348, + GLFW_KEY_LAST = GLFW_KEY_MENU; + + /** If this bit is set one or more Shift keys were held down. */ + public static final int GLFW_MOD_SHIFT = 0x1; + + /** If this bit is set one or more Control keys were held down. */ + public static final int GLFW_MOD_CONTROL = 0x2; + + /** If this bit is set one or more Alt keys were held down. */ + public static final int GLFW_MOD_ALT = 0x4; + + /** If this bit is set one or more Super keys were held down. */ + public static final int GLFW_MOD_SUPER = 0x8; + + /** If this bit is set the Caps Lock key is enabled and the {@link #GLFW_LOCK_KEY_MODS LOCK_KEY_MODS} input mode is set. */ + public static final int GLFW_MOD_CAPS_LOCK = 0x10; + + /** If this bit is set the Num Lock key is enabled and the {@link #GLFW_LOCK_KEY_MODS LOCK_KEY_MODS} input mode is set. */ + public static final int GLFW_MOD_NUM_LOCK = 0x20; + + /** Mouse buttons. See mouse button input for how these are used. */ + public static final int + GLFW_MOUSE_BUTTON_1 = 0, + GLFW_MOUSE_BUTTON_2 = 1, + GLFW_MOUSE_BUTTON_3 = 2, + GLFW_MOUSE_BUTTON_4 = 3, + GLFW_MOUSE_BUTTON_5 = 4, + GLFW_MOUSE_BUTTON_6 = 5, + GLFW_MOUSE_BUTTON_7 = 6, + GLFW_MOUSE_BUTTON_8 = 7, + GLFW_MOUSE_BUTTON_LAST = GLFW_MOUSE_BUTTON_8, + GLFW_MOUSE_BUTTON_LEFT = GLFW_MOUSE_BUTTON_1, + GLFW_MOUSE_BUTTON_RIGHT = GLFW_MOUSE_BUTTON_2, + GLFW_MOUSE_BUTTON_MIDDLE = GLFW_MOUSE_BUTTON_3; + + /** Joysticks. See joystick input for how these are used. */ + public static final int + GLFW_JOYSTICK_1 = 0, + GLFW_JOYSTICK_2 = 1, + GLFW_JOYSTICK_3 = 2, + GLFW_JOYSTICK_4 = 3, + GLFW_JOYSTICK_5 = 4, + GLFW_JOYSTICK_6 = 5, + GLFW_JOYSTICK_7 = 6, + GLFW_JOYSTICK_8 = 7, + GLFW_JOYSTICK_9 = 8, + GLFW_JOYSTICK_10 = 9, + GLFW_JOYSTICK_11 = 10, + GLFW_JOYSTICK_12 = 11, + GLFW_JOYSTICK_13 = 12, + GLFW_JOYSTICK_14 = 13, + GLFW_JOYSTICK_15 = 14, + GLFW_JOYSTICK_16 = 15, + GLFW_JOYSTICK_LAST = GLFW_JOYSTICK_16; + + /** Gamepad buttons. See gamepad for how these are used. */ + public static final int + GLFW_GAMEPAD_BUTTON_A = 0, + GLFW_GAMEPAD_BUTTON_B = 1, + GLFW_GAMEPAD_BUTTON_X = 2, + GLFW_GAMEPAD_BUTTON_Y = 3, + GLFW_GAMEPAD_BUTTON_LEFT_BUMPER = 4, + GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER = 5, + GLFW_GAMEPAD_BUTTON_BACK = 6, + GLFW_GAMEPAD_BUTTON_START = 7, + GLFW_GAMEPAD_BUTTON_GUIDE = 8, + GLFW_GAMEPAD_BUTTON_LEFT_THUMB = 9, + GLFW_GAMEPAD_BUTTON_RIGHT_THUMB = 10, + GLFW_GAMEPAD_BUTTON_DPAD_UP = 11, + GLFW_GAMEPAD_BUTTON_DPAD_RIGHT = 12, + GLFW_GAMEPAD_BUTTON_DPAD_DOWN = 13, + GLFW_GAMEPAD_BUTTON_DPAD_LEFT = 14, + GLFW_GAMEPAD_BUTTON_LAST = GLFW_GAMEPAD_BUTTON_DPAD_LEFT, + GLFW_GAMEPAD_BUTTON_CROSS = GLFW_GAMEPAD_BUTTON_A, + GLFW_GAMEPAD_BUTTON_CIRCLE = GLFW_GAMEPAD_BUTTON_B, + GLFW_GAMEPAD_BUTTON_SQUARE = GLFW_GAMEPAD_BUTTON_X, + GLFW_GAMEPAD_BUTTON_TRIANGLE = GLFW_GAMEPAD_BUTTON_Y; + + /** Gamepad axes. See gamepad for how these are used. */ + public static final int + GLFW_GAMEPAD_AXIS_LEFT_X = 0, + GLFW_GAMEPAD_AXIS_LEFT_Y = 1, + GLFW_GAMEPAD_AXIS_RIGHT_X = 2, + GLFW_GAMEPAD_AXIS_RIGHT_Y = 3, + GLFW_GAMEPAD_AXIS_LEFT_TRIGGER = 4, + GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER = 5, + GLFW_GAMEPAD_AXIS_LAST = GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER; + + /** + * Error codes. + * + *This occurs if a GLFW function was called that may not be called unless the library is initialized.
+ *This occurs if a GLFW function was called that needs and operates on the current OpenGL or OpenGL ES context but no context is current on the + * calling thread. One such function is {@link #glfwSwapInterval SwapInterval}.
+ *One of the arguments to the function was an invalid enum value, for example requesting {@link #GLFW_RED_BITS RED_BITS} with {@link #glfwGetWindowAttrib GetWindowAttrib}.
+ *One of the arguments to the function was an invalid value, for example requesting a non-existent OpenGL or OpenGL ES version like 2.7.
+ * + *Requesting a valid but unavailable OpenGL or OpenGL ES version will instead result in a {@link #GLFW_VERSION_UNAVAILABLE VERSION_UNAVAILABLE} error.
+ *A bug in GLFW or the underlying operating system. Report the bug to our issue tracker.
+ *The installed graphics driver does not support the requested API, or does not support it via the chosen context creation backend. Below are a few + * examples:
+ * + *Some pre-installed Windows graphics drivers do not support OpenGL. AMD only supports OpenGL ES via EGL, while Nvidia and Intel only support it via + * a WGL or GLX extension. macOS does not provide OpenGL ES at all. The Mesa EGL, OpenGL and OpenGL ES libraries do not interface with the Nvidia + * binary driver. Older graphics drivers do not support Vulkan.
+ *The machine does not support your requirements. If your application is sufficiently flexible, downgrade your requirements and try again. Otherwise, + * inform the user that their machine does not match your requirements.
+ * + *Future invalid OpenGL and OpenGL ES versions, for example OpenGL 4.8 if 5.0 comes out before the 4.x series gets that far, also fail with this + * error and not {@link #GLFW_INVALID_VALUE INVALID_VALUE}, because GLFW cannot know what future versions will exist.
+ *A bug or configuration error in GLFW, the underlying operating system or its drivers, or a lack of required resources. Report the issue to our + * issue tracker.
+ *If emitted during window creation, one or more hard constraints did not match any of the available pixel formats. If your application is + * sufficiently flexible, downgrade your requirements and try again. Otherwise, inform the user that their machine does not match your requirements.
+ * + *If emitted when querying the clipboard, ignore the error or report it to the user, as appropriate.
+ *A window that does not have an OpenGL or OpenGL ES context was passed to a function that requires it to have one.
+ * + *Application programmer error. Fix the offending call.
+ *{@code GetWindowAttrib}: Indicates whether the specified window has input focus.
+ *{@code GetWindowAttrib}: Indicates whether the specified window is resizable by the user.
+ *{@code GetWindowAttrib}: Indicates whether the specified window is visible. Window visibility can be controlled with {@link #glfwShowWindow ShowWindow} and {@link #glfwHideWindow HideWindow}.
+ *{@code GetWindowAttrib}: Indicates whether the specified window has decorations such as a border, a close widget, etc.
+ *{@code GetWindowAttrib}: Indicates whether the specified window is floating, also called topmost or always-on-top.
+ *{@code GetWindowAttrib}: Indicates whether the specified window is maximized, whether by the user or {@link #glfwMaximizeWindow MaximizeWindow}.
+ *{@code GetWindowAttrib}: Indicates whether input focuses on calling show window.
+ *{@code GetWindowAttrib}: Indicates the client API provided by the window's context; either {@link #GLFW_OPENGL_API OPENGL_API}, {@link #GLFW_OPENGL_ES_API OPENGL_ES_API} or {@link #GLFW_NO_API NO_API}.
+ *{@code GetWindowAttrib}: Indicate the client API major version of the window's context.
+ *{@code GetWindowAttrib}: Indicate the client API minor version of the window's context.
+ *{@code GetWindowAttrib}: Indicates the robustness strategy used by the context. This is {@link #GLFW_LOSE_CONTEXT_ON_RESET LOSE_CONTEXT_ON_RESET} or {@link #GLFW_NO_RESET_NOTIFICATION NO_RESET_NOTIFICATION} if the window's + * context supports robustness, or {@link #GLFW_NO_ROBUSTNESS NO_ROBUSTNESS} otherwise.
+ *{@code GetWindowAttrib}: Indicates if the window's context is an OpenGL forward-compatible one.
+ *{@code GetWindowAttrib}: Indicates if the window's context is an OpenGL debug context.
+ *{@code GetWindowAttrib}: Indicates the OpenGL profile used by the context. This is {@link #GLFW_OPENGL_CORE_PROFILE OPENGL_CORE_PROFILE} or {@link #GLFW_OPENGL_COMPAT_PROFILE OPENGL_COMPAT_PROFILE} if the context uses a + * known profile, or {@link #GLFW_OPENGL_ANY_PROFILE OPENGL_ANY_PROFILE} if the OpenGL profile is unknown or the context is an OpenGL ES context. Note that the returned profile may + * not match the profile bits of the context flags, as GLFW will try other means of detecting the profile when no bits are set.
+ *{@code GetWindowAttrib}: Indicates the context creation API used to create the window's context; either {@link #GLFW_NATIVE_CONTEXT_API NATIVE_CONTEXT_API} or {@link #GLFW_EGL_CONTEXT_API EGL_CONTEXT_API}.
+ *This hint only has an effect on platforms where screen coordinates and pixels always map 1:1 such as Windows and X11. On platforms like macOS the + * resolution of the framebuffer is changed independently of the window size.
+ *If this function fails, it calls {@link #glfwTerminate Terminate} before returning. If it succeeds, you should call {@link #glfwTerminate Terminate} before the application exits.
+ * + *Additional calls to this function after successful initialization but before termination will return {@link #GLFW_TRUE TRUE} immediately.
+ * + *If GLFW has been successfully initialized, this function should be called before the application exits. If initialization fails, there is no need to + * call this function, as it is called by {@link #glfwInit Init} before it returns failure.
+ * + *The values you set hints to are never reset by GLFW, but they only take effect during initialization. Once GLFW has been initialized, any values you + * set will be ignored until the library is terminated and initialized again.
+ * + *Some hints are platform specific. These may be set on any platform but they will only affect their specific platform. Other platforms will simply + * ignore them. Setting these hints requires no platform specific headers or functions.
+ * + *| {@link #GLFW_JOYSTICK_HAT_BUTTONS JOYSTICK_HAT_BUTTONS} | {@link #GLFW_COCOA_CHDIR_RESOURCES COCOA_CHDIR_RESOURCES} | {@link #GLFW_COCOA_MENUBAR COCOA_MENUBAR} |
Do not use the version string to parse the GLFW library version. The {@link #glfwGetVersion GetVersion} function already provides the version of the library binary + * in numerical format.
+ * + *This function returns and clears the error code of the last error that occurred on the calling thread and optionally a UTF-8 encoded human-readable + * description of it. If no error has occurred since the last call, it returns {@link #GLFW_NO_ERROR NO_ERROR} (zero), and the description pointer is set to {@code NULL}.
+ * + *The error code is set before the callback is called. Calling {@link #glfwGetError GetError} from the error callback will return the same value as the error code argument.
+ * + *The error callback is called on the thread where the error occurred. If you are using GLFW from multiple threads, your error callback needs to be + * written accordingly.
+ * + *Because the description string may have been generated specifically for that error, it is not guaranteed to be valid after the callback has returned. If + * you wish to use it after the callback returns, you need to make a copy.
+ * + *Once set, the error callback remains set even after the library has been terminated.
+ * + *The returned array is allocated and freed by GLFW. You should not free it yourself. It is guaranteed to be valid only until the monitor configuration + * changes or the library is terminated.
+ * + *This function must only be called from the main thread.
+ * + * @return an array of monitor handlers, or {@code NULL} if no monitors were found or if an error occurred + * + * @since version 3.0 + */ + @Nullable + @NativeType("GLFWmonitor **") + public static PointerBuffer glfwGetMonitors() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + IntBuffer count = stack.callocInt(1); + try { + long __result = nglfwGetMonitors(memAddress(count)); + return memPointerBufferSafe(__result, count.get(0)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glfwGetPrimaryMonitor ] --- + + /** + * Returns the primary monitor. This is usually the monitor where elements like the task bar or global menu bar are located. + * + *This function must only be called from the main thread.
+ * + *The primary monitor is always first in the array returned by {@link #glfwGetMonitors GetMonitors}.
+ * + * @return the primary monitor, or {@code NULL} if no monitors were found or if an error occurred + * + * @since version 3.0 + */ + @NativeType("GLFWmonitor *") + public static long glfwGetPrimaryMonitor() { + long __functionAddress = Functions.GetPrimaryMonitor; + return invokeP(__functionAddress); + } + + // --- [ glfwGetMonitorPos ] --- + + /** Unsafe version of: {@link #glfwGetMonitorPos GetMonitorPos} */ + public static void nglfwGetMonitorPos(long monitor, long xpos, long ypos) { + long __functionAddress = Functions.GetMonitorPos; + if (CHECKS) { + check(monitor); + } + invokePPPV(monitor, xpos, ypos, __functionAddress); + } + + /** + * Returns the position, in screen coordinates, of the upper-left corner of the specified monitor. + * + *Any or all of the position arguments may be {@code NULL}. If an error occurs, all non-{@code NULL} position arguments will be set to zero.
+ * + *This function must only be called from the main thread.
+ * + * @param monitor the monitor to query + * @param xpos where to store the monitor x-coordinate, or {@code NULL} + * @param ypos where to store the monitor y-coordinate, or {@code NULL} + * + * @since version 3.0 + */ + public static void glfwGetMonitorPos(@NativeType("GLFWmonitor *") long monitor, @Nullable @NativeType("int *") IntBuffer xpos, @Nullable @NativeType("int *") IntBuffer ypos) { + if (CHECKS) { + checkSafe(xpos, 1); + checkSafe(ypos, 1); + } + nglfwGetMonitorPos(monitor, memAddressSafe(xpos), memAddressSafe(ypos)); + } + + // --- [ glfwGetMonitorWorkarea ] --- + + /** Unsafe version of: {@link #glfwGetMonitorWorkarea GetMonitorWorkarea} */ + public static void nglfwGetMonitorWorkarea(long monitor, long xpos, long ypos, long width, long height) { + long __functionAddress = Functions.GetMonitorWorkarea; + if (CHECKS) { + check(monitor); + } + invokePPPPPV(monitor, xpos, ypos, width, height, __functionAddress); + } + + /** + * Retrieves the work area of the monitor. + * + *This function returns the position, in screen coordinates, of the upper-left corner of the work area of the specified monitor along with the work area + * size in screen coordinates. The work area is defined as the area of the monitor not occluded by the operating system task bar where present. If no task + * bar exists then the work area is the monitor resolution in screen coordinates.
+ * + *Any or all of the position and size arguments may be {@code NULL}. If an error occurs, all non-{@code NULL} position and size arguments will be set to zero.
+ * + *This function must only be called from the main thread.
+ * + * @param monitor the monitor to query + * @param xpos where to store the working area x-coordinate, or {@code NULL} + * @param ypos where to store the working area y-coordinate, or {@code NULL} + * @param width where to store the working area width, or {@code NULL} + * @param height where to store the working area height, or {@code NULL} + * + * @since version 3.3 + */ + public static void glfwGetMonitorWorkarea(@NativeType("GLFWmonitor *") long monitor, @Nullable @NativeType("int *") IntBuffer xpos, @Nullable @NativeType("int *") IntBuffer ypos, @Nullable @NativeType("int *") IntBuffer width, @Nullable @NativeType("int *") IntBuffer height) { + if (CHECKS) { + checkSafe(xpos, 1); + checkSafe(ypos, 1); + checkSafe(width, 1); + checkSafe(height, 1); + } + nglfwGetMonitorWorkarea(monitor, memAddressSafe(xpos), memAddressSafe(ypos), memAddressSafe(width), memAddressSafe(height)); + } + + // --- [ glfwGetMonitorPhysicalSize ] --- + + /** Unsafe version of: {@link #glfwGetMonitorPhysicalSize GetMonitorPhysicalSize} */ + public static void nglfwGetMonitorPhysicalSize(long monitor, long widthMM, long heightMM) { + long __functionAddress = Functions.GetMonitorPhysicalSize; + if (CHECKS) { + check(monitor); + } + invokePPPV(monitor, widthMM, heightMM, __functionAddress); + } + + /** + * Returns the size, in millimetres, of the display area of the specified monitor. + * + *Some systems do not provide accurate monitor size information, either because the monitor + * EDID data is incorrect or because the driver does not report it + * accurately.
+ * + *Any or all of the size arguments may be {@code NULL}. If an error occurs, all non-{@code NULL} size arguments will be set to zero.
+ * + *This function retrieves the content scale for the specified monitor. The content scale is the ratio between the current DPI and the platform's default + * DPI. This is especially important for text and any UI elements. If the pixel dimensions of your UI scaled by this look appropriate on your machine then + * it should appear at a reasonable size on other machines regardless of their DPI and scaling settings. This relies on the system DPI and scaling + * settings being somewhat correct.
+ * + *The content scale may depend on both the monitor resolution and pixel density and on user settings. It may be very different from the raw DPI + * calculated from the physical size and current resolution.
+ * + *This function must only be called from the main thread.
+ * + * @param monitor the monitor to query + * @param xscale where to store the x-axis content scale, or {@code NULL} + * @param yscale where to store the y-axis content scale, or {@code NULL} + * + * @since version 3.3 + */ + public static void glfwGetMonitorContentScale(@NativeType("GLFWmonitor *") long monitor, @Nullable @NativeType("float *") FloatBuffer xscale, @Nullable @NativeType("float *") FloatBuffer yscale) { + if (CHECKS) { + checkSafe(xscale, 1); + checkSafe(yscale, 1); + } + nglfwGetMonitorContentScale(monitor, memAddressSafe(xscale), memAddressSafe(yscale)); + } + + // --- [ glfwGetMonitorName ] --- + + /** Unsafe version of: {@link #glfwGetMonitorName GetMonitorName} */ + public static long nglfwGetMonitorName(long monitor) { + long __functionAddress = Functions.GetMonitorName; + if (CHECKS) { + check(monitor); + } + return invokePP(monitor, __functionAddress); + } + + /** + * Returns a human-readable name, encoded as UTF-8, of the specified monitor. The name typically reflects the make and model of the monitor and is not + * guaranteed to be unique among the connected monitors. + * + *The returned string is allocated and freed by GLFW. You should not free it yourself. It is valid until the specified monitor is disconnected or the + * library is terminated.
+ * + *This function must only be called from the main thread.
+ * + * @param monitor the monitor to query + * + * @return the UTF-8 encoded name of the monitor, or {@code NULL} if an error occurred + * + * @since version 3.0 + */ + @Nullable + @NativeType("char const *") + public static String glfwGetMonitorName(@NativeType("GLFWmonitor *") long monitor) { + long __result = nglfwGetMonitorName(monitor); + return memUTF8Safe(__result); + } + + // --- [ glfwSetMonitorUserPointer ] --- + + /** + * Sets the user pointer of the specified monitor. + * + *This function sets the user-defined pointer of the specified monitor. The current value is retained until the monitor is disconnected. The initial + * value is {@code NULL}.
+ * + *This function may be called from the monitor callback, even for a monitor that is being disconnected.
+ * + *This function may be called from any thread. Access is not synchronized.
+ * + * @param monitor the monitor whose pointer to set + * @param pointer the new value + * + * @since version 3.3 + */ + public static void glfwSetMonitorUserPointer(@NativeType("GLFWmonitor *") long monitor, @NativeType("void *") long pointer) { + long __functionAddress = Functions.SetMonitorUserPointer; + if (CHECKS) { + check(monitor); + check(pointer); + } + invokePPV(monitor, pointer, __functionAddress); + } + + // --- [ glfwGetMonitorUserPointer ] --- + + /** + * Returns the user pointer of the specified monitor. + * + *This function returns the current value of the user-defined pointer of the specified monitor. The initial value is {@code NULL}.
+ * + *This function may be called from the monitor callback, even for a monitor that is being disconnected.
+ * + *This function may be called from any thread. Access is not synchronized.
+ * + * @param monitor the monitor whose pointer to return + * + * @since version 3.3 + */ + @NativeType("void *") + public static long glfwGetMonitorUserPointer(@NativeType("GLFWmonitor *") long monitor) { + long __functionAddress = Functions.GetMonitorUserPointer; + if (CHECKS) { + check(monitor); + } + return invokePP(monitor, __functionAddress); + } + + // --- [ glfwSetMonitorCallback ] --- + + /** Unsafe version of: {@link #glfwSetMonitorCallback SetMonitorCallback} */ + public static long nglfwSetMonitorCallback(long cbfun) { + long __functionAddress = Functions.SetMonitorCallback; + return invokePP(cbfun, __functionAddress); + } + + /** + * Sets the monitor configuration callback, or removes the currently set callback. This is called when a monitor is connected to or disconnected from the + * system. + * + *This function must only be called from the main thread.
+ * + * @param cbfun the new callback, or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set or the library had not been initialized + * + * @since version 3.0 + */ + @Nullable + @NativeType("GLFWmonitorfun") + public static GLFWMonitorCallback glfwSetMonitorCallback(@Nullable @NativeType("GLFWmonitorfun") GLFWMonitorCallbackI cbfun) { + return GLFWMonitorCallback.createSafe(nglfwSetMonitorCallback(memAddressSafe(cbfun))); + } + + // --- [ glfwGetVideoModes ] --- + + /** + * Unsafe version of: {@link #glfwGetVideoModes GetVideoModes} + * + * @param count where to store the number of video modes in the returned array. This is set to zero if an error occurred. + */ + public static long nglfwGetVideoModes(long monitor, long count) { + long __functionAddress = Functions.GetVideoModes; + if (CHECKS) { + check(monitor); + } + return invokePPP(monitor, count, __functionAddress); + } + + /** + * Returns an array of all video modes supported by the specified monitor. The returned array is sorted in ascending order, first by color bit depth (the + * sum of all channel depths) and then by resolution area (the product of width and height). + * + *The returned array is allocated and freed by GLFW. You should not free it yourself. It is valid until the specified monitor is disconnected, this + * function is called again for that monitor or the library is terminated.
+ * + *This function must only be called from the main thread.
+ * + * @param monitor the monitor to query + * + * @return an array of video modes, or {@code NULL} if an error occurred + * + * @since version 1.0 + */ + @Nullable + @NativeType("GLFWvidmode const *") + public static GLFWVidMode.Buffer glfwGetVideoModes(@NativeType("GLFWmonitor *") long monitor) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + IntBuffer count = stack.callocInt(1); + try { + long __result = nglfwGetVideoModes(monitor, memAddress(count)); + return GLFWVidMode.createSafe(__result, count.get(0)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glfwGetVideoMode ] --- + + /** Unsafe version of: {@link #glfwGetVideoMode GetVideoMode} */ + public static long nglfwGetVideoMode(long monitor) { + long __functionAddress = Functions.GetVideoMode; + if (CHECKS) { + check(monitor); + } + return invokePP(monitor, __functionAddress); + } + + /** + * Returns the current video mode of the specified monitor. If you have created a full screen window for that monitor, the return value will depend on + * whether that window is iconified. + * + *The returned array is allocated and freed by GLFW. You should not free it yourself. It is valid until the specified monitor is disconnected or the + * library is terminated.
+ * + *This function must only be called from the main thread.
+ * + * @param monitor the monitor to query + * + * @return the current mode of the monitor, or {@code NULL} if an error occurred + * + * @since version 3.0 + */ + @Nullable + @NativeType("GLFWvidmode const *") + public static GLFWVidMode glfwGetVideoMode(@NativeType("GLFWmonitor *") long monitor) { +// long __result = nglfwGetVideoMode(monitor); + return glfwVidMode; + } + + // --- [ glfwSetGamma ] --- + + /** + * Generates a gamma ramp and sets it for the specified monitor. + * + *This function generates an appropriately sized gamma ramp from the specified exponent and then calls {@link #glfwSetGammaRamp SetGammaRamp} with it. The value must be a + * finite number greater than zero.
+ * + *The software controlled gamma ramp is applied in addition to the hardware gamma correction, which today is usually an approximation of sRGB + * gamma. This means that setting a perfectly linear ramp, or gamma 1.0, will produce the default (usually sRGB-like) behavior.
+ * + *For gamma correct rendering with OpenGL or OpenGL ES, see the {@link #GLFW_SRGB_CAPABLE SRGB_CAPABLE} hint.
+ * + *Notes:
+ * + *The returned structure and its arrays are allocated and freed by GLFW. You should not free them yourself. They are valid until the specified monitor is + * disconnected, this function is called again for that monitor or the library is terminated.
+ * + *Notes:
+ * + *This function sets the current gamma ramp for the specified monitor. The original gamma ramp for that monitor is saved by GLFW the first time this + * function is called and is restored by {@link #glfwTerminate Terminate}.
+ * + *The software controlled gamma ramp is applied in addition to the hardware gamma correction, which today is usually an approximation of sRGB + * gamma. This means that setting a perfectly linear ramp, or gamma 1.0, will produce the default (usually sRGB-like) behavior.
+ * + *For gamma correct rendering with OpenGL or OpenGL ES, see the {@link #GLFW_SRGB_CAPABLE SRGB_CAPABLE} hint.
+ * + *This function must only be called from the main thread.
+ * + * @since version 3.0 + */ + public static void glfwDefaultWindowHints() { + long __functionAddress = Functions.DefaultWindowHints; + invokeV(__functionAddress); + } + + // --- [ glfwWindowHint ] --- + + /** + * Sets hints for the next call to {@link #glfwCreateWindow CreateWindow}. The hints, once set, retain their values until changed by a call to this function or + * {@link #glfwDefaultWindowHints DefaultWindowHints}, or until the library is terminated. + * + *Only integer value hints can be set with this function. String value hints are set with {@link #glfwWindowHintString WindowHintString}.
+ * + *This function does not check whether the specified hint values are valid. If you set hints to invalid values this will instead be reported by the next + * call to {@link #glfwCreateWindow CreateWindow}.
+ * + *Some hints are platform specific. These may be set on any platform but they will only affect their specific platform. Other platforms will ignore them. + * Setting these hints requires no platform specific headers or functions.
+ * + *| Name | Default value | Supported values |
|---|---|---|
| {@link #GLFW_RESIZABLE RESIZABLE} | {@link #GLFW_TRUE TRUE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_VISIBLE VISIBLE} | {@link #GLFW_TRUE TRUE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_DECORATED DECORATED} | {@link #GLFW_TRUE TRUE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_FOCUSED FOCUSED} | {@link #GLFW_TRUE TRUE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_AUTO_ICONIFY AUTO_ICONIFY} | {@link #GLFW_TRUE TRUE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_FLOATING FLOATING} | {@link #GLFW_FALSE FALSE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_MAXIMIZED MAXIMIZED} | {@link #GLFW_FALSE FALSE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_CENTER_CURSOR CENTER_CURSOR} | {@link #GLFW_TRUE TRUE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_TRANSPARENT_FRAMEBUFFER TRANSPARENT_FRAMEBUFFER} | {@link #GLFW_FALSE FALSE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_FOCUS_ON_SHOW FOCUS_ON_SHOW} | {@link #GLFW_TRUE TRUE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_SCALE_TO_MONITOR SCALE_TO_MONITOR} | {@link #GLFW_FALSE FALSE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_RED_BITS RED_BITS} | 8 | 0 to {@link Integer#MAX_VALUE} or {@link #GLFW_DONT_CARE DONT_CARE} |
| {@link #GLFW_GREEN_BITS GREEN_BITS} | 8 | 0 to {@link Integer#MAX_VALUE} or {@link #GLFW_DONT_CARE DONT_CARE} |
| {@link #GLFW_BLUE_BITS BLUE_BITS} | 8 | 0 to {@link Integer#MAX_VALUE} or {@link #GLFW_DONT_CARE DONT_CARE} |
| {@link #GLFW_ALPHA_BITS ALPHA_BITS} | 8 | 0 to {@link Integer#MAX_VALUE} or {@link #GLFW_DONT_CARE DONT_CARE} |
| {@link #GLFW_DEPTH_BITS DEPTH_BITS} | 24 | 0 to {@link Integer#MAX_VALUE} or {@link #GLFW_DONT_CARE DONT_CARE} |
| {@link #GLFW_STENCIL_BITS STENCIL_BITS} | 8 | 0 to {@link Integer#MAX_VALUE} or {@link #GLFW_DONT_CARE DONT_CARE} |
| {@link #GLFW_ACCUM_RED_BITS ACCUM_RED_BITS} | 0 | 0 to {@link Integer#MAX_VALUE} or {@link #GLFW_DONT_CARE DONT_CARE} |
| {@link #GLFW_ACCUM_GREEN_BITS ACCUM_GREEN_BITS} | 0 | 0 to {@link Integer#MAX_VALUE} or {@link #GLFW_DONT_CARE DONT_CARE} |
| {@link #GLFW_ACCUM_BLUE_BITS ACCUM_BLUE_BITS} | 0 | 0 to {@link Integer#MAX_VALUE} or {@link #GLFW_DONT_CARE DONT_CARE} |
| {@link #GLFW_ACCUM_ALPHA_BITS ACCUM_ALPHA_BITS} | 0 | 0 to {@link Integer#MAX_VALUE} or {@link #GLFW_DONT_CARE DONT_CARE} |
| {@link #GLFW_AUX_BUFFERS AUX_BUFFERS} | 0 | 0 to {@link Integer#MAX_VALUE} |
| {@link #GLFW_SAMPLES SAMPLES} | 0 | 0 to {@link Integer#MAX_VALUE} |
| {@link #GLFW_REFRESH_RATE REFRESH_RATE} | {@link #GLFW_DONT_CARE DONT_CARE} | 0 to {@link Integer#MAX_VALUE} or {@link #GLFW_DONT_CARE DONT_CARE} |
| {@link #GLFW_STEREO STEREO} | {@link #GLFW_FALSE FALSE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_SRGB_CAPABLE SRGB_CAPABLE} | {@link #GLFW_FALSE FALSE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_DOUBLEBUFFER DOUBLEBUFFER} | {@link #GLFW_TRUE TRUE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_CLIENT_API CLIENT_API} | {@link #GLFW_OPENGL_API OPENGL_API} | {@link #GLFW_NO_API NO_API} {@link #GLFW_OPENGL_API OPENGL_API} {@link #GLFW_OPENGL_ES_API OPENGL_ES_API} |
| {@link #GLFW_CONTEXT_CREATION_API CONTEXT_CREATION_API} | {@link #GLFW_NATIVE_CONTEXT_API NATIVE_CONTEXT_API} | {@link #GLFW_NATIVE_CONTEXT_API NATIVE_CONTEXT_API} {@link #GLFW_EGL_CONTEXT_API EGL_CONTEXT_API} {@link #GLFW_OSMESA_CONTEXT_API OSMESA_CONTEXT_API} |
| {@link #GLFW_CONTEXT_VERSION_MAJOR CONTEXT_VERSION_MAJOR} | 1 | Any valid major version number of the chosen client API |
| {@link #GLFW_CONTEXT_VERSION_MINOR CONTEXT_VERSION_MINOR} | 0 | Any valid minor version number of the chosen client API |
| {@link #GLFW_CONTEXT_ROBUSTNESS CONTEXT_ROBUSTNESS} | {@link #GLFW_NO_ROBUSTNESS NO_ROBUSTNESS} | {@link #GLFW_NO_ROBUSTNESS NO_ROBUSTNESS} {@link #GLFW_NO_RESET_NOTIFICATION NO_RESET_NOTIFICATION} {@link #GLFW_LOSE_CONTEXT_ON_RESET LOSE_CONTEXT_ON_RESET} |
| {@link #GLFW_CONTEXT_RELEASE_BEHAVIOR CONTEXT_RELEASE_BEHAVIOR} | {@link #GLFW_ANY_RELEASE_BEHAVIOR ANY_RELEASE_BEHAVIOR} | {@link #GLFW_ANY_RELEASE_BEHAVIOR ANY_RELEASE_BEHAVIOR} {@link #GLFW_RELEASE_BEHAVIOR_FLUSH RELEASE_BEHAVIOR_FLUSH} {@link #GLFW_RELEASE_BEHAVIOR_NONE RELEASE_BEHAVIOR_NONE} |
| {@link #GLFW_CONTEXT_NO_ERROR CONTEXT_NO_ERROR} | {@link #GLFW_FALSE FALSE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_OPENGL_FORWARD_COMPAT OPENGL_FORWARD_COMPAT} | {@link #GLFW_FALSE FALSE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_OPENGL_DEBUG_CONTEXT OPENGL_DEBUG_CONTEXT} | {@link #GLFW_FALSE FALSE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_OPENGL_PROFILE OPENGL_PROFILE} | {@link #GLFW_OPENGL_ANY_PROFILE OPENGL_ANY_PROFILE} | {@link #GLFW_OPENGL_ANY_PROFILE OPENGL_ANY_PROFILE} {@link #GLFW_OPENGL_CORE_PROFILE OPENGL_CORE_PROFILE} {@link #GLFW_OPENGL_COMPAT_PROFILE OPENGL_COMPAT_PROFILE} |
| {@link #GLFW_COCOA_RETINA_FRAMEBUFFER COCOA_RETINA_FRAMEBUFFER} | {@link #GLFW_TRUE TRUE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
| {@link #GLFW_COCOA_GRAPHICS_SWITCHING COCOA_GRAPHICS_SWITCHING} | {@link #GLFW_FALSE FALSE} | {@link #GLFW_TRUE TRUE} or {@link #GLFW_FALSE FALSE} |
This function must only be called from the main thread.
+ * + * @param hint the window hint to set. One of:| {@link #GLFW_FOCUSED FOCUSED} | {@link #GLFW_RESIZABLE RESIZABLE} | {@link #GLFW_VISIBLE VISIBLE} | {@link #GLFW_DECORATED DECORATED} | {@link #GLFW_AUTO_ICONIFY AUTO_ICONIFY} |
| {@link #GLFW_FLOATING FLOATING} | {@link #GLFW_MAXIMIZED MAXIMIZED} | {@link #GLFW_CENTER_CURSOR CENTER_CURSOR} | {@link #GLFW_TRANSPARENT_FRAMEBUFFER TRANSPARENT_FRAMEBUFFER} | {@link #GLFW_FOCUS_ON_SHOW FOCUS_ON_SHOW} |
| {@link #GLFW_CLIENT_API CLIENT_API} | {@link #GLFW_CONTEXT_VERSION_MAJOR CONTEXT_VERSION_MAJOR} | {@link #GLFW_CONTEXT_VERSION_MINOR CONTEXT_VERSION_MINOR} | {@link #GLFW_CONTEXT_ROBUSTNESS CONTEXT_ROBUSTNESS} | {@link #GLFW_OPENGL_FORWARD_COMPAT OPENGL_FORWARD_COMPAT} |
| {@link #GLFW_OPENGL_DEBUG_CONTEXT OPENGL_DEBUG_CONTEXT} | {@link #GLFW_OPENGL_PROFILE OPENGL_PROFILE} | {@link #GLFW_CONTEXT_RELEASE_BEHAVIOR CONTEXT_RELEASE_BEHAVIOR} | {@link #GLFW_CONTEXT_NO_ERROR CONTEXT_NO_ERROR} | {@link #GLFW_CONTEXT_CREATION_API CONTEXT_CREATION_API} |
| {@link #GLFW_SCALE_TO_MONITOR SCALE_TO_MONITOR} | {@link #GLFW_RED_BITS RED_BITS} | {@link #GLFW_GREEN_BITS GREEN_BITS} | {@link #GLFW_BLUE_BITS BLUE_BITS} | {@link #GLFW_ALPHA_BITS ALPHA_BITS} |
| {@link #GLFW_DEPTH_BITS DEPTH_BITS} | {@link #GLFW_STENCIL_BITS STENCIL_BITS} | {@link #GLFW_ACCUM_RED_BITS ACCUM_RED_BITS} | {@link #GLFW_ACCUM_GREEN_BITS ACCUM_GREEN_BITS} | {@link #GLFW_ACCUM_BLUE_BITS ACCUM_BLUE_BITS} |
| {@link #GLFW_ACCUM_ALPHA_BITS ACCUM_ALPHA_BITS} | {@link #GLFW_AUX_BUFFERS AUX_BUFFERS} | {@link #GLFW_STEREO STEREO} | {@link #GLFW_SAMPLES SAMPLES} | {@link #GLFW_SRGB_CAPABLE SRGB_CAPABLE} |
| {@link #GLFW_REFRESH_RATE REFRESH_RATE} | {@link #GLFW_DOUBLEBUFFER DOUBLEBUFFER} | {@link #GLFW_COCOA_RETINA_FRAMEBUFFER COCOA_RETINA_FRAMEBUFFER} | {@link #GLFW_COCOA_GRAPHICS_SWITCHING COCOA_GRAPHICS_SWITCHING} |
This function sets hints for the next call to {@link #glfwCreateWindow CreateWindow}. The hints, once set, retain their values until changed by a call to this function or + * {@link #glfwDefaultWindowHints DefaultWindowHints}, or until the library is terminated.
+ * + *Only string type hints can be set with this function. Integer value hints are set with {@link #glfwWindowHint WindowHint}.
+ * + *This function does not check whether the specified hint values are valid. If you set hints to invalid values this will instead be reported by the next + * call to {@link #glfwCreateWindow CreateWindow}.
+ * + *Some hints are platform specific. These may be set on any platform but they will only affect their specific platform. Other platforms will ignore them. + * Setting these hints requires no platform specific headers or functions.
+ * + *| Name | Default value | Supported values |
|---|---|---|
| {@link #GLFW_COCOA_FRAME_NAME COCOA_FRAME_NAME} | "" | A UTF-8 encoded frame autosave name |
| {@link #GLFW_X11_CLASS_NAME X11_CLASS_NAME} | "" | An ASCII encoded {@code WM_CLASS} class name |
| {@link #GLFW_X11_INSTANCE_NAME X11_INSTANCE_NAME} | "" | An ASCII encoded {@code WM_CLASS} instance name |
This function must only be called from the main thread.
+ * + * @param hint the window hint to set. One of:| {@link #GLFW_COCOA_FRAME_NAME COCOA_FRAME_NAME} | {@link #GLFW_X11_CLASS_NAME X11_CLASS_NAME} | {@link #GLFW_X11_INSTANCE_NAME X11_INSTANCE_NAME} |
This function sets hints for the next call to {@link #glfwCreateWindow CreateWindow}. The hints, once set, retain their values until changed by a call to this function or + * {@link #glfwDefaultWindowHints DefaultWindowHints}, or until the library is terminated.
+ * + *Only string type hints can be set with this function. Integer value hints are set with {@link #glfwWindowHint WindowHint}.
+ * + *This function does not check whether the specified hint values are valid. If you set hints to invalid values this will instead be reported by the next + * call to {@link #glfwCreateWindow CreateWindow}.
+ * + *Some hints are platform specific. These may be set on any platform but they will only affect their specific platform. Other platforms will ignore them. + * Setting these hints requires no platform specific headers or functions.
+ * + *| Name | Default value | Supported values |
|---|---|---|
| {@link #GLFW_COCOA_FRAME_NAME COCOA_FRAME_NAME} | "" | A UTF-8 encoded frame autosave name |
| {@link #GLFW_X11_CLASS_NAME X11_CLASS_NAME} | "" | An ASCII encoded {@code WM_CLASS} class name |
| {@link #GLFW_X11_INSTANCE_NAME X11_INSTANCE_NAME} | "" | An ASCII encoded {@code WM_CLASS} instance name |
This function must only be called from the main thread.
+ * + * @param hint the window hint to set. One of:| {@link #GLFW_COCOA_FRAME_NAME COCOA_FRAME_NAME} | {@link #GLFW_X11_CLASS_NAME X11_CLASS_NAME} | {@link #GLFW_X11_INSTANCE_NAME X11_INSTANCE_NAME} |
Successful creation does not change which context is current. Before you can use the newly created context, you need to make it current. For information + * about the {@code share} parameter, see context sharing.
+ * + *The created window, framebuffer and context may differ from what you requested, as not all parameters and hints are hard constraints. This includes the + * size of the window, especially for full screen windows. To query the actual attributes of the created window, framebuffer and context, use queries like + * {@link #glfwGetWindowAttrib GetWindowAttrib} and {@link #glfwGetWindowSize GetWindowSize} and {@link #glfwGetFramebufferSize GetFramebufferSize}.
+ * + *To create a full screen window, you need to specify the monitor the window will cover. If no monitor is specified, the window will be windowed mode. + * Unless you have a way for the user to choose a specific monitor, it is recommended that you pick the primary monitor. For more information on how to + * query connected monitors, see monitors.
+ * + *For full screen windows, the specified size becomes the resolution of the window's desired video mode. As long as a full screen window is not + * iconified, the supported video mode most closely matching the desired video mode is set for the specified monitor. For more information about full + * screen windows, including the creation of so called windowed full screen or borderless full screen windows, see + * full screen.
+ * + *Once you have created the window, you can switch it between windowed and full screen mode with {@link #glfwSetWindowMonitor SetWindowMonitor}. If the window has an OpenGL or + * OpenGL ES context, it will be unaffected.
+ * + *By default, newly created windows use the placement recommended by the window system. To create the window at a specific position, make it initially + * invisible using the {@link #GLFW_VISIBLE VISIBLE} window hint, set its position and then + * show it.
+ * + *As long as at least one full screen window is not iconified, the screensaver is prohibited from starting.
+ * + *Window systems put limits on window sizes. Very large or very small window dimensions may be overridden by the window system on creation. Check the + * actual size after creation.
+ * + *The swap interval is not set during window creation and the initial value may vary + * depending on driver settings and defaults.
+ * + *Successful creation does not change which context is current. Before you can use the newly created context, you need to make it current. For information + * about the {@code share} parameter, see context sharing.
+ * + *The created window, framebuffer and context may differ from what you requested, as not all parameters and hints are hard constraints. This includes the + * size of the window, especially for full screen windows. To query the actual attributes of the created window, framebuffer and context, use queries like + * {@link #glfwGetWindowAttrib GetWindowAttrib} and {@link #glfwGetWindowSize GetWindowSize} and {@link #glfwGetFramebufferSize GetFramebufferSize}.
+ * + *To create a full screen window, you need to specify the monitor the window will cover. If no monitor is specified, the window will be windowed mode. + * Unless you have a way for the user to choose a specific monitor, it is recommended that you pick the primary monitor. For more information on how to + * query connected monitors, see monitors.
+ * + *For full screen windows, the specified size becomes the resolution of the window's desired video mode. As long as a full screen window is not + * iconified, the supported video mode most closely matching the desired video mode is set for the specified monitor. For more information about full + * screen windows, including the creation of so called windowed full screen or borderless full screen windows, see + * full screen.
+ * + *Once you have created the window, you can switch it between windowed and full screen mode with {@link #glfwSetWindowMonitor SetWindowMonitor}. If the window has an OpenGL or + * OpenGL ES context, it will be unaffected.
+ * + *By default, newly created windows use the placement recommended by the window system. To create the window at a specific position, make it initially + * invisible using the {@link #GLFW_VISIBLE VISIBLE} window hint, set its position and then + * show it.
+ * + *As long as at least one full screen window is not iconified, the screensaver is prohibited from starting.
+ * + *Window systems put limits on window sizes. Very large or very small window dimensions may be overridden by the window system on creation. Check the + * actual size after creation.
+ * + *The swap interval is not set during window creation and the initial value may vary + * depending on driver settings and defaults.
+ * + *If the context of the specified window is current on the main thread, it is detached before being destroyed.
+ * + *This function may be called from any thread.
+ * + * @param window the window to query + * + * @return the value of the close flag + * + * @since version 3.0 + */ + @NativeType("int") + public static boolean glfwWindowShouldClose(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.WindowShouldClose; + if (CHECKS) { + check(window); + } + return invokePI(window, __functionAddress) != 0; + } + + // --- [ glfwSetWindowShouldClose ] --- + + /** + * Sets the value of the close flag of the specified window. This can be used to override the user's attempt to close the window, or to signal that it + * should be closed. + * + *This function may be called from any thread. Access is not synchronized.
+ * + * @param window the window whose flag to change + * @param value the new value + * + * @since version 3.0 + */ + public static void glfwSetWindowShouldClose(@NativeType("GLFWwindow *") long window, @NativeType("int") boolean value) { + long __functionAddress = Functions.SetWindowShouldClose; + if (CHECKS) { + check(window); + } + invokePV(window, value ? 1 : 0, __functionAddress); + } + + // --- [ glfwSetWindowTitle ] --- + + /** Unsafe version of: {@link #glfwSetWindowTitle SetWindowTitle} */ + public static void nglfwSetWindowTitle(long window, long title) { + long __functionAddress = Functions.SetWindowTitle; + if (CHECKS) { + check(window); + } + invokePPV(window, title, __functionAddress); + } + + /** + * Sets the window title, encoded as UTF-8, of the specified window. + * + *This function must only be called from the main thread.
+ * + *macOS: The window title will not be updated until the next time you process events.
+ * + * @param window the window whose title to change + * @param title the UTF-8 encoded window title + * + * @since version 1.0 + */ + public static void glfwSetWindowTitle(@NativeType("GLFWwindow *") long window, @NativeType("char const *") ByteBuffer title) { + if (CHECKS) { + checkNT1(title); + } + nglfwSetWindowTitle(window, memAddress(title)); + } + + /** + * Sets the window title, encoded as UTF-8, of the specified window. + * + *This function must only be called from the main thread.
+ * + *macOS: The window title will not be updated until the next time you process events.
+ * + * @param window the window whose title to change + * @param title the UTF-8 encoded window title + * + * @since version 1.0 + */ + public static void glfwSetWindowTitle(@NativeType("GLFWwindow *") long window, @NativeType("char const *") CharSequence title) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8(title, true); + long titleEncoded = stack.getPointerAddress(); + nglfwSetWindowTitle(window, titleEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glfwSetWindowIcon ] --- + + /** + * Unsafe version of: {@link #glfwSetWindowIcon SetWindowIcon} + * + * @param count the number of images in the specified array, or zero to revert to the default window icon + */ + public static void nglfwSetWindowIcon(long window, int count, long images) { + long __functionAddress = Functions.SetWindowIcon; + if (CHECKS) { + check(window); + if (images != NULL) { GLFWImage.validate(images, count); } + } + invokePPV(window, count, images, __functionAddress); + } + + /** + * Sets the icon for the specified window. + * + *This function sets the icon of the specified window. If passed an array of candidate images, those of or closest to the sizes desired by the system are + * selected. If no images are specified, the window reverts to its default icon.
+ * + *The pixels are 32-bit, little-endian, non-premultiplied RGBA, i.e. eight bits per channel with the red channel first. They are arranged canonically as + * packed sequential rows, starting from the top-left corner.
+ * + *The desired image sizes varies depending on platform and system settings. The selected images will be rescaled as needed. Good sizes include 16x16, + * 32x32 and 48x48.
+ * + *Notes:
+ * + *Any or all of the position arguments may be {@code NULL}. If an error occurs, all non-{@code NULL} position arguments will be set to zero.
+ * + *Notes:
+ * + *Do not use this function to move an already visible window unless you have very good reasons for doing so, as it will confuse and annoy the + * user.
+ * + *The window manager may put limits on what positions are allowed. GLFW cannot and should not override these limits.
+ * + *Notes:
+ * + *Any or all of the size arguments may be {@code NULL}. If an error occurs, all non-{@code NULL} size arguments will be set to zero.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window whose size to retrieve + * @param width where to store the width, in screen coordinates, of the content area, or {@code NULL} + * @param height where to store the height, in screen coordinates, of the content area, or {@code NULL} + * + * @since version 1.0 + */ + public static void glfwGetWindowSize(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("int *") IntBuffer width, @Nullable @NativeType("int *") IntBuffer height) { + if (CHECKS) { + checkSafe(width, 1); + checkSafe(height, 1); + } + nglfwGetWindowSize(window, memAddressSafe(width), memAddressSafe(height)); + } + + // --- [ glfwSetWindowSizeLimits ] --- + + /** + * Sets the size limits of the content area of the specified window. If the window is full screen, the size limits only take effect if once it is made + * windowed. If the window is not resizable, this function does nothing. + * + *The size limits are applied immediately to a windowed mode window and may cause it to be resized.
+ * + *The maximum dimensions must be greater than or equal to the minimum dimensions and all must be greater than or equal to zero.
+ * + *Notes:
+ * + *The aspect ratio is specified as a numerator and a denominator and both values must be greater than zero. For example, the common 16:9 aspect ratio is + * specified as 16 and 9, respectively.
+ * + *If the numerator and denominator is set to {@link #GLFW_DONT_CARE DONT_CARE} then the aspect ratio limit is disabled.
+ * + *The aspect ratio is applied immediately to a windowed mode window and may cause it to be resized.
+ * + *Notes:
+ * + *For full screen windows, this function updates the resolution of its desired video mode and switches to the video mode closest to it, without affecting + * the window's context. As the context is unaffected, the bit depths of the framebuffer remain unchanged.
+ * + *If you wish to update the refresh rate of the desired video mode in addition to its resolution, see {@link #glfwSetWindowMonitor SetWindowMonitor}.
+ * + *The window manager may put limits on what sizes are allowed. GLFW cannot and should not override these limits.
+ * + *Notes:
+ * + *Any or all of the size arguments may be {@code NULL}. If an error occurs, all non-{@code NULL} size arguments will be set to zero.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window whose framebuffer to query + * @param width where to store the width, in pixels, of the framebuffer, or {@code NULL} + * @param height where to store the height, in pixels, of the framebuffer, or {@code NULL} + * + * @since version 3.0 + */ + public static void glfwGetFramebufferSize(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("int *") IntBuffer width, @Nullable @NativeType("int *") IntBuffer height) { + if (CHECKS) { + checkSafe(width, 1); + checkSafe(height, 1); + } + nglfwGetFramebufferSize(window, memAddressSafe(width), memAddressSafe(height)); + } + + // --- [ glfwGetWindowFrameSize ] --- + + /** Unsafe version of: {@link #glfwGetWindowFrameSize GetWindowFrameSize} */ + public static void nglfwGetWindowFrameSize(long window, long left, long top, long right, long bottom) { + long __functionAddress = Functions.GetWindowFrameSize; + if (CHECKS) { + check(window); + } + invokePPPPPV(window, left, top, right, bottom, __functionAddress); + } + + /** + * Retrieves the size, in screen coordinates, of each edge of the frame of the specified window. This size includes the title bar, if the window has one. + * The size of the frame may vary depending on the window-related hints used to + * create it. + * + *Because this function retrieves the size of each window frame edge and not the offset along a particular coordinate axis, the retrieved values will + * always be zero or positive.
+ * + *Any or all of the size arguments may be {@code NULL}. If an error occurs, all non-{@code NULL} size arguments will be set to zero.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window whose frame size to query + * @param left where to store the size, in screen coordinates, of the left edge of the window frame, or {@code NULL} + * @param top where to store the size, in screen coordinates, of the top edge of the window frame, or {@code NULL} + * @param right where to store the size, in screen coordinates, of the right edge of the window frame, or {@code NULL} + * @param bottom where to store the size, in screen coordinates, of the bottom edge of the window frame, or {@code NULL} + * + * @since version 3.1 + */ + public static void glfwGetWindowFrameSize(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("int *") IntBuffer left, @Nullable @NativeType("int *") IntBuffer top, @Nullable @NativeType("int *") IntBuffer right, @Nullable @NativeType("int *") IntBuffer bottom) { + if (CHECKS) { + checkSafe(left, 1); + checkSafe(top, 1); + checkSafe(right, 1); + checkSafe(bottom, 1); + } + nglfwGetWindowFrameSize(window, memAddressSafe(left), memAddressSafe(top), memAddressSafe(right), memAddressSafe(bottom)); + } + + // --- [ glfwGetWindowContentScale ] --- + + /** Unsafe version of: {@link #glfwGetWindowContentScale GetWindowContentScale} */ + public static void nglfwGetWindowContentScale(long window, long xscale, long yscale) { + long __functionAddress = Functions.GetWindowContentScale; + if (CHECKS) { + check(window); + } + invokePPPV(window, xscale, yscale, __functionAddress); + } + + /** + * Retrieves the content scale for the specified window. + * + *This function retrieves the content scale for the specified window. The content scale is the ratio between the current DPI and the platform's default + * DPI. This is especially important for text and any UI elements. If the pixel dimensions of your UI scaled by this look appropriate on your machine then + * it should appear at a reasonable size on other machines regardless of their DPI and scaling settings. This relies on the system DPI and scaling + * settings being somewhat correct.
+ * + *On systems where each monitor can have its own content scale, the window content scale will depend on which monitor the system considers the window to + * be on.
+ * + * @param window the window to query + * @param xscale where to store the x-axis content scale, or {@code NULL} + * @param yscale where to store the y-axis content scale, or {@code NULL} + * + * @since version 3.3 + */ + public static void glfwGetWindowContentScale(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("float *") FloatBuffer xscale, @Nullable @NativeType("float *") FloatBuffer yscale) { + if (CHECKS) { + checkSafe(xscale, 1); + checkSafe(yscale, 1); + } + nglfwGetWindowContentScale(window, memAddressSafe(xscale), memAddressSafe(yscale)); + } + + // --- [ glfwGetWindowOpacity ] --- + + /** + * Returns the opacity of the whole window. + * + *This function returns the opacity of the window, including any decorations.
+ * + *The opacity (or alpha) value is a positive finite number between zero and one, where zero is fully transparent and one is fully opaque. If the system + * does not support whole window transparency, this function always returns one.
+ * + *The initial opacity value for newly created windows is one.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window to query + * + * @return the opacity value of the specified window + * + * @since version 3.3 + */ + public static float glfwGetWindowOpacity(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.GetWindowOpacity; + if (CHECKS) { + check(window); + } + return invokePF(window, __functionAddress); + } + + // --- [ glfwSetWindowOpacity ] --- + + /** + * Sets the opacity of the whole window. + * + *This function sets the opacity of the window, including any decorations.
+ * + *The opacity (or alpha) value is a positive finite number between zero and one, where zero is fully transparent and one is fully opaque.
+ * + *The initial opacity value for newly created windows is one.
+ * + *A window created with framebuffer transparency may not use whole window transparency. The results of doing this are undefined.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window to set the opacity for + * @param opacity the desired opacity of the specified window + * + * @since version 3.3 + */ + public static void glfwSetWindowOpacity(@NativeType("GLFWwindow *") long window, float opacity) { + long __functionAddress = Functions.SetWindowOpacity; + if (CHECKS) { + check(window); + } + invokePV(window, opacity, __functionAddress); + } + + // --- [ glfwIconifyWindow ] --- + + /** + * Iconifies (minimizes) the specified window if it was previously restored. If the window is already iconified, this function does nothing. + * + *If the specified window is a full screen window, the original monitor resolution is restored until the window is restored.
+ * + *Notes:
+ * + *If the specified window is a full screen window, the resolution chosen for the window is restored on the selected monitor.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window to restore + * + * @since version 2.1 + */ + public static void glfwRestoreWindow(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.RestoreWindow; + if (CHECKS) { + check(window); + } + invokePV(window, __functionAddress); + } + + // --- [ glfwMaximizeWindow ] --- + + /** + * Maximizes the specified window if it was previously not maximized. If the window is already maximized, this function does nothing. + * + *If the specified window is a full screen window, this function does nothing.
+ * + *This function may only be called from the main thread.
+ * + * @param window the window to maximize + * + * @since version 3.2 + */ + public static void glfwMaximizeWindow(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.MaximizeWindow; + if (CHECKS) { + check(window); + } + invokePV(window, __functionAddress); + } + + // --- [ glfwShowWindow ] --- + + /** + * Makes the specified window visible if it was previously hidden. If the window is already visible or is in full screen mode, this function does nothing. + * + *By default, windowed mode windows are focused when shown. Set the {@link #GLFW_FOCUS_ON_SHOW FOCUS_ON_SHOW} window hint to change this behavior for all newly created windows, or + * change the behavior for an existing window with {@link #glfwSetWindowAttrib SetWindowAttrib}.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window to make visible + * + * @since version 3.0 + */ + public static void glfwShowWindow(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.ShowWindow; + EventLoop.OnScreen.check(); + if (CHECKS) { + check(window); + } + invokePV(window, __functionAddress); + } + + // --- [ glfwHideWindow ] --- + + /** + * Hides the specified window, if it was previously visible. If the window is already hidden or is in full screen mode, this function does nothing. + * + *This function must only be called from the main thread.
+ * + * @param window the window to hide + * + * @since version 3.0 + */ + public static void glfwHideWindow(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.HideWindow; + if (CHECKS) { + check(window); + } + invokePV(window, __functionAddress); + } + + // --- [ glfwFocusWindow ] --- + + /** + * Brings the specified window to front and sets input focus. The window should already be visible and not iconified. + * + *By default, both windowed and full screen mode windows are focused when initially created. Set the {@link #GLFW_FOCUSED FOCUSED} hint to disable this behavior.
+ * + *Also by default, windowed mode windows are focused when shown with {@link #glfwShowWindow ShowWindow}. Set the {@link #GLFW_FOCUS_ON_SHOW FOCUS_ON_SHOW} window hint to disable this behavior.
+ * + *Do not use this function to steal focus from other applications unless you are certain that is what the user wants. Focus stealing can be + * extremely disruptive.
+ * + *For a less disruptive way of getting the user's attention, see {@link #glfwRequestWindowAttention RequestWindowAttention}.
+ * + *Notes:
+ * + *This function requests user attention to the specified window. On platforms where this is not supported, attention is requested to the application as + * a whole.
+ * + *Once the user has given attention, usually by focusing the window or application, the system will end the request automatically.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window to query + * + * @return the monitor, or {@code NULL} if the window is in windowed mode or an error occurred + * + * @since version 3.0 + */ + @NativeType("GLFWmonitor *") + public static long glfwGetWindowMonitor(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.GetWindowMonitor; + if (CHECKS) { + check(window); + } + return invokePP(window, __functionAddress); + } + + // --- [ glfwSetWindowMonitor ] --- + + /** + * Sets the mode, monitor, video mode and placement of a window. + * + *This function sets the monitor that the window uses for full screen mode or, if the monitor is {@code NULL}, makes it windowed mode.
+ * + *When setting a monitor, this function updates the width, height and refresh rate of the desired video mode and switches to the video mode closest to + * it. The window position is ignored when setting a monitor.
+ * + *When the monitor is {@code NULL}, the position, width and height are used to place the window content area. The refresh rate is ignored when no monitor is + * specified.
+ * + *If you only wish to update the resolution of a full screen window or the size of a windowed mode window, see {@link #glfwSetWindowSize SetWindowSize}.
+ * + *When a window transitions from full screen to windowed mode, this function restores any previous window settings such as whether it is decorated, + * floating, resizable, has size or aspect ratio limits, etc.
+ * + *Notes:
+ * + *This function must only be called from the main thread.
+ * + *Framebuffer related hints are not window attributes.
+ * + *Zero is a valid value for many window and context related attributes so you cannot use a return value of zero as an indication of errors. However, this + * function should not fail as long as it is passed valid arguments and the library has been initialized.
+ * + * @param window the window to query + * @param attrib the window attribute whose value to return. One of:| {@link #GLFW_FOCUSED FOCUSED} | {@link #GLFW_ICONIFIED ICONIFIED} | {@link #GLFW_RESIZABLE RESIZABLE} | {@link #GLFW_VISIBLE VISIBLE} | {@link #GLFW_DECORATED DECORATED} |
| {@link #GLFW_FLOATING FLOATING} | {@link #GLFW_MAXIMIZED MAXIMIZED} | {@link #GLFW_CENTER_CURSOR CENTER_CURSOR} | {@link #GLFW_TRANSPARENT_FRAMEBUFFER TRANSPARENT_FRAMEBUFFER} | {@link #GLFW_HOVERED HOVERED} |
| {@link #GLFW_FOCUS_ON_SHOW FOCUS_ON_SHOW} | {@link #GLFW_CLIENT_API CLIENT_API} | {@link #GLFW_CONTEXT_VERSION_MAJOR CONTEXT_VERSION_MAJOR} | {@link #GLFW_CONTEXT_VERSION_MINOR CONTEXT_VERSION_MINOR} | {@link #GLFW_CONTEXT_REVISION CONTEXT_REVISION} |
| {@link #GLFW_CONTEXT_ROBUSTNESS CONTEXT_ROBUSTNESS} | {@link #GLFW_OPENGL_FORWARD_COMPAT OPENGL_FORWARD_COMPAT} | {@link #GLFW_OPENGL_DEBUG_CONTEXT OPENGL_DEBUG_CONTEXT} | {@link #GLFW_OPENGL_PROFILE OPENGL_PROFILE} | {@link #GLFW_CONTEXT_RELEASE_BEHAVIOR CONTEXT_RELEASE_BEHAVIOR} |
| {@link #GLFW_CONTEXT_NO_ERROR CONTEXT_NO_ERROR} | {@link #GLFW_CONTEXT_CREATION_API CONTEXT_CREATION_API} | {@link #GLFW_SCALE_TO_MONITOR SCALE_TO_MONITOR} |
This function must only be called from the main thread.
+ * + * @param window the window to set the attribute for + * @param attrib the attribute to set. + * + *Some of these attributes are ignored for full screen windows. The new value will take effect if the window is later made windowed.
+ * + *Some of these attributes are ignored for windowed mode windows. The new value will take effect if the window is later made full screen.
+ * + *Calling {@link #glfwGetWindowAttrib GetWindowAttrib} will always return the latest value, even if that value is ignored by the current mode of the window. One of:
| {@link #GLFW_DECORATED DECORATED} | {@link #GLFW_RESIZABLE RESIZABLE} | {@link #GLFW_FLOATING FLOATING} | {@link #GLFW_AUTO_ICONIFY AUTO_ICONIFY} | {@link #GLFW_FOCUS_ON_SHOW FOCUS_ON_SHOW} |
This function may be called from any thread. Access is not synchronized.
+ * + * @param window the window whose pointer to set + * @param pointer the new value + * + * @since version 3.0 + */ + public static void glfwSetWindowUserPointer(@NativeType("GLFWwindow *") long window, @NativeType("void *") long pointer) { + long __functionAddress = Functions.SetWindowUserPointer; + if (CHECKS) { + check(window); + } + invokePPV(window, pointer, __functionAddress); + } + + // --- [ glfwGetWindowUserPointer ] --- + + /** + * Returns the current value of the user-defined pointer of the specified window. The initial value is {@code NULL}. + * + *This function may be called from any thread. Access is not synchronized.
+ * + * @param window the window whose pointer to return + * + * @since version 3.0 + */ + @NativeType("void *") + public static long glfwGetWindowUserPointer(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.GetWindowUserPointer; + if (CHECKS) { + check(window); + } + return invokePP(window, __functionAddress); + } + + // --- [ glfwSetWindowPosCallback ] --- + + /** Unsafe version of: {@link #glfwSetWindowPosCallback SetWindowPosCallback} */ + public static long nglfwSetWindowPosCallback(long window, long cbfun) { + long __functionAddress = Functions.SetWindowPosCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the position callback of the specified window, which is called when the window is moved. The callback is provided with the position, in screen + * coordinates, of the upper-left corner of the content area of the window. + * + *Notes:
+ * + *This function must only be called from the main thread.
+ * + * @param window the window whose callback to set + * @param cbfun the new callback or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set or the library had not been + * initialized + * + * @since version 1.0 + */ + @Nullable + @NativeType("GLFWwindowsizefun") + public static GLFWWindowSizeCallback glfwSetWindowSizeCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWwindowsizefun") GLFWWindowSizeCallbackI cbfun) { + return GLFWWindowSizeCallback.createSafe(nglfwSetWindowSizeCallback(window, memAddressSafe(cbfun))); + } + + // --- [ glfwSetWindowCloseCallback ] --- + + /** Unsafe version of: {@link #glfwSetWindowCloseCallback SetWindowCloseCallback} */ + public static long nglfwSetWindowCloseCallback(long window, long cbfun) { + long __functionAddress = Functions.SetWindowCloseCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the close callback of the specified window, which is called when the user attempts to close the window, for example by clicking the close widget in + * the title bar. + * + *The close flag is set before this callback is called, but you can modify it at any time with {@link #glfwSetWindowShouldClose SetWindowShouldClose}.
+ * + *The close callback is not triggered by {@link #glfwDestroyWindow DestroyWindow}.
+ * + *On compositing window systems such as Aero, Compiz or Aqua, where the window contents are saved off-screen, this callback may be called only very + * infrequently or never at all.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window whose callback to set + * @param cbfun the new callback or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set or the library had not been + * initialized + * + * @since version 2.5 + */ + @Nullable + @NativeType("GLFWwindowrefreshfun") + public static GLFWWindowRefreshCallback glfwSetWindowRefreshCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWwindowrefreshfun") GLFWWindowRefreshCallbackI cbfun) { + return GLFWWindowRefreshCallback.createSafe(nglfwSetWindowRefreshCallback(window, memAddressSafe(cbfun))); + } + + // --- [ glfwSetWindowFocusCallback ] --- + + /** Unsafe version of: {@link #glfwSetWindowFocusCallback SetWindowFocusCallback} */ + public static long nglfwSetWindowFocusCallback(long window, long cbfun) { + long __functionAddress = Functions.SetWindowFocusCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the focus callback of the specified window, which is called when the window gains or loses input focus. + * + *After the focus callback is called for a window that lost input focus, synthetic key and mouse button release events will be generated for all such + * that had been pressed. For more information, see {@link #glfwSetKeyCallback SetKeyCallback} and {@link #glfwSetMouseButtonCallback SetMouseButtonCallback}.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window whose callback to set + * @param cbfun the new callback or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set or the library had not been + * initialized + * + * @since version 3.0 + */ + @Nullable + @NativeType("GLFWwindowfocusfun") + public static GLFWWindowFocusCallback glfwSetWindowFocusCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWwindowfocusfun") GLFWWindowFocusCallbackI cbfun) { + return GLFWWindowFocusCallback.createSafe(nglfwSetWindowFocusCallback(window, memAddressSafe(cbfun))); + } + + // --- [ glfwSetWindowIconifyCallback ] --- + + /** Unsafe version of: {@link #glfwSetWindowIconifyCallback SetWindowIconifyCallback} */ + public static long nglfwSetWindowIconifyCallback(long window, long cbfun) { + long __functionAddress = Functions.SetWindowIconifyCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the iconification callback of the specified window, which is called when the window is iconified or restored. + * + *This function must only be called from the main thread.
+ * + * @param window the window whose callback to set + * @param cbfun the new callback or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set or the library had not been + * initialized + * + * @since version 3.0 + */ + @Nullable + @NativeType("GLFWwindowiconifyfun") + public static GLFWWindowIconifyCallback glfwSetWindowIconifyCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWwindowiconifyfun") GLFWWindowIconifyCallbackI cbfun) { + return GLFWWindowIconifyCallback.createSafe(nglfwSetWindowIconifyCallback(window, memAddressSafe(cbfun))); + } + + // --- [ glfwSetWindowMaximizeCallback ] --- + + /** Unsafe version of: {@link #glfwSetWindowMaximizeCallback SetWindowMaximizeCallback} */ + public static long nglfwSetWindowMaximizeCallback(long window, long cbfun) { + long __functionAddress = Functions.SetWindowMaximizeCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the maximization callback of the specified window, which is called when the window is maximized or restored. + * + *This function must only be called from the main thread.
+ * + * @param window the window whose callback to set + * @param cbfun the new callback or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set or the library had not been + * initialized + * + * @since version 3.3 + */ + @Nullable + @NativeType("GLFWwindowmaximizefun") + public static GLFWWindowMaximizeCallback glfwSetWindowMaximizeCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWwindowmaximizefun") GLFWWindowMaximizeCallbackI cbfun) { + return GLFWWindowMaximizeCallback.createSafe(nglfwSetWindowMaximizeCallback(window, memAddressSafe(cbfun))); + } + + // --- [ glfwSetFramebufferSizeCallback ] --- + + /** Unsafe version of: {@link #glfwSetFramebufferSizeCallback SetFramebufferSizeCallback} */ + public static long nglfwSetFramebufferSizeCallback(long window, long cbfun) { + long __functionAddress = Functions.SetFramebufferSizeCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the framebuffer resize callback of the specified window, which is called when the framebuffer of the specified window is resized. + * + *This function must only be called from the main thread.
+ * + * @param window the window whose callback to set + * @param cbfun the new callback or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set or the library had not been + * initialized + * + * @since version 3.0 + */ + @Nullable + @NativeType("GLFWframebuffersizefun") + public static GLFWFramebufferSizeCallback glfwSetFramebufferSizeCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWframebuffersizefun") GLFWFramebufferSizeCallbackI cbfun) { + return GLFWFramebufferSizeCallback.createSafe(nglfwSetFramebufferSizeCallback(window, memAddressSafe(cbfun))); + } + + // --- [ glfwSetWindowContentScaleCallback ] --- + + /** Unsafe version of: {@link #glfwSetWindowContentScaleCallback SetWindowContentScaleCallback} */ + public static long nglfwSetWindowContentScaleCallback(long window, long cbfun) { + long __functionAddress = Functions.SetWindowContentScaleCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the window content scale callback for the specified window, which is called when the content scale of the specified window changes. + * + *This function must only be called from the main thread.
+ * + * @param window the window whose callback to set + * @param cbfun the new callback or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set or the library had not been + * initialized + * + * @since version 3.3 + */ + @Nullable + @NativeType("GLFWwindowcontentscalefun") + public static GLFWWindowContentScaleCallback glfwSetWindowContentScaleCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWwindowcontentscalefun") GLFWWindowContentScaleCallbackI cbfun) { + return GLFWWindowContentScaleCallback.createSafe(nglfwSetWindowContentScaleCallback(window, memAddressSafe(cbfun))); + } + + // --- [ glfwPollEvents ] --- + + /** + * Processes all pending events. + * + *This function processes only those events that are already in the event queue and then returns immediately. Processing events will cause the window and + * input callbacks associated with those events to be called.
+ * + *On some platforms, a window move, resize or menu operation will cause event processing to block. This is due to how event processing is designed on + * those platforms. You can use the window refresh callback to redraw the + * contents of your window when necessary during such operations.
+ * + *On some platforms, certain events are sent directly to the application without going through the event queue, causing callbacks to be called outside of + * a call to one of the event processing functions.
+ * + *Event processing is not required for joystick input to work.
+ * + *This function puts the calling thread to sleep until at least one event is available in the event queue. Once one or more events are available, it + * behaves exactly like {@link #glfwPollEvents PollEvents}, i.e. the events in the queue are processed and the function then returns immediately. Processing events will cause + * the window and input callbacks associated with those events to be called.
+ * + *Since not all events are associated with callbacks, this function may return without a callback having been called even if you are monitoring all + * callbacks.
+ * + *On some platforms, a window move, resize or menu operation will cause event processing to block. This is due to how event processing is designed on + * those platforms. You can use the window refresh callback to redraw the + * contents of your window when necessary during such operations.
+ * + *On some platforms, certain callbacks may be called outside of a call to one of the event processing functions.
+ * + *Event processing is not required for joystick input to work.
+ * + *This function puts the calling thread to sleep until at least one event is available in the event queue, or until the specified timeout is reached. If + * one or more events are available, it behaves exactly like {@link #glfwPollEvents PollEvents}, i.e. the events in the queue are processed and the function then returns + * immediately. Processing events will cause the window and input callbacks associated with those events to be called.
+ * + *The timeout value must be a positive finite number.
+ * + *Since not all events are associated with callbacks, this function may return without a callback having been called even if you are monitoring all + * callbacks.
+ * + *On some platforms, a window move, resize or menu operation will cause event processing to block. This is due to how event processing is designed on + * those platforms. You can use the window refresh callback to redraw the contents of your window when necessary during such operations.
+ * + *On some platforms, certain callbacks may be called outside of a call to one of the event processing functions.
+ * + *Event processing is not required for joystick input to work.
+ * + *This function may be called from any thread.
+ * + * @since version 3.1 + */ + public static void glfwPostEmptyEvent() { + long __functionAddress = Functions.PostEmptyEvent; + invokeV(__functionAddress); + } + + // --- [ glfwGetInputMode ] --- + + /** + * Returns the value of an input option for the specified window. + * + *This function must only be called from the main thread.
+ * + * @param window the window to query + * @param mode the input mode whose value to return. One of:| {@link #GLFW_CURSOR CURSOR} | {@link #GLFW_STICKY_KEYS STICKY_KEYS} | {@link #GLFW_STICKY_MOUSE_BUTTONS STICKY_MOUSE_BUTTONS} | {@link #GLFW_LOCK_KEY_MODS LOCK_KEY_MODS} | {@link #GLFW_RAW_MOUSE_MOTION RAW_MOUSE_MOTION} |
If {@code mode} is {@link #GLFW_CURSOR CURSOR}, the value must be one of the following cursor modes:
+ * + *If the {@code mode} is {@link #GLFW_STICKY_KEYS STICKY_KEYS}, the value must be either {@link #GLFW_TRUE TRUE} to enable sticky keys, or {@link #GLFW_FALSE FALSE} to disable it. If sticky keys are enabled, a key + * press will ensure that {@link #glfwGetKey GetKey} returns {@link #GLFW_PRESS PRESS} the next time it is called even if the key had been released before the call. This is useful when you + * are only interested in whether keys have been pressed but not when or in which order.
+ * + *If the {@code mode} is {@link #GLFW_STICKY_MOUSE_BUTTONS STICKY_MOUSE_BUTTONS}, the value must be either {@link #GLFW_TRUE TRUE} to enable sticky mouse buttons, or {@link #GLFW_FALSE FALSE} to disable it. If sticky mouse + * buttons are enabled, a mouse button press will ensure that {@link #glfwGetMouseButton GetMouseButton} returns {@link #GLFW_PRESS PRESS} the next time it is called even if the mouse button had + * been released before the call. This is useful when you are only interested in whether mouse buttons have been pressed but not when or in which order.
+ * + *If the {@code mode} is {@link #GLFW_LOCK_KEY_MODS LOCK_KEY_MODS}, the value must be either {@link #GLFW_TRUE TRUE} to enable lock key modifier bits, or {@link #GLFW_FALSE FALSE} to disable them. If enabled, + * callbacks that receive modifier bits will also have the {@link #GLFW_MOD_CAPS_LOCK MOD_CAPS_LOCK} bit set when the event was generated with Caps Lock on, and the {@link #GLFW_MOD_NUM_LOCK MOD_NUM_LOCK} + * bit when Num Lock was on.
+ * + *If the mode is {@link #GLFW_RAW_MOUSE_MOTION RAW_MOUSE_MOTION}, the value must be either {@link #GLFW_TRUE TRUE} to enable raw (unscaled and unaccelerated) mouse motion when the cursor is disabled, + * or {@link #GLFW_FALSE FALSE} to disable it. If raw motion is not supported, attempting to set this will emit {@link #GLFW_PLATFORM_ERROR PLATFORM_ERROR}. Call {@link #glfwRawMouseMotionSupported RawMouseMotionSupported} to check for + * support.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window whose input mode to set + * @param mode the input mode to set. One of:| {@link #GLFW_CURSOR CURSOR} | {@link #GLFW_STICKY_KEYS STICKY_KEYS} | {@link #GLFW_STICKY_MOUSE_BUTTONS STICKY_MOUSE_BUTTONS} |
This function returns whether raw mouse motion is supported on the current system. This status does not change after GLFW has been initialized so you + * only need to check this once. If you attempt to enable raw motion on a system that does not support it, {@link #GLFW_PLATFORM_ERROR PLATFORM_ERROR} will be emitted.
+ * + *Raw mouse motion is closer to the actual motion of the mouse across a surface. It is not affected by the scaling and acceleration applied to the motion + * of the desktop cursor. That processing is suitable for a cursor while raw motion is better for controlling for example a 3D camera. Because of this, + * raw mouse motion is only provided when the cursor is disabled.
+ * + *This function must only be called from the main thread.
+ * + * @return {@link #GLFW_TRUE TRUE} if raw mouse motion is supported on the current machine, or {@link #GLFW_FALSE FALSE} otherwise + * + * @since version 3.3 + */ + @NativeType("int") + public static boolean glfwRawMouseMotionSupported() { + long __functionAddress = Functions.RawMouseMotionSupported; + return invokeI(__functionAddress) != 0; + } + + // --- [ glfwGetKeyName ] --- + + /** Unsafe version of: {@link #glfwGetKeyName GetKeyName} */ + public static long nglfwGetKeyName(int key, int scancode) { + long __functionAddress = Functions.GetKeyName; + return invokeP(key, scancode, __functionAddress); + } + + /** + * Returns the layout-specific name of the specified printable key. + * + *This function returns the name of the specified printable key, encoded as UTF-8. This is typically the character that key would produce without any + * modifier keys, intended for displaying key bindings to the user. For dead keys, it is typically the diacritic it would add to a character.
+ * + *Do not use this function for text input. You will break text input for many languages even if it happens to work for yours.
+ * + *If the key is {@link #GLFW_KEY_UNKNOWN KEY_UNKNOWN}, the scancode is used to identify the key, otherwise the scancode is ignored. If you specify a non-printable key, or + * {@link #GLFW_KEY_UNKNOWN KEY_UNKNOWN} and a scancode that maps to a non-printable key, this function returns {@code NULL} but does not emit an error.
+ * + *This behavior allows you to always pass in the arguments in the key callback without modification.
+ * + *The printable keys are:
+ * + *Names for printable keys depend on keyboard layout, while names for non-printable keys are the same across layouts but depend on the application + * language and should be localized along with other user interface text.
+ * + *The returned string is allocated and freed by GLFW. You should not free it yourself. It is valid until the next call to {@link #glfwGetKeyName GetKeyName}, or until the + * library is terminated.
+ * + *This function must only be called from the main thread.
+ * + * @param key the key to query, or {@link #GLFW_KEY_UNKNOWN KEY_UNKNOWN} + * @param scancode the scancode of the key to query + * + * @return the UTF-8 encoded, layout-specific name of the key, or {@code NULL} + * + * @since version 3.2 + */ + @Nullable + @NativeType("char const *") + public static String glfwGetKeyName(int key, int scancode) { + long __result = nglfwGetKeyName(key, scancode); + return memUTF8Safe(__result); + } + + // --- [ glfwGetKeyScancode ] --- + + /** + * Returns the platform dependent scancode of the specified key. + * + *This function returns the platform dependent scancode of the specified key. This is intended for platform specific default keybindings.
+ * + *If the key is {@link #GLFW_KEY_UNKNOWN KEY_UNKNOWN} or does not exist on the keyboard this method will return {@code -1}.
+ * + *This function may be called from any thread.
+ * + * @param key the key to query, or {@link #GLFW_KEY_UNKNOWN KEY_UNKNOWN} + * + * @return the platform dependent scancode for the key, or {@code -1} if an errror occurred + * + * @since version 3.3 + */ + public static int glfwGetKeyScancode(int key) { + long __functionAddress = Functions.GetKeyScancode; + return invokeI(key, __functionAddress); + } + + // --- [ glfwGetKey ] --- + + /** + * Returns the last state reported for the specified key to the specified window. The returned state is one of {@link #GLFW_PRESS PRESS} or {@link #GLFW_RELEASE RELEASE}. The higher-level action + * {@link #GLFW_REPEAT REPEAT} is only reported to the key callback. + * + *If the {@link #GLFW_STICKY_KEYS STICKY_KEYS} input mode is enabled, this function returns {@link #GLFW_PRESS PRESS} the first time you call it for a key that was pressed, even if that + * key has already been released.
+ * + *The key functions deal with physical keys, with key tokens named after their use on the standard US keyboard layout. If you want to input text, use the + * Unicode character callback instead.
+ * + *The modifier key bit masks are not key tokens and cannot be used with this function.
+ * + *Do not use this function to implement text input.
+ * + *If the {@link #GLFW_STICKY_MOUSE_BUTTONS STICKY_MOUSE_BUTTONS} input mode is enabled, this function returns {@link #GLFW_PRESS PRESS} the first time you call it for a mouse button that was pressed, even + * if that mouse button has already been released.
+ * + *This function must only be called from the main thread.
+ * + * @param window the desired window + * @param button the desired mouse button + * + * @return one of {@link #GLFW_PRESS PRESS} or {@link #GLFW_RELEASE RELEASE} + * + * @since version 1.0 + */ + public static int glfwGetMouseButton(@NativeType("GLFWwindow *") long window, int button) { + long __functionAddress = Functions.GetMouseButton; + if (CHECKS) { + check(window); + } + return invokePI(window, button, __functionAddress); + } + + // --- [ glfwGetCursorPos ] --- + + /** Unsafe version of: {@link #glfwGetCursorPos GetCursorPos} */ + public static void nglfwGetCursorPos(long window, long xpos, long ypos) { + long __functionAddress = Functions.GetCursorPos; + if (CHECKS) { + check(window); + } + invokePPPV(window, xpos, ypos, __functionAddress); + } + + /** + * Returns the position of the cursor, in screen coordinates, relative to the upper-left corner of the content area of the specified window. + * + *If the cursor is disabled (with {@link #GLFW_CURSOR_DISABLED CURSOR_DISABLED}) then the cursor position is unbounded and limited only by the minimum and maximum values of a + * double.
+ * + *The coordinates can be converted to their integer equivalents with the {@link Math#floor} function. Casting directly to an integer type works for positive + * coordinates, but fails for negative ones.
+ * + *Any or all of the position arguments may be {@code NULL}. If an error occurs, all non-{@code NULL} position arguments will be set to zero.
+ * + *This function must only be called from the main thread.
+ * + * @param window the desired window + * @param xpos where to store the cursor x-coordinate, relative to the left edge of the content area, or {@code NULL} + * @param ypos where to store the cursor y-coordinate, relative to the to top edge of the content area, or {@code NULL}. + * + * @since version 1.0 + */ + public static void glfwGetCursorPos(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("double *") DoubleBuffer xpos, @Nullable @NativeType("double *") DoubleBuffer ypos) { + if (CHECKS) { + checkSafe(xpos, 1); + checkSafe(ypos, 1); + } + nglfwGetCursorPos(window, memAddressSafe(xpos), memAddressSafe(ypos)); + } + + // --- [ glfwSetCursorPos ] --- + + /** + * Sets the position, in screen coordinates, of the cursor relative to the upper-left corner of the content area of the specified window. The window must + * have input focus. If the window does not have input focus when this function is called, it fails silently. + * + *Do not use this function to implement things like camera controls. GLFW already provides the {@link #GLFW_CURSOR_DISABLED CURSOR_DISABLED} cursor mode that hides the cursor, + * transparently re-centers it and provides unconstrained cursor motion. See {@link #glfwSetInputMode SetInputMode} for more information.
+ * + *If the cursor mode is {@link #GLFW_CURSOR_DISABLED CURSOR_DISABLED} then the cursor position is unconstrained and limited only by the minimum and maximum values of double.
+ * + *Notes:
+ * + *The pixels are 32-bit, little-endian, non-premultiplied RGBA, i.e. eight bits per channel with the red channel first. They are arranged canonically as + * packed sequential rows, starting from the top-left corner.
+ * + *The cursor hotspot is specified in pixels, relative to the upper-left corner of the cursor image. Like all other coordinate systems in GLFW, the X-axis + * points to the right and the Y-axis points down.
+ * + *This function must only be called from the main thread.
+ * + * @param shape one of the standard shapes. One of:| {@link #GLFW_ARROW_CURSOR ARROW_CURSOR} | {@link #GLFW_IBEAM_CURSOR IBEAM_CURSOR} | {@link #GLFW_CROSSHAIR_CURSOR CROSSHAIR_CURSOR} | {@link #GLFW_HAND_CURSOR HAND_CURSOR} | {@link #GLFW_HRESIZE_CURSOR HRESIZE_CURSOR} | {@link #GLFW_VRESIZE_CURSOR VRESIZE_CURSOR} |
On some platforms, the set cursor may not be visible unless the window also has input focus.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window to set the system cursor for + * @param cursor the cursor to set, or {@code NULL} to switch back to the default arrow cursor + * + * @since version 3.1 + */ + public static void glfwSetCursor(@NativeType("GLFWwindow *") long window, @NativeType("GLFWcursor *") long cursor) { + long __functionAddress = Functions.SetCursor; + if (CHECKS) { + check(window); + } + invokePPV(window, cursor, __functionAddress); + } + + // --- [ glfwSetKeyCallback ] --- + + /** Unsafe version of: {@link #glfwSetKeyCallback SetKeyCallback} */ + public static long nglfwSetKeyCallback(long window, long cbfun) { + long __functionAddress = Functions.SetKeyCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the key callback of the specified window, which is called when a key is pressed, repeated or released. + * + *The key functions deal with physical keys, with layout independent key tokens named after their values in the standard US keyboard layout. If you want + * to input text, use {@link #glfwSetCharCallback SetCharCallback} instead.
+ * + *When a window loses input focus, it will generate synthetic key release events for all pressed keys. You can tell these events from user-generated + * events by the fact that the synthetic ones are generated after the focus loss event has been processed, i.e. after the window focus callback has been + * called.
+ * + *The scancode of a key is specific to that platform or sometimes even to that machine. Scancodes are intended to allow users to bind keys that don't have + * a GLFW key token. Such keys have {@code key} set to {@link #GLFW_KEY_UNKNOWN KEY_UNKNOWN}, their state is not saved and so it cannot be queried with {@link #glfwGetKey GetKey}.
+ * + *Sometimes GLFW needs to generate synthetic key events, in which case the scancode may be zero.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window whose callback to set + * @param cbfun the new callback or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set + * + * @since version 1.0 + */ + @Nullable + @NativeType("GLFWkeyfun") + public static GLFWKeyCallback glfwSetKeyCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWkeyfun") GLFWKeyCallbackI cbfun) { + return GLFWKeyCallback.createSafe(nglfwSetKeyCallback(window, memAddressSafe(cbfun))); + } + + // --- [ glfwSetCharCallback ] --- + + /** Unsafe version of: {@link #glfwSetCharCallback SetCharCallback} */ + public static long nglfwSetCharCallback(long window, long cbfun) { + long __functionAddress = Functions.SetCharCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the character callback of the specified window, which is called when a Unicode character is input. + * + *The character callback is intended for Unicode text input. As it deals with characters, it is keyboard layout dependent, whereas {@link #glfwSetKeyCallback SetKeyCallback} is + * not. Characters do not map 1:1 to physical keys, as a key may produce zero, one or more characters. If you want to know whether a specific physical key + * was pressed or released, see the key callback instead.
+ * + *The character callback behaves as system text input normally does and will not be called if modifier keys are held down that would prevent normal text + * input on that platform, for example a Super (Command) key on macOS or Alt key on Windows.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window whose callback to set + * @param cbfun the new callback or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set + * + * @since version 2.4 + */ + @Nullable + @NativeType("GLFWcharfun") + public static GLFWCharCallback glfwSetCharCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWcharfun") GLFWCharCallbackI cbfun) { + return GLFWCharCallback.createSafe(nglfwSetCharCallback(window, memAddressSafe(cbfun))); + } + + // --- [ glfwSetCharModsCallback ] --- + + /** Unsafe version of: {@link #glfwSetCharModsCallback SetCharModsCallback} */ + public static long nglfwSetCharModsCallback(long window, long cbfun) { + long __functionAddress = Functions.SetCharModsCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the character with modifiers callback of the specified window, which is called when a Unicode character is input regardless of what modifier keys + * are used. + * + *The character with modifiers callback is intended for implementing custom Unicode character input. For regular Unicode text input, see + * {@link #glfwSetCharCallback SetCharCallback}. Like the character callback, the character with modifiers callback deals with characters and is keyboard layout dependent. + * Characters do not map 1:1 to physical keys, as a key may produce zero, one or more characters. If you want to know whether a specific physical key was + * pressed or released, see {@link #glfwSetKeyCallback SetKeyCallback} instead.
+ * + *This function must only be called from the main thread.
+ * + *Deprecated: scheduled for removal in version 4.0.
+ * + * @param window the window whose callback to set + * @param cbfun the new callback or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set + * + * @since version 3.1 + */ + @Nullable + @NativeType("GLFWcharmodsfun") + public static GLFWCharModsCallback glfwSetCharModsCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWcharmodsfun") GLFWCharModsCallbackI cbfun) { + return GLFWCharModsCallback.createSafe(nglfwSetCharModsCallback(window, memAddressSafe(cbfun))); + } + + // --- [ glfwSetMouseButtonCallback ] --- + + /** Unsafe version of: {@link #glfwSetMouseButtonCallback SetMouseButtonCallback} */ + public static long nglfwSetMouseButtonCallback(long window, long cbfun) { + long __functionAddress = Functions.SetMouseButtonCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the mouse button callback of the specified window, which is called when a mouse button is pressed or released. + * + *When a window loses input focus, it will generate synthetic mouse button release events for all pressed mouse buttons. You can tell these events from + * user-generated events by the fact that the synthetic ones are generated after the focus loss event has been processed, i.e. after the window focus + * callback has been called.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window whose callback to set + * @param cbfun the new callback or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set + * + * @since version 1.0 + */ + @Nullable + @NativeType("GLFWmousebuttonfun") + public static GLFWMouseButtonCallback glfwSetMouseButtonCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWmousebuttonfun") GLFWMouseButtonCallbackI cbfun) { + return GLFWMouseButtonCallback.createSafe(nglfwSetMouseButtonCallback(window, memAddressSafe(cbfun))); + } + + // --- [ glfwSetCursorPosCallback ] --- + + /** Unsafe version of: {@link #glfwSetCursorPosCallback SetCursorPosCallback} */ + public static long nglfwSetCursorPosCallback(long window, long cbfun) { + long __functionAddress = Functions.SetCursorPosCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the cursor position callback of the specified window, which is called when the cursor is moved. The callback is provided with the position, in + * screen coordinates, relative to the upper-left corner of the content area of the window. + * + *This function must only be called from the main thread.
+ * + * @param window the window whose callback to set + * @param cbfun the new callback or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set + * + * @since version 1.0 + */ + @Nullable + @NativeType("GLFWcursorposfun") + public static GLFWCursorPosCallback glfwSetCursorPosCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWcursorposfun") GLFWCursorPosCallbackI cbfun) { + return GLFWCursorPosCallback.createSafe(nglfwSetCursorPosCallback(window, memAddressSafe(cbfun))); + } + + // --- [ glfwSetCursorEnterCallback ] --- + + /** Unsafe version of: {@link #glfwSetCursorEnterCallback SetCursorEnterCallback} */ + public static long nglfwSetCursorEnterCallback(long window, long cbfun) { + long __functionAddress = Functions.SetCursorEnterCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the cursor boundary crossing callback of the specified window, which is called when the cursor enters or leaves the content area of the window. + * + *This function must only be called from the main thread.
+ * + * @param window the window whose callback to set + * @param cbfun the new callback or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set + * + * @since version 3.0 + */ + @Nullable + @NativeType("GLFWcursorenterfun") + public static GLFWCursorEnterCallback glfwSetCursorEnterCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWcursorenterfun") GLFWCursorEnterCallbackI cbfun) { + return GLFWCursorEnterCallback.createSafe(nglfwSetCursorEnterCallback(window, memAddressSafe(cbfun))); + } + + // --- [ glfwSetScrollCallback ] --- + + /** Unsafe version of: {@link #glfwSetScrollCallback SetScrollCallback} */ + public static long nglfwSetScrollCallback(long window, long cbfun) { + long __functionAddress = Functions.SetScrollCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the scroll callback of the specified window, which is called when a scrolling device is used. + * + *The scroll callback receives all scrolling input, like that from a mouse wheel or a touchpad scrolling area.
+ * + *This function must only be called from the main thread.
+ * + * @param window the window whose callback to set + * @param cbfun the new callback or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set + * + * @since version 2.1 + */ + @Nullable + @NativeType("GLFWscrollfun") + public static GLFWScrollCallback glfwSetScrollCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWscrollfun") GLFWScrollCallbackI cbfun) { + return GLFWScrollCallback.createSafe(nglfwSetScrollCallback(window, memAddressSafe(cbfun))); + } + + // --- [ glfwSetDropCallback ] --- + + /** Unsafe version of: {@link #glfwSetDropCallback SetDropCallback} */ + public static long nglfwSetDropCallback(long window, long cbfun) { + long __functionAddress = Functions.SetDropCallback; + if (CHECKS) { + check(window); + } + return invokePPP(window, cbfun, __functionAddress); + } + + /** + * Sets the file drop callback of the specified window, which is called when one or more dragged files are dropped on the window. + * + *Because the path array and its strings may have been generated specifically for that event, they are not guaranteed to be valid after the callback has + * returned. If you wish to use them after the callback returns, you need to make a deep copy.
+ * + *Notes:
+ * + *This function must only be called from the main thread.
+ * + * @param jid joystick to query + * + * @return {@link #GLFW_TRUE TRUE} if the joystick is present, or {@link #GLFW_FALSE FALSE} otherwise + * + * @since version 3.0 + */ + @NativeType("int") + public static boolean glfwJoystickPresent(int jid) { + return false; + } + + /** + * Returns the values of all axes of the specified joystick. Each element in the array is a value between -1.0 and 1.0. + * + *If the specified joystick is not present this function will return {@code NULL} but will not generate an error. This can be used instead of first calling + * {@link #glfwJoystickPresent JoystickPresent}.
+ * + *The returned array is allocated and freed by GLFW. You should not free it yourself. It is valid until the specified joystick is disconnected, this + * function is called again for that joystick or the library is terminated.
+ * + *This function must only be called from the main thread.
+ * + * @param jid the joystick to query + * + * @return an array of axis values, or {@code NULL} if the joystick is not present + * + * @since version 2.2 + */ + @Nullable + @NativeType("float const *") + public static FloatBuffer glfwGetJoystickAxes(int jid) { + return null; + } + + /** + * Returns the state of all buttons of the specified joystick. Each element in the array is either {@link #GLFW_PRESS PRESS} or {@link #GLFW_RELEASE RELEASE}. + * + *For backward compatibility with earlier versions that did not have {@link #glfwGetJoystickHats GetJoystickHats}, the button array also includes all hats, each represented as four + * buttons. The hats are in the same order as returned by {@link #glfwGetJoystickHats GetJoystickHats} and are in the order up, right, down and left. To disable these extra + * buttons, set the {@link #GLFW_JOYSTICK_HAT_BUTTONS JOYSTICK_HAT_BUTTONS} init hint before initialization.
+ * + *If the specified joystick is not present this function will return {@code NULL} but will not generate an error. This can be used instead of first calling + * {@link #glfwJoystickPresent JoystickPresent}.
+ * + *The returned array is allocated and freed by GLFW. You should not free it yourself. It is valid until the specified joystick is disconnected, this + * function is called again for that joystick or the library is terminated.
+ * + *This function must only be called from the main thread.
+ * + * @param jid the joystick to query + * + * @return an array of button states, or {@code NULL} if the joystick is not present + * + * @since version 2.2 + */ + @Nullable + @NativeType("unsigned char const *") + public static ByteBuffer glfwGetJoystickButtons(int jid) { + return null; + } + + /** + * Returns the state of all hats of the specified joystick. + * + *This function returns the state of all hats of the specified joystick. Each element in the array is one of the following values:
+ * + *
+ * Name | Value
+ * ------------------- | ------------------------------
+ * GLFW_HAT_CENTERED | 0
+ * GLFW_HAT_UP | 1
+ * GLFW_HAT_RIGHT | 2
+ * GLFW_HAT_DOWN | 4
+ * GLFW_HAT_LEFT | 8
+ * GLFW_HAT_RIGHT_UP | GLFW_HAT_RIGHT | GLFW_HAT_UP
+ * GLFW_HAT_RIGHT_DOWN | GLFW_HAT_RIGHT | GLFW_HAT_DOWN
+ * GLFW_HAT_LEFT_UP | GLFW_HAT_LEFT | GLFW_HAT_UP
+ * GLFW_HAT_LEFT_DOWN | GLFW_HAT_LEFT | GLFW_HAT_DOWNThe diagonal directions are bitwise combinations of the primary (up, right, down and left) directions and you can test for these individually by ANDing + * it with the corresponding direction.
+ * + *
+ * if (hats[2] & GLFW_HAT_RIGHT)
+ * {
+ * // State of hat 2 could be right-up, right or right-down
+ * }If the specified joystick is not present this function will return {@code NULL} but will not generate an error. This can be used instead of first calling + * {@link #glfwJoystickPresent JoystickPresent}.
+ * + *If the specified joystick is not present this function will return {@code NULL} but will not generate an error. This can be used instead of first calling + * {@link #glfwJoystickPresent JoystickPresent}.
+ * + *The returned string is allocated and freed by GLFW. You should not free it yourself. It is valid until the specified joystick is disconnected, this + * function is called again for that joystick or the library is terminated.
+ * + *This function must only be called from the main thread.
+ * + * @param jid the joystick to query + * + * @return the UTF-8 encoded name of the joystick, or {@code NULL} if the joystick is not present + * + * @since version 3.0 + */ + @Nullable + @NativeType("char const *") + public static String glfwGetJoystickName(int jid) { + return null; + } + + /** + * Returns the SDL compatible GUID, as a UTF-8 encoded hexadecimal string, of the specified joystick. + * + *The GUID is what connects a joystick to a gamepad mapping. A connected joystick will always have a GUID even if there is no gamepad mapping assigned to + * it.
+ * + *The GUID uses the format introduced in SDL 2.0.5. This GUID tries to uniquely identify the make and model of a joystick but does not identify a + * specific unit, e.g. all wired Xbox 360 controllers will have the same GUID on that platform. The GUID for a unit may vary between platforms depending + * on what hardware information the platform specific APIs provide.
+ * + *If the specified joystick is not present this function will return {@code NULL} but will not generate an error. This can be used instead of first calling + * {@link #glfwJoystickPresent JoystickPresent}.
+ * + *The returned string is allocated and freed by GLFW. You should not free it yourself. It is valid until the specified joystick is disconnected or the + * library is terminated.
+ * + *This function must only be called from the main thread.
+ * + * @param jid the joystick to query + * + * @return the UTF-8 encoded GUID of the joystick, or {@code NULL} if the joystick is not present or an error occurred + * + * @since version 3.3 + */ + @Nullable + @NativeType("char const *") + public static String glfwGetJoystickGUID(int jid) { + return null; + } + + // --- [ glfwSetJoystickUserPointer ] --- + + /** + * Sets the user pointer of the specified joystick. + * + *This function sets the user-defined pointer of the specified joystick. The current value is retained until the joystick is disconnected. The initial + * value is {@code NULL}.
+ * + *This function may be called from the joystick callback, even for a joystick that is being disconnected.
+ * + *This function may be called from any thread. Access is not synchronized.
+ * + * @param jid the joystick whose pointer to set + * @param pointer the new value + * + * @since version 3.3 + */ + public static void glfwSetJoystickUserPointer(int jid, @NativeType("void *") long pointer) { + + } + + // --- [ glfwGetJoystickUserPointer ] --- + + /** + * Returns the user pointer of the specified joystick. + * + *This function returns the current value of the user-defined pointer of the specified joystick. The initial value is {@code NULL}.
+ * + *This function may be called from the joystick callback, even for a joystick that is being disconnected.
+ * + *This function may be called from any thread. Access is not synchronized.
+ * + * @param jid the joystick whose pointer to set + * + * @since version 3.3 + */ + @NativeType("void *") + public static long glfwGetJoystickUserPointer(int jid) { + return 0; + } + + // --- [ glfwJoystickIsGamepad ] --- + + /** + * Returns whether the specified joystick is both present and has a gamepad mapping. + * + *If the specified joystick is present but does not have a gamepad mapping this function will return {@code false} but will not generate an error. Call + * {@link #glfwJoystickPresent JoystickPresent} to check if a joystick is present regardless of whether it has a mapping.
+ * + *This function must only be called from the main thread.
+ * + * @param jid the joystick id to query + * + * @return {@code true} if a joystick is both present and has a gamepad mapping or {@code false} otherwise + * + * @since version 3.3 + */ + @NativeType("int") + public static boolean glfwJoystickIsGamepad(int jid) { + return false; + } + + /** + * Sets the joystick configuration callback, or removes the currently set callback. This is called when a joystick is connected to or disconnected from + * the system. + * + *For joystick connection and disconnection events to be delivered on all platforms, you need to call one of the event processing functions. Joystick + * disconnection may also be detected and the callback called by joystick functions. The function will then return whatever it returns if the joystick is + * not present.
+ * + *This function must only be called from the main thread.
+ * + * @param cbfun the new callback, or {@code NULL} to remove the currently set callback + * + * @return the previously set callback, or {@code NULL} if no callback was set or the library had not been initialized + * + * @since version 3.2 + */ + @Nullable + @NativeType("GLFWjoystickfun") + public static GLFWJoystickCallback glfwSetJoystickCallback(@Nullable @NativeType("GLFWjoystickfun") GLFWJoystickCallbackI cbfun) { + return null; + } + + + /** + * Adds the specified SDL_GameControllerDB gamepad mappings. + * + *This function parses the specified ASCII encoded string and updates the internal list with any gamepad mappings it finds. This string may contain either + * a single gamepad mapping or many mappings separated by newlines. The parser supports the full format of the {@code gamecontrollerdb.txt} source file + * including empty lines and comments.
+ * + *See gamepad_mapping for a description of the format.
+ * + *If there is already a gamepad mapping for a given GUID in the internal list, it will be replaced by the one passed to this function. If the library is + * terminated and re-initialized the internal list will revert to the built-in default.
+ * + *This function must only be called from the main thread.
+ * + * @param string the string containing the gamepad mappings + * + * @return {@code true}, or {@code false} if an error occurred + * + * @since version 3.3 + */ + @NativeType("int") + public static boolean glfwUpdateGamepadMappings(@NativeType("char const *") ByteBuffer string) { + return false; + } + + /** + * Returns the human-readable name of the gamepad from the gamepad mapping assigned to the specified joystick. + * + *If the specified joystick is not present or does not have a gamepad mapping this function will return {@code NULL} but will not generate an error. Call + * {@link #glfwJoystickIsGamepad JoystickIsGamepad} to check if a joystick is present regardless of whether it has a mapping.
+ * + *The returned string is allocated and freed by GLFW. You should not free it yourself. It is valid until the specified joystick is disconnected, the + * gamepad mappings are updated or the library is terminated.
+ * + *This function must only be called from the main thread.
+ * + * @param jid the joystick to query + * + * @return the UTF-8 encoded name of the gamepad, or {@code NULL} if the joystick is not present, does not have a mapping or an error occurred + * + * @since version 3.3 + */ + @Nullable + @NativeType("char const *") + public static String glfwGetGamepadName(int jid) { + return null; + } + + /** + * Retrieves the state of the specified joystick remapped to an Xbox-like gamepad. + * + *If the specified joystick is not present or does not have a gamepad mapping this function will return {@link #GLFW_FALSE FALSE} but will not generate an error. Call + * {@link #glfwJoystickPresent JoystickPresent} to check whether it is present regardless of whether it has a mapping.
+ * + *The Guide button may not be available for input as it is often hooked by the system or the Steam client.
+ * + *Not all devices have all the buttons or axes provided by {@link GLFWGamepadState}. Unavailable buttons and axes will always report {@link #GLFW_RELEASE RELEASE} and 0.0 + * respectively.
+ * + *This function must only be called from the main thread.
+ * + * @param jid the joystick to query + * @param state the gamepad input state of the joystick + * + * @return {@code true} if successful, or {@code false} if no joystick is connected, it has no gamepad mapping or an error occurred + * + * @since version 3.3 + */ + @NativeType("int") + public static boolean glfwGetGamepadState(int jid, @NativeType("GLFWgamepadstate *") GLFWGamepadState state) { + return false; + } + + // --- [ glfwSetClipboardString ] --- + + /** Unsafe version of: {@link #glfwSetClipboardString SetClipboardString} */ + public static void nglfwSetClipboardString(long window, long string) { + long __functionAddress = Functions.SetClipboardString; + invokePPV(window, string, __functionAddress); + } + + /** + * Sets the system clipboard to the specified, UTF-8 encoded string. + * + *The specified string is copied before this function returns.
+ * + *Notes:
+ * + *The specified string is copied before this function returns.
+ * + *Notes:
+ * + *The returned string is allocated and freed by GLFW. You should not free it yourself. It is valid until the next call to {@link #glfwGetClipboardString GetClipboardString} or + * {@link #glfwSetClipboardString SetClipboardString}, or until the library is terminated.
+ * + *The resolution of the timer is system dependent, but is usually on the order of a few micro- or nanoseconds. It uses the highest-resolution monotonic + * time source on each supported platform.
+ * + *This function may be called from any thread. Reading and writing of the internal timer offset is not atomic, so it needs to be externally synchronized + * with calls to {@link #glfwSetTime SetTime}.
+ * + * @return the current value, in seconds, or zero if an error occurred + * + * @since version 1.0 + */ + public static double glfwGetTime() { + long __functionAddress = Functions.GetTime; + return invokeD(__functionAddress); + } + + // --- [ glfwSetTime ] --- + + /** + * Sets the value of the GLFW timer. It then continues to count up from that value. The value must be a positive finite number less than or equal to + * 18446744073.0, which is approximately 584.5 years. + * + *The upper limit of the timer is calculated as floor((264 - 1) / 109) and is due to implementations storing nanoseconds
+ * in 64 bits. The limit may be increased in the future.
This function may be called from any thread. Reading and writing of the internal timer offset is not atomic, so it needs to be externally synchronized + * with calls to {@link #glfwGetTime GetTime}.
+ * + * @param time the new value, in seconds + * + * @since version 2.2 + */ + public static void glfwSetTime(double time) { + long __functionAddress = Functions.SetTime; + invokeV(time, __functionAddress); + } + + // --- [ glfwGetTimerValue ] --- + + /** + * Returns the current value of the raw timer. + * + *This function returns the current value of the raw timer, measured in {@code 1 / frequency} seconds. To get the frequency, call {@link #glfwGetTimerFrequency GetTimerFrequency}.
+ * + *This function may be called from any thread.
+ * + * @return the value of the timer, or zero if an error occurred + * + * @since version 3.2 + */ + @NativeType("uint64_t") + public static long glfwGetTimerValue() { + long __functionAddress = Functions.GetTimerValue; + return invokeJ(__functionAddress); + } + + // --- [ glfwGetTimerFrequency ] --- + + /** + * Returns the frequency, in Hz, of the raw timer. + * + *This function may be called from any thread.
+ * + * @return the frequency of the timer, in Hz, or zero if an error occurred + * + * @since version 3.2 + */ + @NativeType("uint64_t") + public static long glfwGetTimerFrequency() { + long __functionAddress = Functions.GetTimerFrequency; + return invokeJ(__functionAddress); + } + + // --- [ glfwMakeContextCurrent ] --- + + /** + * Makes the OpenGL or OpenGL ES context of the specified window current on the calling thread. A context must only be made current on a single thread at + * a time and each thread can have only a single current context at a time. + * + *When moving a context between threads, you must make it non-current on the old thread before making it current on the new one.
+ * + *By default, making a context non-current implicitly forces a pipeline flush. On machines that support + * GL_KHR_context_flush_control, you can control whether + * a context performs this flush by setting the {@link #GLFW_CONTEXT_RELEASE_BEHAVIOR CONTEXT_RELEASE_BEHAVIOR} + * window hint.
+ * + *The specified window must have an OpenGL or OpenGL ES context. Specifying a window without a context will generate a {@link #GLFW_NO_WINDOW_CONTEXT NO_WINDOW_CONTEXT} error.
+ * + *This function may be called from any thread.
+ * + * @param window the window whose context to make current, or {@code NULL} to detach the current context + * + * @since version 3.0 + */ + public static void glfwMakeContextCurrent(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.MakeContextCurrent; + invokePV(window, __functionAddress); + } + + // --- [ glfwGetCurrentContext ] --- + + /** + * Returns the window whose OpenGL or OpenGL ES context is current on the calling thread. + * + *This function may be called from any thread.
+ * + * @return the window whose context is current, or {@code NULL} if no window's context is current + * + * @since version 3.0 + */ + @NativeType("GLFWwindow *") + public static long glfwGetCurrentContext() { + long __functionAddress = Functions.GetCurrentContext; + return invokeP(__functionAddress); + } + + // --- [ glfwSwapBuffers ] --- + + /** + * Swaps the front and back buffers of the specified window when rendering with OpenGL or OpenGL ES. If the swap interval is greater than zero, the GPU + * driver waits the specified number of screen updates before swapping the buffers. + * + *The specified window must have an OpenGL or OpenGL ES context. Specifying a window without a context will generate a {@link #GLFW_NO_WINDOW_CONTEXT NO_WINDOW_CONTEXT} error.
+ * + *This function does not apply to Vulkan. If you are rendering with Vulkan, {@code vkQueuePresentKHR} instead.
+ * + *EGL: The context of the specified window must be current on the calling thread.
+ * + *This function may be called from any thread.
+ * + * @param window the window whose buffers to swap + * + * @since version 1.0 + */ + public static void glfwSwapBuffers(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.SwapBuffers; + if (CHECKS) { + check(window); + } + invokePV(window, __functionAddress); + } + + // --- [ glfwSwapInterval ] --- + + /** + * Sets the swap interval for the current OpenGL or OpenGL ES context, i.e. the number of screen updates to wait from the time {@link #glfwSwapBuffers SwapBuffers} was called + * before swapping the buffers and returning. This is sometimes called vertical synchronization, vertical retrace synchronization or just + * vsync. + * + *A context that supports either of the + * WGL_EXT_swap_control_tear and + * GLX_EXT_swap_control_tear extensions also accepts + * negative swap intervals, which allows the driver to swap immediately even if a frame arrives a little bit late. You can check for these + * extensions with {@link #glfwExtensionSupported ExtensionSupported}. For more information about swap tearing, see the extension specifications.
+ * + *A context must be current on the calling thread. Calling this function without a current context will cause a {@link #GLFW_NO_CURRENT_CONTEXT NO_CURRENT_CONTEXT} error.
+ * + *This function does not apply to Vulkan. If you are rendering with Vulkan, see the present mode of your swapchain instead.
+ * + *A context must be current on the calling thread. Calling this function without a current context will cause a {@link #GLFW_NO_CURRENT_CONTEXT NO_CURRENT_CONTEXT} error.
+ * + *As this functions retrieves and searches one or more extension strings each call, it is recommended that you cache its results if it is going to be used + * frequently. The extension strings will not change during the lifetime of a context, so there is no danger in doing this.
+ * + *This function does not apply to Vulkan. If you are using Vulkan, see {@code glfwGetRequiredInstanceExtensions}, + * {@code vkEnumerateInstanceExtensionProperties} and {@code vkEnumerateDeviceExtensionProperties} instead.
+ * + *This function may be called from any thread.
+ * + * @param extension the ASCII encoded name of the extension + * + * @return {@link #GLFW_TRUE TRUE} if the extension is available, or {@link #GLFW_FALSE FALSE} otherwise + * + * @since version 1.0 + */ + @NativeType("int") + public static boolean glfwExtensionSupported(@NativeType("char const *") ByteBuffer extension) { + if (CHECKS) { + checkNT1(extension); + } + return nglfwExtensionSupported(memAddress(extension)) != 0; + } + + /** + * Returns whether the specified API extension is supported by the current + * OpenGL or OpenGL ES context. It searches both for client API extension and context creation API extensions. + * + *A context must be current on the calling thread. Calling this function without a current context will cause a {@link #GLFW_NO_CURRENT_CONTEXT NO_CURRENT_CONTEXT} error.
+ * + *As this functions retrieves and searches one or more extension strings each call, it is recommended that you cache its results if it is going to be used + * frequently. The extension strings will not change during the lifetime of a context, so there is no danger in doing this.
+ * + *This function does not apply to Vulkan. If you are using Vulkan, see {@code glfwGetRequiredInstanceExtensions}, + * {@code vkEnumerateInstanceExtensionProperties} and {@code vkEnumerateDeviceExtensionProperties} instead.
+ * + *This function may be called from any thread.
+ * + * @param extension the ASCII encoded name of the extension + * + * @return {@link #GLFW_TRUE TRUE} if the extension is available, or {@link #GLFW_FALSE FALSE} otherwise + * + * @since version 1.0 + */ + @NativeType("int") + public static boolean glfwExtensionSupported(@NativeType("char const *") CharSequence extension) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nASCII(extension, true); + long extensionEncoded = stack.getPointerAddress(); + return nglfwExtensionSupported(extensionEncoded) != 0; + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glfwGetProcAddress ] --- + + /** Unsafe version of: {@link #glfwGetProcAddress GetProcAddress} */ + public static long nglfwGetProcAddress(long procname) { + long __functionAddress = Functions.GetProcAddress; + return invokePP(procname, __functionAddress); + } + + /** + * Returns the address of the specified OpenGL or OpenGL ES core or extension function, if it is supported by the current context. + * + *A context must be current on the calling thread. Calling this function without a current context will cause a {@link #GLFW_NO_CURRENT_CONTEXT NO_CURRENT_CONTEXT} error.
+ * + *This function does not apply to Vulkan. If you are rendering with Vulkan, {@code glfwGetInstanceProcAddress}, {@code vkGetInstanceProcAddr} and + * {@code vkGetDeviceProcAddr} instead.
+ * + *A context must be current on the calling thread. Calling this function without a current context will cause a {@link #GLFW_NO_CURRENT_CONTEXT NO_CURRENT_CONTEXT} error.
+ * + *This function does not apply to Vulkan. If you are rendering with Vulkan, {@code glfwGetInstanceProcAddress}, {@code vkGetInstanceProcAddr} and + * {@code vkGetDeviceProcAddr} instead.
+ * + *
+ * void (*) (
+ * GLFWwindow *window,
+ * unsigned int codepoint
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * unsigned int codepoint
+ * )Deprecared: scheduled for removal in version 4.0.
+ * + *
+ * void (*) (
+ * GLFWwindow *window,
+ * unsigned int codepoint,
+ * int mods
+ * )Deprecared: scheduled for removal in version 4.0.
+ * + *
+ * void (*) (
+ * GLFWwindow *window,
+ * unsigned int codepoint,
+ * int mods
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int entered
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int entered
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * double xpos,
+ * double ypos
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * double xpos,
+ * double ypos
+ * )The callback function receives the cursor position, measured in screen coordinates but relative to the top-left corner of the window client area. On + * platforms that provide it, the full sub-pixel cursor position is passed on.
+ * + * @param window the window that received the event + * @param xpos the new cursor x-coordinate, relative to the left edge of the content area + * @param ypos the new cursor y-coordinate, relative to the top edge of the content area + */ + void invoke(@NativeType("GLFWwindow *") long window, double xpos, double ypos); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWDropCallback.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWDropCallback.java new file mode 100644 index 00000000..eaf831c2 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWDropCallback.java @@ -0,0 +1,101 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import javax.annotation.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; + +import static org.lwjgl.glfw.GLFW.*; + +/** + * Instances of this class may be passed to the {@link GLFW#glfwSetDropCallback SetDropCallback} method. + * + *
+ * void (*) (
+ * GLFWwindow *window,
+ * int count,
+ * char const **names
+ * )This method may only be used inside a {@code GLFWDropCallback} invocation.
+ * + * @param names pointer to the array of UTF-8 encoded path names of the dropped files + * @param index the index to decode + * + * @return the name at the specified index as a String + */ + public static String getName(long names, int index) { + return memUTF8(memGetAddress(names + Pointer.POINTER_SIZE * index)); + } + + /** See {@link GLFW#glfwSetDropCallback SetDropCallback}. */ + public GLFWDropCallback set(long window) { + glfwSetDropCallback(window, this); + return this; + } + + private static final class Container extends GLFWDropCallback { + + private final GLFWDropCallbackI delegate; + + Container(long functionPointer, GLFWDropCallbackI delegate) { + super(functionPointer); + this.delegate = delegate; + } + + @Override + public void invoke(long window, int count, long names) { + delegate.invoke(window, count, names); + } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWDropCallbackI.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWDropCallbackI.java new file mode 100644 index 00000000..7528629e --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWDropCallbackI.java @@ -0,0 +1,53 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.dyncall.DynCallback.*; + +/** + * Instances of this interface may be passed to the {@link GLFW#glfwSetDropCallback SetDropCallback} method. + * + *
+ * void (*) (
+ * GLFWwindow *window,
+ * int count,
+ * char const **names
+ * )
+ * void (*) (
+ * int error,
+ * char *description
+ * )This method may only be used inside a GLFWErrorCallback invocation.
+ * + * @param description pointer to the UTF-8 encoded description string + * + * @return the description as a String + */ + public static String getDescription(long description) { + return memUTF8(description); + } + + /** + * Returns a {@link GLFWErrorCallback} instance that prints the error to the {@link APIUtil#DEBUG_STREAM}. + * + * @return the GLFWerrorCallback + */ + public static GLFWErrorCallback createPrint() { + return createPrint(APIUtil.DEBUG_STREAM); + } + + /** + * Returns a {@link GLFWErrorCallback} instance that prints the error in the specified {@link PrintStream}. + * + * @param stream the PrintStream to use + * + * @return the GLFWerrorCallback + */ + public static GLFWErrorCallback createPrint(PrintStream stream) { + return new GLFWErrorCallback() { + private Map
+ * void (*) (
+ * int error,
+ * char *description
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int width,
+ * int height
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int width,
+ * int height
+ * )
+ * struct GLFWgamepadstate {
+ * unsigned char buttons[15];
+ * float axes[6];
+ * }The created instance holds a strong reference to the container object.
+ */ + public GLFWGamepadState(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns a {@link ByteBuffer} view of the {@code buttons} field. */ + @NativeType("unsigned char[15]") + public ByteBuffer buttons() { return nbuttons(address()); } + /** Returns the value at the specified index of the {@code buttons} field. */ + @NativeType("unsigned char") + public byte buttons(int index) { return nbuttons(address(), index); } + /** Returns a {@link FloatBuffer} view of the {@code axes} field. */ + @NativeType("float[6]") + public FloatBuffer axes() { return naxes(address()); } + /** Returns the value at the specified index of the {@code axes} field. */ + public float axes(int index) { return naxes(address(), index); } + + /** Copies the specified {@link ByteBuffer} to the {@code buttons} field. */ + public GLFWGamepadState buttons(@NativeType("unsigned char[15]") ByteBuffer value) { nbuttons(address(), value); return this; } + /** Sets the specified value at the specified index of the {@code buttons} field. */ + public GLFWGamepadState buttons(int index, @NativeType("unsigned char") byte value) { nbuttons(address(), index, value); return this; } + /** Copies the specified {@link FloatBuffer} to the {@code axes} field. */ + public GLFWGamepadState axes(@NativeType("float[6]") FloatBuffer value) { naxes(address(), value); return this; } + /** Sets the specified value at the specified index of the {@code axes} field. */ + public GLFWGamepadState axes(int index, float value) { naxes(address(), index, value); return this; } + + /** Initializes this struct with the specified values. */ + public GLFWGamepadState set( + ByteBuffer buttons, + FloatBuffer axes + ) { + buttons(buttons); + axes(axes); + + return this; + } + + /** + * Copies the specified struct data to this struct. + * + * @param src the source struct + * + * @return this struct + */ + public GLFWGamepadState set(GLFWGamepadState src) { + memCopy(src.address(), address(), SIZEOF); + return this; + } + + // ----------------------------------- + + /** Returns a new {@code GLFWGamepadState} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static GLFWGamepadState malloc() { + return wrap(GLFWGamepadState.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code GLFWGamepadState} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static GLFWGamepadState calloc() { + return wrap(GLFWGamepadState.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code GLFWGamepadState} instance allocated with {@link BufferUtils}. */ + public static GLFWGamepadState create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(GLFWGamepadState.class, memAddress(container), container); + } + + /** Returns a new {@code GLFWGamepadState} instance for the specified memory address. */ + public static GLFWGamepadState create(long address) { + return wrap(GLFWGamepadState.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static GLFWGamepadState createSafe(long address) { + return address == NULL ? null : wrap(GLFWGamepadState.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code GLFWGamepadState} instance allocated on the thread-local {@link MemoryStack}. */ + public static GLFWGamepadState mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code GLFWGamepadState} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static GLFWGamepadState callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code GLFWGamepadState} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static GLFWGamepadState mallocStack(MemoryStack stack) { + return wrap(GLFWGamepadState.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code GLFWGamepadState} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static GLFWGamepadState callocStack(MemoryStack stack) { + return wrap(GLFWGamepadState.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #buttons}. */ + public static ByteBuffer nbuttons(long struct) { return memByteBuffer(struct + GLFWGamepadState.BUTTONS, 15); } + /** Unsafe version of {@link #buttons(int) buttons}. */ + public static byte nbuttons(long struct, int index) { + return UNSAFE.getByte(null, struct + GLFWGamepadState.BUTTONS + check(index, 15) * 1); + } + /** Unsafe version of {@link #axes}. */ + public static FloatBuffer naxes(long struct) { return memFloatBuffer(struct + GLFWGamepadState.AXES, 6); } + /** Unsafe version of {@link #axes(int) axes}. */ + public static float naxes(long struct, int index) { + return UNSAFE.getFloat(null, struct + GLFWGamepadState.AXES + check(index, 6) * 4); + } + + /** Unsafe version of {@link #buttons(ByteBuffer) buttons}. */ + public static void nbuttons(long struct, ByteBuffer value) { + if (CHECKS) { checkGT(value, 15); } + memCopy(memAddress(value), struct + GLFWGamepadState.BUTTONS, value.remaining() * 1); + } + /** Unsafe version of {@link #buttons(int, byte) buttons}. */ + public static void nbuttons(long struct, int index, byte value) { + UNSAFE.putByte(null, struct + GLFWGamepadState.BUTTONS + check(index, 15) * 1, value); + } + /** Unsafe version of {@link #axes(FloatBuffer) axes}. */ + public static void naxes(long struct, FloatBuffer value) { + if (CHECKS) { checkGT(value, 6); } + memCopy(memAddress(value), struct + GLFWGamepadState.AXES, value.remaining() * 4); + } + /** Unsafe version of {@link #axes(int, float) axes}. */ + public static void naxes(long struct, int index, float value) { + UNSAFE.putFloat(null, struct + GLFWGamepadState.AXES + check(index, 6) * 4, value); + } + + // ----------------------------------- + + /** An array of {@link GLFWGamepadState} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected GLFWGamepadState getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns a {@link ByteBuffer} view of the {@code buttons} field. */ + @NativeType("unsigned char[15]") + public ByteBuffer buttons() { return GLFWGamepadState.nbuttons(address()); } + /** Returns the value at the specified index of the {@code buttons} field. */ + @NativeType("unsigned char") + public byte buttons(int index) { return GLFWGamepadState.nbuttons(address(), index); } + /** Returns a {@link FloatBuffer} view of the {@code axes} field. */ + @NativeType("float[6]") + public FloatBuffer axes() { return GLFWGamepadState.naxes(address()); } + /** Returns the value at the specified index of the {@code axes} field. */ + public float axes(int index) { return GLFWGamepadState.naxes(address(), index); } + + /** Copies the specified {@link ByteBuffer} to the {@code buttons} field. */ + public Buffer buttons(@NativeType("unsigned char[15]") ByteBuffer value) { GLFWGamepadState.nbuttons(address(), value); return this; } + /** Sets the specified value at the specified index of the {@code buttons} field. */ + public Buffer buttons(int index, @NativeType("unsigned char") byte value) { GLFWGamepadState.nbuttons(address(), index, value); return this; } + /** Copies the specified {@link FloatBuffer} to the {@code axes} field. */ + public Buffer axes(@NativeType("float[6]") FloatBuffer value) { GLFWGamepadState.naxes(address(), value); return this; } + /** Sets the specified value at the specified index of the {@code axes} field. */ + public Buffer axes(int index, float value) { GLFWGamepadState.naxes(address(), index, value); return this; } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWGammaRamp.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWGammaRamp.java new file mode 100644 index 00000000..a3e4d808 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWGammaRamp.java @@ -0,0 +1,384 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.MemoryStack.*; + +/** + * Describes the gamma ramp for a monitor. + * + *
+ * struct GLFWgammaramp {
+ * unsigned short * red;
+ * unsigned short * green;
+ * unsigned short * blue;
+ * unsigned int size;
+ * }The created instance holds a strong reference to the container object.
+ */ + public GLFWGammaRamp(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns a {@link ShortBuffer} view of the data pointed to by the {@code red} field. */ + @NativeType("unsigned short *") + public ShortBuffer red() { return nred(address()); } + /** Returns a {@link ShortBuffer} view of the data pointed to by the {@code green} field. */ + @NativeType("unsigned short *") + public ShortBuffer green() { return ngreen(address()); } + /** Returns a {@link ShortBuffer} view of the data pointed to by the {@code blue} field. */ + @NativeType("unsigned short *") + public ShortBuffer blue() { return nblue(address()); } + /** Returns the value of the {@code size} field. */ + @NativeType("unsigned int") + public int size() { return nsize(address()); } + + /** Sets the address of the specified {@link ShortBuffer} to the {@code red} field. */ + public GLFWGammaRamp red(@NativeType("unsigned short *") ShortBuffer value) { nred(address(), value); return this; } + /** Sets the address of the specified {@link ShortBuffer} to the {@code green} field. */ + public GLFWGammaRamp green(@NativeType("unsigned short *") ShortBuffer value) { ngreen(address(), value); return this; } + /** Sets the address of the specified {@link ShortBuffer} to the {@code blue} field. */ + public GLFWGammaRamp blue(@NativeType("unsigned short *") ShortBuffer value) { nblue(address(), value); return this; } + /** Sets the specified value to the {@code size} field. */ + public GLFWGammaRamp size(@NativeType("unsigned int") int value) { nsize(address(), value); return this; } + + /** Initializes this struct with the specified values. */ + public GLFWGammaRamp set( + ShortBuffer red, + ShortBuffer green, + ShortBuffer blue, + int size + ) { + red(red); + green(green); + blue(blue); + size(size); + + return this; + } + + /** + * Copies the specified struct data to this struct. + * + * @param src the source struct + * + * @return this struct + */ + public GLFWGammaRamp set(GLFWGammaRamp src) { + memCopy(src.address(), address(), SIZEOF); + return this; + } + + // ----------------------------------- + + /** Returns a new {@code GLFWGammaRamp} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static GLFWGammaRamp malloc() { + return wrap(GLFWGammaRamp.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code GLFWGammaRamp} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static GLFWGammaRamp calloc() { + return wrap(GLFWGammaRamp.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code GLFWGammaRamp} instance allocated with {@link BufferUtils}. */ + public static GLFWGammaRamp create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(GLFWGammaRamp.class, memAddress(container), container); + } + + /** Returns a new {@code GLFWGammaRamp} instance for the specified memory address. */ + public static GLFWGammaRamp create(long address) { + return wrap(GLFWGammaRamp.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static GLFWGammaRamp createSafe(long address) { + return address == NULL ? null : wrap(GLFWGammaRamp.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code GLFWGammaRamp} instance allocated on the thread-local {@link MemoryStack}. */ + public static GLFWGammaRamp mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code GLFWGammaRamp} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static GLFWGammaRamp callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code GLFWGammaRamp} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static GLFWGammaRamp mallocStack(MemoryStack stack) { + return wrap(GLFWGammaRamp.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code GLFWGammaRamp} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static GLFWGammaRamp callocStack(MemoryStack stack) { + return wrap(GLFWGammaRamp.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #red() red}. */ + public static ShortBuffer nred(long struct) { return memShortBuffer(memGetAddress(struct + GLFWGammaRamp.RED), nsize(struct)); } + /** Unsafe version of {@link #green() green}. */ + public static ShortBuffer ngreen(long struct) { return memShortBuffer(memGetAddress(struct + GLFWGammaRamp.GREEN), nsize(struct)); } + /** Unsafe version of {@link #blue() blue}. */ + public static ShortBuffer nblue(long struct) { return memShortBuffer(memGetAddress(struct + GLFWGammaRamp.BLUE), nsize(struct)); } + /** Unsafe version of {@link #size}. */ + public static int nsize(long struct) { return UNSAFE.getInt(null, struct + GLFWGammaRamp.SIZE); } + + /** Unsafe version of {@link #red(ShortBuffer) red}. */ + public static void nred(long struct, ShortBuffer value) { memPutAddress(struct + GLFWGammaRamp.RED, memAddress(value)); } + /** Unsafe version of {@link #green(ShortBuffer) green}. */ + public static void ngreen(long struct, ShortBuffer value) { memPutAddress(struct + GLFWGammaRamp.GREEN, memAddress(value)); } + /** Unsafe version of {@link #blue(ShortBuffer) blue}. */ + public static void nblue(long struct, ShortBuffer value) { memPutAddress(struct + GLFWGammaRamp.BLUE, memAddress(value)); } + /** Sets the specified value to the {@code size} field of the specified {@code struct}. */ + public static void nsize(long struct, int value) { UNSAFE.putInt(null, struct + GLFWGammaRamp.SIZE, value); } + + /** + * Validates pointer members that should not be {@code NULL}. + * + * @param struct the struct to validate + */ + public static void validate(long struct) { + check(memGetAddress(struct + GLFWGammaRamp.RED)); + check(memGetAddress(struct + GLFWGammaRamp.GREEN)); + check(memGetAddress(struct + GLFWGammaRamp.BLUE)); + } + + /** + * Calls {@link #validate(long)} for each struct contained in the specified struct array. + * + * @param array the struct array to validate + * @param count the number of structs in {@code array} + */ + public static void validate(long array, int count) { + for (int i = 0; i < count; i++) { + validate(array + Integer.toUnsignedLong(i) * SIZEOF); + } + } + + // ----------------------------------- + + /** An array of {@link GLFWGammaRamp} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected GLFWGammaRamp getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns a {@link ShortBuffer} view of the data pointed to by the {@code red} field. */ + @NativeType("unsigned short *") + public ShortBuffer red() { return GLFWGammaRamp.nred(address()); } + /** Returns a {@link ShortBuffer} view of the data pointed to by the {@code green} field. */ + @NativeType("unsigned short *") + public ShortBuffer green() { return GLFWGammaRamp.ngreen(address()); } + /** Returns a {@link ShortBuffer} view of the data pointed to by the {@code blue} field. */ + @NativeType("unsigned short *") + public ShortBuffer blue() { return GLFWGammaRamp.nblue(address()); } + /** Returns the value of the {@code size} field. */ + @NativeType("unsigned int") + public int size() { return GLFWGammaRamp.nsize(address()); } + + /** Sets the address of the specified {@link ShortBuffer} to the {@code red} field. */ + public Buffer red(@NativeType("unsigned short *") ShortBuffer value) { GLFWGammaRamp.nred(address(), value); return this; } + /** Sets the address of the specified {@link ShortBuffer} to the {@code green} field. */ + public Buffer green(@NativeType("unsigned short *") ShortBuffer value) { GLFWGammaRamp.ngreen(address(), value); return this; } + /** Sets the address of the specified {@link ShortBuffer} to the {@code blue} field. */ + public Buffer blue(@NativeType("unsigned short *") ShortBuffer value) { GLFWGammaRamp.nblue(address(), value); return this; } + /** Sets the specified value to the {@code size} field. */ + public Buffer size(@NativeType("unsigned int") int value) { GLFWGammaRamp.nsize(address(), value); return this; } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWImage.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWImage.java new file mode 100644 index 00000000..ca0f825e --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWImage.java @@ -0,0 +1,406 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import javax.annotation.*; + +import java.nio.*; + + +import org.lwjgl.*; +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.MemoryStack.*; + +/** + * Image data. + * + *This describes a single 2D image. See the documentation for each related function to see what the expected pixel format is.
+ * + *
+ * struct GLFWimage {
+ * int width;
+ * int height;
+ * unsigned char * pixels;
+ * }The created instance holds a strong reference to the container object.
+ */ + public GLFWImage(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code width} field. */ + public int width() { return nwidth(address()); } + /** Returns the value of the {@code height} field. */ + public int height() { return nheight(address()); } + /** + * Returns a {@link ByteBuffer} view of the data pointed to by the {@code pixels} field. + * + * @param capacity the number of elements in the returned buffer + */ + @NativeType("unsigned char *") + public ByteBuffer pixels(int capacity) { return npixels(address(), capacity); } + + /** Sets the specified value to the {@code width} field. */ + public GLFWImage width(int value) { nwidth(address(), value); return this; } + /** Sets the specified value to the {@code height} field. */ + public GLFWImage height(int value) { nheight(address(), value); return this; } + /** Sets the address of the specified {@link ByteBuffer} to the {@code pixels} field. */ + public GLFWImage pixels(@NativeType("unsigned char *") ByteBuffer value) { npixels(address(), value); return this; } + + /** Initializes this struct with the specified values. */ + public GLFWImage set( + int width, + int height, + ByteBuffer pixels + ) { + width(width); + height(height); + pixels(pixels); + + return this; + } + + /** + * Copies the specified struct data to this struct. + * + * @param src the source struct + * + * @return this struct + */ + public GLFWImage set(GLFWImage src) { + memCopy(src.address(), address(), SIZEOF); + return this; + } + + // ----------------------------------- + + /** Returns a new {@code GLFWImage} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static GLFWImage malloc() { + return wrap(GLFWImage.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code GLFWImage} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static GLFWImage calloc() { + return wrap(GLFWImage.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code GLFWImage} instance allocated with {@link BufferUtils}. */ + public static GLFWImage create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(GLFWImage.class, memAddress(container), container); + } + + /** Returns a new {@code GLFWImage} instance for the specified memory address. */ + public static GLFWImage create(long address) { + return wrap(GLFWImage.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static GLFWImage createSafe(long address) { + return address == NULL ? null : wrap(GLFWImage.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code GLFWImage} instance allocated on the thread-local {@link MemoryStack}. */ + public static GLFWImage mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code GLFWImage} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static GLFWImage callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code GLFWImage} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static GLFWImage mallocStack(MemoryStack stack) { + return malloc(stack); + } + + /** + * Returns a new {@code GLFWImage} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static GLFWImage callocStack(MemoryStack stack) { + return malloc(stack); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return malloc(capacity, stack); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return malloc(capacity, stack); + } + + // ----------------------------------- + + /** Unsafe version of {@link #width}. */ + public static int nwidth(long struct) { return UNSAFE.getInt(null, struct + GLFWImage.WIDTH); } + /** Unsafe version of {@link #height}. */ + public static int nheight(long struct) { return UNSAFE.getInt(null, struct + GLFWImage.HEIGHT); } + /** Unsafe version of {@link #pixels(int) pixels}. */ + public static ByteBuffer npixels(long struct, int capacity) { return memByteBuffer(memGetAddress(struct + GLFWImage.PIXELS), capacity); } + + /** Unsafe version of {@link #width(int) width}. */ + public static void nwidth(long struct, int value) { UNSAFE.putInt(null, struct + GLFWImage.WIDTH, value); } + /** Unsafe version of {@link #height(int) height}. */ + public static void nheight(long struct, int value) { UNSAFE.putInt(null, struct + GLFWImage.HEIGHT, value); } + /** Unsafe version of {@link #pixels(ByteBuffer) pixels}. */ + public static void npixels(long struct, ByteBuffer value) { memPutAddress(struct + GLFWImage.PIXELS, memAddress(value)); } + + /** + * Validates pointer members that should not be {@code NULL}. + * + * @param struct the struct to validate + */ + public static void validate(long struct) { + check(memGetAddress(struct + GLFWImage.PIXELS)); + } + + /** + * Calls {@link #validate(long)} for each struct contained in the specified struct array. + * + * @param array the struct array to validate + * @param count the number of structs in {@code array} + */ + public static void validate(long array, int count) { + for (int i = 0; i < count; i++) { + validate(array + Integer.toUnsignedLong(i) * SIZEOF); + } + } + + // ----------------------------------- + + /** An array of {@link GLFWImage} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected GLFWImage getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code width} field. */ + public int width() { return GLFWImage.nwidth(address()); } + /** Returns the value of the {@code height} field. */ + public int height() { return GLFWImage.nheight(address()); } + /** + * Returns a {@link ByteBuffer} view of the data pointed to by the {@code pixels} field. + * + * @param capacity the number of elements in the returned buffer + */ + @NativeType("unsigned char *") + public ByteBuffer pixels(int capacity) { return GLFWImage.npixels(address(), capacity); } + + /** Sets the specified value to the {@code width} field. */ + public Buffer width(int value) { GLFWImage.nwidth(address(), value); return this; } + /** Sets the specified value to the {@code height} field. */ + public Buffer height(int value) { GLFWImage.nheight(address(), value); return this; } + /** Sets the address of the specified {@link ByteBuffer} to the {@code pixels} field. */ + public Buffer pixels(@NativeType("unsigned char *") ByteBuffer value) { GLFWImage.npixels(address(), value); return this; } + + } + /** + * Returns a new {@code GLFWImage} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static GLFWImage malloc(MemoryStack stack) { + return wrap(GLFWImage.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + // ----------------------------------- + /** + * Returns a new {@code GLFWImage} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static GLFWImage calloc(MemoryStack stack) { + return wrap(GLFWImage.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWJoystickCallback.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWJoystickCallback.java new file mode 100644 index 00000000..85efe06e --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWJoystickCallback.java @@ -0,0 +1,86 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import javax.annotation.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; + +import static org.lwjgl.glfw.GLFW.*; + +/** + * Instances of this class may be passed to the {@link GLFW#glfwSetJoystickCallback SetJoystickCallback} method. + * + *
+ * void (*) (
+ * int jid,
+ * int event
+ * )
+ * void (*) (
+ * int jid,
+ * int event
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int key,
+ * int scancode,
+ * int action,
+ * int mods
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int key,
+ * int scancode,
+ * int action,
+ * int mods
+ * )| {@link GLFW#GLFW_PRESS PRESS} | {@link GLFW#GLFW_RELEASE RELEASE} | {@link GLFW#GLFW_REPEAT REPEAT} |
+ * void (*) (
+ * GLFWmonitor *monitor,
+ * int event
+ * )
+ * void (*) (
+ * GLFWmonitor *monitor,
+ * int event
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int button,
+ * int action,
+ * int mods
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int button,
+ * int action,
+ * int mods
+ * )| {@link GLFW#GLFW_PRESS PRESS} | {@link GLFW#GLFW_RELEASE RELEASE} | {@link GLFW#GLFW_REPEAT REPEAT} |
Note: This function may be called from any thread. Access is not synchronized.
+ * + * @param monitor the GLFW monitor + * + * @return The {@code CGDirectDisplayID} of the specified monitor, or {@code kCGNullDirectDisplay} if an error occurred. + * + * @since version 3.1 + */ + @NativeType("CGDirectDisplayID") + public static int glfwGetCocoaMonitor(@NativeType("GLFWmonitor *") long monitor) { + long __functionAddress = Functions.GetCocoaMonitor; + if (CHECKS) { + check(monitor); + } + return invokePI(monitor, __functionAddress); + } + + // --- [ glfwGetCocoaWindow ] --- + + /** + * Returns the {@code NSWindow} of the specified GLFW window. + * + *Note: This function may be called from any thread. Access is not synchronized.
+ * + * @param window the GLFW window + * + * @return The {@code NSWindow} of the specified window, or nil if an error occurred. + * + * @since version 3.0 + */ + @NativeType("id") + public static long glfwGetCocoaWindow(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.GetCocoaWindow; + if (CHECKS) { + check(window); + } + return invokePP(window, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeEGL.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeEGL.java new file mode 100644 index 00000000..12ee07a5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeEGL.java @@ -0,0 +1,94 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + + +/** Native bindings to the GLFW library's EGL native access functions. */ +public class GLFWNativeEGL { + + protected GLFWNativeEGL() { + throw new UnsupportedOperationException(); + } + + /** Contains the function pointers loaded from {@code GLFW.getLibrary()}. */ + public static final class Functions { + + private Functions() {} + + /** Function address. */ + public static final long + GetEGLDisplay = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetEGLDisplay"), + GetEGLContext = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetEGLContext"), + GetEGLSurface = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetEGLSurface"); + + } + + // --- [ glfwGetEGLDisplay ] --- + + /** + * Returns the {@code EGLDisplay} used by GLFW. + * + *This function may be called from any thread. Access is not synchronized.
+ * + * @return the {@code EGLDisplay} used by GLFW, or {@link EGL10#EGL_NO_DISPLAY} if an error occured + * + * @since version 3.0 + */ + @NativeType("EGLDisplay") + public static long glfwGetEGLDisplay() { + long __functionAddress = Functions.GetEGLDisplay; + return invokeP(__functionAddress); + } + + // --- [ glfwGetEGLContext ] --- + + /** + * Returns the {@code EGLContext} of the specified window. + * + *This function may be called from any thread. Access is not synchronized.
+ * + * @param window a GLFW window + * + * @return the {@code EGLContext} of the specified window, or {@link EGL10#EGL_NO_CONTEXT} if an error occurred + * + * @since version 3.0 + */ + @NativeType("EGLContext") + public static long glfwGetEGLContext(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.GetEGLContext; + if (CHECKS) { + check(window); + } + return invokePP(window, __functionAddress); + } + + // --- [ glfwGetEGLSurface ] --- + + /** + * Returns the {@code EGLSurface} of the specified window. + * + *This function may be called from any thread. Access is not synchronized.
+ * + * @return the {@code EGLSurface} of the specified window, or {@link EGL10#EGL_NO_SURFACE} if an error occurred + * + * @since version 3.0 + */ + @NativeType("EGLSurface") + public static long glfwGetEGLSurface(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.GetEGLSurface; + if (CHECKS) { + check(window); + } + return invokePP(window, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeGLX.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeGLX.java new file mode 100644 index 00000000..eeef6728 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeGLX.java @@ -0,0 +1,77 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** Native bindings to the GLFW library's GLX native access functions. */ +public class GLFWNativeGLX { + + protected GLFWNativeGLX() { + throw new UnsupportedOperationException(); + } + + /** Contains the function pointers loaded from {@code GLFW.getLibrary()}. */ + public static final class Functions { + + private Functions() {} + + /** Function address. */ + public static final long + GetGLXContext = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetGLXContext"), + GetGLXWindow = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetGLXWindow"); + + } + + // --- [ glfwGetGLXContext ] --- + + /** + * Returns the {@code GLXContext} of the specified window. + * + *This function may be called from any thread. Access is not synchronized.
+ * + * @param window a GLFW window + * + * @return the {@code GLXContext} of the specified window, or {@code NULL} if an error occurred. + * + * @since version 3.0 + */ + @NativeType("GLXContext") + public static long glfwGetGLXContext(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.GetGLXContext; + if (CHECKS) { + check(window); + } + return invokePP(window, __functionAddress); + } + + // --- [ glfwGetGLXWindow ] --- + + /** + * Returns the {@code GLXWindow} of the specified window. + * + *This function may be called from any thread. Access is not synchronized.
+ * + * @param window a GLFW window + * + * @return the {@code GLXWindow} of the specified window, or {@code None} if an error occurred. + * + * @since version 3.2 + */ + @NativeType("GLXWindow") + public static long glfwGetGLXWindow(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.GetGLXWindow; + if (CHECKS) { + check(window); + } + return invokePP(window, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeNSGL.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeNSGL.java new file mode 100644 index 00000000..c025b9dc --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeNSGL.java @@ -0,0 +1,54 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** Native bindings to the GLFW library's NSGL native access functions. */ +public class GLFWNativeNSGL { + + protected GLFWNativeNSGL() { + throw new UnsupportedOperationException(); + } + + /** Contains the function pointers loaded from {@code GLFW.getLibrary()}. */ + public static final class Functions { + + private Functions() {} + + /** Function address. */ + public static final long + GetNSGLContext = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetNSGLContext"); + + } + + // --- [ glfwGetNSGLContext ] --- + + /** + * Returns the {@code NSOpenGLContext} of the specified GLFW window. + * + *Note: This function may be called from any thread. Access is not synchronized.
+ * + * @param window the GLFW window + * + * @return The {@code NSOpenGLContext} of the specified window, or nil if an error occurred. + * + * @since version 3.0 + */ + @NativeType("id") + public static long glfwGetNSGLContext(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.GetNSGLContext; + if (CHECKS) { + check(window); + } + return invokePP(window, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeWGL.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeWGL.java new file mode 100644 index 00000000..69f2688b --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeWGL.java @@ -0,0 +1,54 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** Native bindings to the GLFW library's WGL native access functions. */ +public class GLFWNativeWGL { + + protected GLFWNativeWGL() { + throw new UnsupportedOperationException(); + } + + /** Contains the function pointers loaded from {@code GLFW.getLibrary()}. */ + public static final class Functions { + + private Functions() {} + + /** Function address. */ + public static final long + GetWGLContext = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetWGLContext"); + + } + + // --- [ glfwGetWGLContext ] --- + + /** + * Returns the {@code HGLRC} of the specified window. + * + *Note: This function may be called from any thread. Access is not synchronized.
+ * + * @param window the GLFW window + * + * @return The {@code HGLRC} of the specified window, or {@code NULL} if an error occurred. + * + * @since version 3.0 + */ + @NativeType("HGLRC") + public static long glfwGetWGLContext(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.GetWGLContext; + if (CHECKS) { + check(window); + } + return invokePP(window, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeWayland.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeWayland.java new file mode 100644 index 00000000..50fae437 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeWayland.java @@ -0,0 +1,91 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** Native bindings to the GLFW library's Wayland native access functions. */ +public class GLFWNativeWayland { + + protected GLFWNativeWayland() { + throw new UnsupportedOperationException(); + } + + /** Contains the function pointers loaded from {@code GLFW.getLibrary()}. */ + public static final class Functions { + + private Functions() {} + + /** Function address. */ + public static final long + GetWaylandDisplay = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetWaylandDisplay"), + GetWaylandMonitor = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetWaylandMonitor"), + GetWaylandWindow = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetWaylandWindow"); + + } + + // --- [ glfwGetWaylandDisplay ] --- + + /** + * Returns the {@code struct wl_display*} used by GLFW. + * + *This function may be called from any thread. Access is not synchronized.
+ * + * @return the {@code struct wl_display*} used by GLFW, or {@code NULL} if an error occurred. + * + * @since version 3.2 + */ + @NativeType("struct wl_display *") + public static long glfwGetWaylandDisplay() { + long __functionAddress = Functions.GetWaylandDisplay; + return invokeP(__functionAddress); + } + + // --- [ glfwGetWaylandMonitor ] --- + + /** + * Returns the {@code struct wl_output*} of the specified monitor. + * + *This function may be called from any thread. Access is not synchronized.
+ * + * @return the {@code struct wl_output*} of the specified monitor, or {@code NULL} if an error occurred. + * + * @since version 3.2 + */ + @NativeType("struct wl_output *") + public static long glfwGetWaylandMonitor(@NativeType("GLFWmonitor *") long monitor) { + long __functionAddress = Functions.GetWaylandMonitor; + if (CHECKS) { + check(monitor); + } + return invokePP(monitor, __functionAddress); + } + + // --- [ glfwGetWaylandWindow ] --- + + /** + * Returns the main {@code struct wl_surface*} of the specified window. + * + *This function may be called from any thread. Access is not synchronized.
+ * + * @return the main {@code struct wl_surface*} of the specified window, or {@code NULL} if an error occurred. + * + * @since version 3.2 + */ + @NativeType("struct wl_surface *") + public static long glfwGetWaylandWindow(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.GetWaylandWindow; + if (CHECKS) { + check(window); + } + return invokePP(window, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeWin32.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeWin32.java new file mode 100644 index 00000000..d65d236a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeWin32.java @@ -0,0 +1,146 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import javax.annotation.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** Native bindings to the GLFW library's Win32 native access functions. */ +public class GLFWNativeWin32 { + + protected GLFWNativeWin32() { + throw new UnsupportedOperationException(); + } + + /** Contains the function pointers loaded from {@code GLFW.getLibrary()}. */ + public static final class Functions { + + private Functions() {} + + /** Function address. */ + public static final long + GetWin32Adapter = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetWin32Adapter"), + GetWin32Monitor = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetWin32Monitor"), + GetWin32Window = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetWin32Window"), + AttachWin32Window = apiGetFunctionAddress(GLFW.getLibrary(), "glfwAttachWin32Window"); + + } + + // --- [ glfwGetWin32Adapter ] --- + + /** Unsafe version of: {@link #glfwGetWin32Adapter GetWin32Adapter} */ + public static long nglfwGetWin32Adapter(long monitor) { + long __functionAddress = Functions.GetWin32Adapter; + if (CHECKS) { + check(monitor); + } + return invokePP(monitor, __functionAddress); + } + + /** + * Returns the adapter device name of the specified monitor. + * + *Note: This function may be called from any thread. Access is not synchronized.
+ * + * @param monitor the GLFW monitor + * + * @return the UTF-8 encoded adapter device name (for example `\\.\DISPLAY1`) of the specified monitor, or {@code NULL} if an error occurred + * + * @since version 3.1 + */ + @Nullable + @NativeType("char const *") + public static String glfwGetWin32Adapter(@NativeType("GLFWmonitor *") long monitor) { + long __result = nglfwGetWin32Adapter(monitor); + return memUTF8Safe(__result); + } + + // --- [ glfwGetWin32Monitor ] --- + + /** Unsafe version of: {@link #glfwGetWin32Monitor GetWin32Monitor} */ + public static long nglfwGetWin32Monitor(long monitor) { + long __functionAddress = Functions.GetWin32Monitor; + if (CHECKS) { + check(monitor); + } + return invokePP(monitor, __functionAddress); + } + + /** + * Returns the display device name of the specified monitor. + * + *Note: This function may be called from any thread. Access is not synchronized.
+ * + * @param monitor the GLFW monitor + * + * @return the UTF-8 encoded display device name (for example `\\.\DISPLAY1\Monitor0`) of the specified monitor, or {@code NULL} if an error occurred + * + * @since version 3.1 + */ + @Nullable + @NativeType("char const *") + public static String glfwGetWin32Monitor(@NativeType("GLFWmonitor *") long monitor) { + long __result = nglfwGetWin32Monitor(monitor); + return memUTF8Safe(__result); + } + + // --- [ glfwGetWin32Window ] --- + + /** + * Returns the {@code HWND} of the specified window. + * + *Note: This function may be called from any thread. Access is not synchronized.
+ * + * @param window the GLFW window + * + * @return the {@code HWND} of the specified window, or {@code NULL} if an error occurred + * + * @since version 3.0 + */ + @NativeType("HWND") + public static long glfwGetWin32Window(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.GetWin32Window; + if (CHECKS) { + check(window); + } + return invokePP(window, __functionAddress); + } + + // --- [ glfwAttachWin32Window ] --- + + /** + * Wraps an existing {@code HWND} in a new GLFW window object. + * + *This function creates a GLFW window object and its associated OpenGL or OpenGL ES context for an existing {@code HWND}. The {@code HWND} is not + * destroyed by GLFW.
+ * + *This function may be called from any thread.
+ * + *LWJGL: This functionality is experimental and not officially supported by GLFW yet.
+ * + * @param handle the {@code HWND} to attach to the window object + * @param share the window whose context to share resources with, or {@code NULL} to not share resources + * + * @return the handle of the created window, or {@code NULL} if an error occurred + * + * @since version 3.3 + */ + @NativeType("GLFWwindow *") + public static long glfwAttachWin32Window(@NativeType("HWND") long handle, @NativeType("GLFWwindow *") long share) { + long __functionAddress = Functions.AttachWin32Window; + if (CHECKS) { + check(handle); + } + return invokePPP(handle, share, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeX11.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeX11.java new file mode 100644 index 00000000..57fe2114 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWNativeX11.java @@ -0,0 +1,199 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** Native bindings to the GLFW library's X11 native access functions. */ +public class GLFWNativeX11 { + + protected GLFWNativeX11() { + throw new UnsupportedOperationException(); + } + + /** Contains the function pointers loaded from {@code GLFW.getLibrary()}. */ + public static final class Functions { + + private Functions() {} + + /** Function address. */ + public static final long + GetX11Display = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetX11Display"), + GetX11Adapter = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetX11Adapter"), + GetX11Monitor = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetX11Monitor"), + GetX11Window = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetX11Window"), + SetX11SelectionString = apiGetFunctionAddress(GLFW.getLibrary(), "glfwSetX11SelectionString"), + GetX11SelectionString = apiGetFunctionAddress(GLFW.getLibrary(), "glfwGetX11SelectionString"); + + } + + // --- [ glfwGetX11Display ] --- + + /** + * Returns the {@code Display} used by GLFW. + * + *Note: This function may be called from any thread. Access is not synchronized.
+ * + * @return The {@code Display} used by GLFW, or {@code NULL} if an error occurred. + * + * @since version 3.0 + */ + @NativeType("Display *") + public static long glfwGetX11Display() { + long __functionAddress = Functions.GetX11Display; + return invokeP(__functionAddress); + } + + // --- [ glfwGetX11Adapter ] --- + + /** + * Returns the {@code RRCrtc} of the specified monitor. + * + *Note: This function may be called from any thread. Access is not synchronized.
+ * + * @param monitor the GLFW monitor + * + * @return The {@code RRCrtc} of the specified monitor, or {@code None} if an error occurred. + * + * @since version 3.1 + */ + @NativeType("RRCrtc") + public static long glfwGetX11Adapter(@NativeType("GLFWmonitor *") long monitor) { + long __functionAddress = Functions.GetX11Adapter; + if (CHECKS) { + check(monitor); + } + return invokePN(monitor, __functionAddress); + } + + // --- [ glfwGetX11Monitor ] --- + + /** + * Returns the {@code RROutput} of the specified monitor. + * + *Note: This function may be called from any thread. Access is not synchronized.
+ * + * @param monitor the GLFW monitor + * + * @return The {@code RROutput} of the specified monitor, or {@code None} if an error occurred. + * + * @since version 3.1 + */ + @NativeType("RROutput") + public static long glfwGetX11Monitor(@NativeType("GLFWmonitor *") long monitor) { + long __functionAddress = Functions.GetX11Monitor; + if (CHECKS) { + check(monitor); + } + return invokePN(monitor, __functionAddress); + } + + // --- [ glfwGetX11Window ] --- + + /** + * Returns the {@code Window} of the specified window. + * + *Note: This function may be called from any thread. Access is not synchronized.
+ * + * @param window a GLFW window + * + * @return The {@code Window} of the specified window, or {@code None} if an error occurred. + * + * @since version 3.0 + */ + @NativeType("Window") + public static long glfwGetX11Window(@NativeType("GLFWwindow *") long window) { + long __functionAddress = Functions.GetX11Window; + if (CHECKS) { + check(window); + } + return invokePN(window, __functionAddress); + } + + // --- [ glfwSetX11SelectionString ] --- + + /** Unsafe version of: {@link #glfwSetX11SelectionString SetX11SelectionString} */ + public static void nglfwSetX11SelectionString(long string) { + long __functionAddress = Functions.SetX11SelectionString; + invokePV(string, __functionAddress); + } + + /** + * Sets the current primary selection to the specified string. + * + *This function must only be called from the main thread.
+ * + * @param string a UTF-8 encoded string. The specified string is copied before this function returns. + * + * @since version 3.3 + */ + public static void glfwSetX11SelectionString(@NativeType("char const *") ByteBuffer string) { + if (CHECKS) { + checkNT1(string); + } + nglfwSetX11SelectionString(memAddress(string)); + } + + /** + * Sets the current primary selection to the specified string. + * + *This function must only be called from the main thread.
+ * + * @param string a UTF-8 encoded string. The specified string is copied before this function returns. + * + * @since version 3.3 + */ + public static void glfwSetX11SelectionString(@NativeType("char const *") CharSequence string) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8(string, true); + long stringEncoded = stack.getPointerAddress(); + nglfwSetX11SelectionString(stringEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glfwGetX11SelectionString ] --- + + /** Unsafe version of: {@link #glfwGetX11SelectionString GetX11SelectionString} */ + public static long nglfwGetX11SelectionString() { + long __functionAddress = Functions.GetX11SelectionString; + return invokeP(__functionAddress); + } + + /** + * Returns the contents of the current primary selection as a string. + * + *If the selection is empty or if its contents cannot be converted, {@code NULL} is returned and a {@link GLFW#GLFW_FORMAT_UNAVAILABLE FORMAT_UNAVAILABLE} error is generated.
+ * + *The returned string is allocated and freed by GLFW. You should not free it yourself. It is valid until the next call to {@link #glfwGetX11SelectionString GetX11SelectionString} or + * {@link #glfwSetX11SelectionString SetX11SelectionString}, or until the library is terminated.
+ * + *This function must only be called from the main thread.
+ * + * @return the contents of the selection as a UTF-8 encoded string, or {@code NULL} if an error occurred + * + * @since version 3.3 + */ + @Nullable + @NativeType("char const *") + public static String glfwGetX11SelectionString() { + long __result = nglfwGetX11SelectionString(); + return memUTF8Safe(__result); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWScrollCallback.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWScrollCallback.java new file mode 100644 index 00000000..4a305a8b --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWScrollCallback.java @@ -0,0 +1,87 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import javax.annotation.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; + +import static org.lwjgl.glfw.GLFW.*; + +/** + * Instances of this class may be passed to the {@link GLFW#glfwSetScrollCallback SetScrollCallback} method. + * + *
+ * void (*) (
+ * GLFWwindow *window,
+ * double xoffset,
+ * double yoffset
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * double xoffset,
+ * double yoffset
+ * )
+ * struct GLFWvidmode {
+ * int width;
+ * int height;
+ * int redBits;
+ * int greenBits;
+ * int blueBits;
+ * int refreshRate;
+ * }The created instance holds a strong reference to the container object.
+ */ + public GLFWVidMode(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code width} field. */ + public int width() { return nwidth(address()); } + /** Returns the value of the {@code height} field. */ + public int height() { return nheight(address()); } + /** Returns the value of the {@code redBits} field. */ + public int redBits() { return nredBits(address()); } + /** Returns the value of the {@code greenBits} field. */ + public int greenBits() { return ngreenBits(address()); } + /** Returns the value of the {@code blueBits} field. */ + public int blueBits() { return nblueBits(address()); } + /** Returns the value of the {@code refreshRate} field. */ + public int refreshRate() { return nrefreshRate(address()); } + + // ----------------------------------- + + /** Returns a new {@code GLFWVidMode} instance for the specified memory address. */ + public static GLFWVidMode create(long address) { + return wrap(GLFWVidMode.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static GLFWVidMode createSafe(long address) { + return address == NULL ? null : wrap(GLFWVidMode.class, address); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #width}. */ + public static int nwidth(long struct) { return UNSAFE.getInt(null, struct + GLFWVidMode.WIDTH); } + /** Unsafe version of {@link #height}. */ + public static int nheight(long struct) { return UNSAFE.getInt(null, struct + GLFWVidMode.HEIGHT); } + /** Unsafe version of {@link #redBits}. */ + public static int nredBits(long struct) { return UNSAFE.getInt(null, struct + GLFWVidMode.REDBITS); } + /** Unsafe version of {@link #greenBits}. */ + public static int ngreenBits(long struct) { return UNSAFE.getInt(null, struct + GLFWVidMode.GREENBITS); } + /** Unsafe version of {@link #blueBits}. */ + public static int nblueBits(long struct) { return UNSAFE.getInt(null, struct + GLFWVidMode.BLUEBITS); } + /** Unsafe version of {@link #refreshRate}. */ + public static int nrefreshRate(long struct) { return UNSAFE.getInt(null, struct + GLFWVidMode.REFRESHRATE); } + + // ----------------------------------- + + /** An array of {@link GLFWVidMode} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected GLFWVidMode getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code width} field. */ + public int width() { return GLFWVidMode.nwidth(address()); } + /** Returns the value of the {@code height} field. */ + public int height() { return GLFWVidMode.nheight(address()); } + /** Returns the value of the {@code redBits} field. */ + public int redBits() { return GLFWVidMode.nredBits(address()); } + /** Returns the value of the {@code greenBits} field. */ + public int greenBits() { return GLFWVidMode.ngreenBits(address()); } + /** Returns the value of the {@code blueBits} field. */ + public int blueBits() { return GLFWVidMode.nblueBits(address()); } + /** Returns the value of the {@code refreshRate} field. */ + public int refreshRate() { return GLFWVidMode.nrefreshRate(address()); } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWWindowCloseCallback.java b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWWindowCloseCallback.java new file mode 100644 index 00000000..da74a99c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/glfw/GLFWWindowCloseCallback.java @@ -0,0 +1,85 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.glfw; + +import javax.annotation.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; + +import static org.lwjgl.glfw.GLFW.*; + +/** + * Instances of this class may be passed to the {@link GLFW#glfwSetWindowCloseCallback SetWindowCloseCallback} method. + * + *
+ * void (*) (
+ * GLFWwindow *window
+ * )
+ * void (*) (
+ * GLFWwindow *window
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * float xscale,
+ * float yscale
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * float xscale,
+ * float yscale
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int focused
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int focused
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int iconified
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int iconified
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int maximized
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int maximized
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int xpos,
+ * int ypos
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int xpos,
+ * int ypos
+ * )
+ * void (*) (
+ * GLFWwindow *window
+ * )
+ * void (*) (
+ * GLFWwindow *window
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int width,
+ * int height
+ * )
+ * void (*) (
+ * GLFWwindow *window,
+ * int width,
+ * int height
+ * )GLFW comes with extensive documentation, which you can read online here. The + * Frequently Asked Questions are also useful.
+ * + *On macOS the JVM must be started with the {@code -XstartOnFirstThread} argument for GLFW to work. This is necessary because most GLFW functions must be + * called on the main thread and the Cocoa API on macOS requires that thread to be the first thread in the process. For this reason, on-screen GLFW + * windows and the GLFW event loop are incompatible with other window toolkits (such as AWT/Swing or JavaFX) on macOS. Off-screen GLFW windows can be used + * with other window toolkits, but only if the window toolkit is initialized before GLFW.
+ */ +@org.lwjgl.system.NonnullDefault +package org.lwjgl.glfw; + diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/AL.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/AL.java new file mode 100644 index 00000000..67f9ddf6 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/AL.java @@ -0,0 +1,264 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + */ +package org.lwjgl.openal; + +import org.lwjgl.system.*; + +import javax.annotation.*; +import java.nio.*; +import java.util.*; + +import static org.lwjgl.openal.AL10.*; +import static org.lwjgl.openal.EXTThreadLocalContext.*; +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * This class must be used before any OpenAL function is called. It has the following responsibilities: + *Instances of {@code ALCapabilities} can be created with the {@link #createCapabilities} method. An OpenAL context must be current in the current thread + * or process before it is called. Calling this method is expensive, so {@code ALCapabilities} instances should be cached in user code.
+ * + *Before a function for a given OpenAL context can be called, the corresponding {@code ALCapabilities} instance must be made current in the current + * thread or process. The user is also responsible for clearing the current {@code ALCapabilities} instance when the context is destroyed or made current in + * another thread.
+ * + *Note that OpenAL contexts are made current process-wide by default. Current thread-local contexts are only available if the + * {@link EXTThreadLocalContext ALC_EXT_thread_local_context} extension is supported by the OpenAL implementation. OpenAL Soft, the implementation + * that LWJGL ships with, supports this extension and performs better when it is used.
+ * + * @see ALC + */ +public final class AL { + + @Nullable + private static FunctionProvider functionProvider; + + @Nullable + private static ALCapabilities processCaps; + + private static final ThreadLocalIf the current thread had a context current (see {@link #setCurrentThread}), those {@code ALCapabilities} are cleared. Any OpenAL functions called in + * the current thread, or any threads that have no context current, will use the specified {@code ALCapabilities}.
+ * + * @param caps the {@link ALCapabilities} to make current, or null + */ + public static void setCurrentProcess(@Nullable ALCapabilities caps) { + processCaps = caps; + capabilitiesTLS.set(null); // See EXT_thread_local_context, second Q. + icd.set(caps); + } + + /** + * Sets the specified {@link ALCapabilities} for the current OpenAL context in the current thread. + * + *Any OpenAL functions called in the current thread will use the specified {@code ALCapabilities}.
+ * + * @param caps the {@link ALCapabilities} to make current, or null + */ + public static void setCurrentThread(@Nullable ALCapabilities caps) { + capabilitiesTLS.set(caps); + icd.set(caps); + } + + /** + * Returns the {@link ALCapabilities} for the OpenAL context that is current in the current thread or process. + * + * @throws IllegalStateException if no OpenAL context is current in the current thread or process + */ + public static ALCapabilities getCapabilities() { + ALCapabilities caps = capabilitiesTLS.get(); + if (caps == null) { + caps = processCaps; + } + + return checkCapabilities(caps); + } + + private static ALCapabilities checkCapabilities(@Nullable ALCapabilities caps) { + if (caps == null) { + throw new IllegalStateException( + "No ALCapabilities instance set for the current thread or process. Possible solutions:\n" + + "\ta) Call AL.createCapabilities() after making a context current.\n" + + "\tb) Call AL.setCurrentProcess() or AL.setCurrentThread() if an ALCapabilities instance already exists." + ); + } + return caps; + } + + /** + * Creates a new {@link ALCapabilities} instance for the OpenAL context that is current in the current thread or process. + * + * @param alcCaps the {@link ALCCapabilities} of the device associated with the current context + * + * @return the ALCapabilities instance + */ + public static ALCapabilities createCapabilities(ALCCapabilities alcCaps) { + FunctionProvider functionProvider = ALC.check(AL.functionProvider); + + ALCapabilities caps = null; + + try { + long GetString = functionProvider.getFunctionAddress("alGetString"); + long GetError = functionProvider.getFunctionAddress("alGetError"); + long IsExtensionPresent = functionProvider.getFunctionAddress("alIsExtensionPresent"); + if (GetString == NULL || GetError == NULL || IsExtensionPresent == NULL) { + throw new IllegalStateException("Core OpenAL functions could not be found. Make sure that the OpenAL library has been loaded correctly."); + } + + String versionString = memASCIISafe(invokeP(AL_VERSION, GetString)); + if (versionString == null || invokeI(GetError) != AL_NO_ERROR) { + throw new IllegalStateException("There is no OpenAL context current in the current thread or process."); + } + + APIVersion apiVersion = apiParseVersion(versionString); + + int majorVersion = apiVersion.major; + int minorVersion = apiVersion.minor; + + int[][] AL_VERSIONS = { + {0, 1} // OpenAL 1 + }; + + SetThis is the default implementation that skips the thread/process lookup. When a new ALCapabilities is set, we compare it to the write-once + * capabilities. If different function pointers are found, we fall back to the expensive lookup. This will never happen with the OpenAL-Soft + * implementation.
+ */ + private static class ICDStatic implements ICD { + + @Nullable + private static ALCapabilities tempCaps; + + @Override + public void set(@Nullable ALCapabilities caps) { + if (tempCaps == null) { + tempCaps = caps; + } else if (caps != null && caps != tempCaps && ThreadLocalUtil.areCapabilitiesDifferent(tempCaps.addresses, caps.addresses)) { + apiLog("[WARNING] Incompatible context detected. Falling back to thread/process lookup for AL contexts."); + icd = AL::getCapabilities; // fall back to thread/process lookup + } + } + + @Override + @Nullable + public ALCapabilities get() { + return WriteOnce.caps; + } + + private static final class WriteOnce { + // This will be initialized the first time get() above is called + @Nullable + static final ALCapabilities caps = ICDStatic.tempCaps; + + static { + if (caps == null) { + throw new IllegalStateException("No ALCapabilities instance has been set"); + } + } + } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/AL10.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/AL10.java new file mode 100644 index 00000000..2aed8341 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/AL10.java @@ -0,0 +1,1878 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** Native bindings to AL 1.0 functionality. */ +public class AL10 { + + /** General tokens. */ + public static final int + AL_INVALID = 0xFFFFFFFF, + AL_NONE = 0x0, + AL_FALSE = 0x0, + AL_TRUE = 0x1; + + /** Error conditions. */ + public static final int + AL_NO_ERROR = 0x0, + AL_INVALID_NAME = 0xA001, + AL_INVALID_ENUM = 0xA002, + AL_INVALID_VALUE = 0xA003, + AL_INVALID_OPERATION = 0xA004, + AL_OUT_OF_MEMORY = 0xA005; + + /** Numerical queries. */ + public static final int + AL_DOPPLER_FACTOR = 0xC000, + AL_DISTANCE_MODEL = 0xD000; + + /** String queries. */ + public static final int + AL_VENDOR = 0xB001, + AL_VERSION = 0xB002, + AL_RENDERER = 0xB003, + AL_EXTENSIONS = 0xB004; + + /** Distance attenuation models. */ + public static final int + AL_INVERSE_DISTANCE = 0xD001, + AL_INVERSE_DISTANCE_CLAMPED = 0xD002; + + /** Source types. */ + public static final int + AL_SOURCE_ABSOLUTE = 0x201, + AL_SOURCE_RELATIVE = 0x202; + + /** Listener and Source attributes. */ + public static final int + AL_POSITION = 0x1004, + AL_VELOCITY = 0x1006, + AL_GAIN = 0x100A; + + /** Source attributes. */ + public static final int + AL_CONE_INNER_ANGLE = 0x1001, + AL_CONE_OUTER_ANGLE = 0x1002, + AL_PITCH = 0x1003, + AL_DIRECTION = 0x1005, + AL_LOOPING = 0x1007, + AL_BUFFER = 0x1009, + AL_SOURCE_STATE = 0x1010, + AL_CONE_OUTER_GAIN = 0x1022, + AL_SOURCE_TYPE = 0x1027; + + /** Source state. */ + public static final int + AL_INITIAL = 0x1011, + AL_PLAYING = 0x1012, + AL_PAUSED = 0x1013, + AL_STOPPED = 0x1014; + + /** Listener attributes. */ + public static final int AL_ORIENTATION = 0x100F; + + /** Queue state. */ + public static final int + AL_BUFFERS_QUEUED = 0x1015, + AL_BUFFERS_PROCESSED = 0x1016; + + /** Gain bounds. */ + public static final int + AL_MIN_GAIN = 0x100D, + AL_MAX_GAIN = 0x100E; + + /** Distance model attributes, */ + public static final int + AL_REFERENCE_DISTANCE = 0x1020, + AL_ROLLOFF_FACTOR = 0x1021, + AL_MAX_DISTANCE = 0x1023; + + /** Buffer attributes, */ + public static final int + AL_FREQUENCY = 0x2001, + AL_BITS = 0x2002, + AL_CHANNELS = 0x2003, + AL_SIZE = 0x2004; + + /** Buffer formats. */ + public static final int + AL_FORMAT_MONO8 = 0x1100, + AL_FORMAT_MONO16 = 0x1101, + AL_FORMAT_STEREO8 = 0x1102, + AL_FORMAT_STEREO16 = 0x1103; + + /** Buffer state. */ + public static final int + AL_UNUSED = 0x2010, + AL_PENDING = 0x2011, + AL_PROCESSED = 0x2012; + + protected AL10() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(ALCapabilities caps) { + return checkFunctions( + caps.alGetError, caps.alEnable, caps.alDisable, caps.alIsEnabled, caps.alGetBoolean, caps.alGetInteger, caps.alGetFloat, caps.alGetDouble, + caps.alGetBooleanv, caps.alGetIntegerv, caps.alGetFloatv, caps.alGetDoublev, caps.alGetString, caps.alDistanceModel, caps.alDopplerFactor, + caps.alDopplerVelocity, caps.alListenerf, caps.alListeneri, caps.alListener3f, caps.alListenerfv, caps.alGetListenerf, caps.alGetListeneri, + caps.alGetListener3f, caps.alGetListenerfv, caps.alGenSources, caps.alDeleteSources, caps.alIsSource, caps.alSourcef, caps.alSource3f, + caps.alSourcefv, caps.alSourcei, caps.alGetSourcef, caps.alGetSource3f, caps.alGetSourcefv, caps.alGetSourcei, caps.alGetSourceiv, + caps.alSourceQueueBuffers, caps.alSourceUnqueueBuffers, caps.alSourcePlay, caps.alSourcePause, caps.alSourceStop, caps.alSourceRewind, + caps.alSourcePlayv, caps.alSourcePausev, caps.alSourceStopv, caps.alSourceRewindv, caps.alGenBuffers, caps.alDeleteBuffers, caps.alIsBuffer, + caps.alGetBufferf, caps.alGetBufferi, caps.alBufferData, caps.alGetEnumValue, caps.alGetProcAddress, caps.alIsExtensionPresent + ); + } + + // --- [ alGetError ] --- + + /** + * Obtains error information. + * + *Each detectable error is assigned a numeric code. When an error is detected by AL, a flag is set and the error code is recorded. Further errors, if they + * occur, do not affect this recorded code. When alGetError is called, the code is returned and the flag is cleared, so that a further error will again + * record its code. If a call to alGetError returns AL_NO_ERROR then there has been no detectable error since the last call to alGetError (or since the AL + * was initialized).
+ * + *Error codes can be mapped to strings. The alGetString function returns a pointer to a constant (literal) string that is identical to the identifier used + * for the enumeration value, as defined in the specification.
+ */ + @NativeType("ALenum") + public static int alGetError() { + long __functionAddress = AL.getICD().alGetError; + return invokeI(__functionAddress); + } + + // --- [ alEnable ] --- + + /** + * Enables AL capabilities. + * + * @param target the capability to enable + */ + @NativeType("ALvoid") + public static void alEnable(@NativeType("ALenum") int target) { + long __functionAddress = AL.getICD().alEnable; + invokeV(target, __functionAddress); + } + + // --- [ alDisable ] --- + + /** + * Disables AL capabilities. + * + * @param target the capability to disable + */ + @NativeType("ALvoid") + public static void alDisable(@NativeType("ALenum") int target) { + long __functionAddress = AL.getICD().alDisable; + invokeV(target, __functionAddress); + } + + // --- [ alIsEnabled ] --- + + /** + * Queries whether a given capability is currently enabled or not. + * + * @param target the capability to query + */ + @NativeType("ALboolean") + public static boolean alIsEnabled(@NativeType("ALenum") int target) { + long __functionAddress = AL.getICD().alIsEnabled; + return invokeZ(target, __functionAddress); + } + + // --- [ alGetBoolean ] --- + + /** + * Returns the boolean value of the specified parameter. + * + * @param paramName the parameter to query + */ + @NativeType("ALboolean") + public static boolean alGetBoolean(@NativeType("ALenum") int paramName) { + long __functionAddress = AL.getICD().alGetBoolean; + return invokeZ(paramName, __functionAddress); + } + + // --- [ alGetInteger ] --- + + /** + * Returns the integer value of the specified parameter. + * + * @param paramName the parameter to query. One of:| {@link #AL_DOPPLER_FACTOR DOPPLER_FACTOR} | {@link #AL_DISTANCE_MODEL DISTANCE_MODEL} | {@link AL11#AL_SPEED_OF_SOUND SPEED_OF_SOUND} |
| {@link #AL_DOPPLER_FACTOR DOPPLER_FACTOR} | {@link #AL_DISTANCE_MODEL DISTANCE_MODEL} | {@link AL11#AL_SPEED_OF_SOUND SPEED_OF_SOUND} |
| {@link #AL_DOPPLER_FACTOR DOPPLER_FACTOR} | {@link #AL_DISTANCE_MODEL DISTANCE_MODEL} | {@link AL11#AL_SPEED_OF_SOUND SPEED_OF_SOUND} |
| {@link #AL_VENDOR VENDOR} | {@link #AL_VERSION VERSION} | {@link #AL_RENDERER RENDERER} | {@link #AL_EXTENSIONS EXTENSIONS} |
Samples usually use the entire dynamic range of the chosen format/encoding, independent of their real world intensity. For example, a jet engine and a + * clockwork both will have samples with full amplitude. The application will then have to adjust source gain accordingly to account for relative differences.
+ * + *Source gain is then attenuated by distance. The effective attenuation of a source depends on many factors, among which distance attenuation and source + * and listener gain are only some of the contributing factors. Even if the source and listener gain exceed 1.0 (amplification beyond the guaranteed + * dynamic range), distance and other attenuation might ultimately limit the overall gain to a value below 1.0.
+ * + *OpenAL currently supports three modes of operation with respect to distance attenuation, including one that is similar to the IASIG I3DL2 model. The + * application can choose one of these models (or chooses to disable distance-dependent attenuation) on a per-context basis.
+ * + * @param modelName the distance attenuation model to set. One of:| {@link #AL_INVERSE_DISTANCE INVERSE_DISTANCE} | {@link #AL_INVERSE_DISTANCE_CLAMPED INVERSE_DISTANCE_CLAMPED} | {@link AL11#AL_LINEAR_DISTANCE LINEAR_DISTANCE} | {@link AL11#AL_LINEAR_DISTANCE_CLAMPED LINEAR_DISTANCE_CLAMPED} |
| {@link AL11#AL_EXPONENT_DISTANCE EXPONENT_DISTANCE} | {@link AL11#AL_EXPONENT_DISTANCE_CLAMPED EXPONENT_DISTANCE_CLAMPED} | {@link #AL_NONE NONE} |
The Doppler Effect depends on the velocities of source and listener relative to the medium, and the propagation speed of sound in that medium. The + * application might want to emphasize or de-emphasize the Doppler Effect as physically accurate calculation might not give the desired results. The amount + * of frequency shift (pitch change) is proportional to the speed of listener and source along their line of sight. The Doppler Effect as implemented by + * OpenAL is described by the formula below. Effects of the medium (air, water) moving with respect to listener and source are ignored.
+ * + *
+ * SS: AL_SPEED_OF_SOUND = speed of sound (default value 343.3)
+ * DF: AL_DOPPLER_FACTOR = Doppler factor (default 1.0)
+ * vls: Listener velocity scalar (scalar, projected on source-to-listener vector)
+ * vss: Source velocity scalar (scalar, projected on source-to-listener vector)
+ * f: Frequency of sample
+ * f': effective Doppler shifted frequency
+ *
+ * 3D Mathematical representation of vls and vss:
+ *
+ * Mag(vector) = sqrt(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z)
+ * DotProduct(v1, v2) = (v1.x * v2.x + v1.y * v2.y + v1.z * v2.z)
+ *
+ * SL = source to listener vector
+ * SV = Source velocity vector
+ * LV = Listener velocity vector
+ *
+ * vls = DotProduct(SL, LV) / Mag(SL)
+ * vss = DotProduct(SL, SV) / Mag(SL)
+ *
+ * Dopper Calculation:
+ *
+ * vss = min(vss, SS / DF)
+ * vls = min(vls, SS / DF)
+ *
+ * f' = f * (SS - DF * vls) / (SS - DF * vss)The {@code dopplerFactor} is a simple scaling of source and listener velocities to exaggerate or deemphasize the Doppler (pitch) shift resulting from + * the calculation.
+ * + * @param dopplerFactor the doppler factor + */ + @NativeType("ALvoid") + public static void alDopplerFactor(@NativeType("ALfloat") float dopplerFactor) { + long __functionAddress = AL.getICD().alDopplerFactor; + invokeV(dopplerFactor, __functionAddress); + } + + // --- [ alDopplerVelocity ] --- + + /** + * Sets the doppler effect propagation velocity. + * + *The OpenAL 1.1 Doppler implementation is different than that of OpenAL 1.0, because the older implementation was confusing and not implemented + * consistently. The new "speed of sound" property makes the 1.1 implementation more intuitive than the old implementation. If your implementation wants to + * support the AL_DOPPLER_VELOCITY parameter (the alDopplerVelocity call will remain as an entry point so that 1.0 applications can link with a 1.1 + * library), the above formula can be changed to the following:
+ * + *
+ * vss = min(vss, (SS * DV)/DF)
+ * vls = min(vls, (SS * DV)/DF)
+ *
+ * f' = f * (SS * DV - DF*vls) / (SS * DV - DF * vss)OpenAL 1.1 programmers would never use AL_DOPPLER_VELOCITY (which defaults to 1.0).
+ * + * @param dopplerVelocity the doppler velocity + */ + @NativeType("ALvoid") + public static void alDopplerVelocity(@NativeType("ALfloat") float dopplerVelocity) { + long __functionAddress = AL.getICD().alDopplerVelocity; + invokeV(dopplerVelocity, __functionAddress); + } + + // --- [ alListenerf ] --- + + /** + * Sets the float value of a listener parameter. + * + * @param paramName the parameter to modify. One of:| {@link #AL_ORIENTATION ORIENTATION} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} |
| {@link #AL_ORIENTATION ORIENTATION} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} |
| {@link #AL_ORIENTATION ORIENTATION} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} |
| {@link #AL_ORIENTATION ORIENTATION} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} |
| {@link #AL_ORIENTATION ORIENTATION} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} |
| {@link #AL_ORIENTATION ORIENTATION} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} |
| {@link #AL_ORIENTATION ORIENTATION} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} |
| {@link #AL_ORIENTATION ORIENTATION} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} |
| {@link #AL_ORIENTATION ORIENTATION} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} |
| {@link #AL_CONE_INNER_ANGLE CONE_INNER_ANGLE} | {@link #AL_CONE_OUTER_ANGLE CONE_OUTER_ANGLE} | {@link #AL_PITCH PITCH} | {@link #AL_DIRECTION DIRECTION} | {@link #AL_LOOPING LOOPING} | {@link #AL_BUFFER BUFFER} | {@link #AL_SOURCE_STATE SOURCE_STATE} |
| {@link #AL_CONE_OUTER_GAIN CONE_OUTER_GAIN} | {@link #AL_SOURCE_TYPE SOURCE_TYPE} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} | {@link #AL_REFERENCE_DISTANCE REFERENCE_DISTANCE} | {@link #AL_ROLLOFF_FACTOR ROLLOFF_FACTOR} |
| {@link #AL_MAX_DISTANCE MAX_DISTANCE} |
| {@link #AL_CONE_INNER_ANGLE CONE_INNER_ANGLE} | {@link #AL_CONE_OUTER_ANGLE CONE_OUTER_ANGLE} | {@link #AL_PITCH PITCH} | {@link #AL_DIRECTION DIRECTION} | {@link #AL_LOOPING LOOPING} | {@link #AL_BUFFER BUFFER} | {@link #AL_SOURCE_STATE SOURCE_STATE} |
| {@link #AL_CONE_OUTER_GAIN CONE_OUTER_GAIN} | {@link #AL_SOURCE_TYPE SOURCE_TYPE} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} | {@link #AL_REFERENCE_DISTANCE REFERENCE_DISTANCE} | {@link #AL_ROLLOFF_FACTOR ROLLOFF_FACTOR} |
| {@link #AL_MAX_DISTANCE MAX_DISTANCE} |
| {@link #AL_CONE_INNER_ANGLE CONE_INNER_ANGLE} | {@link #AL_CONE_OUTER_ANGLE CONE_OUTER_ANGLE} | {@link #AL_PITCH PITCH} | {@link #AL_DIRECTION DIRECTION} | {@link #AL_LOOPING LOOPING} | {@link #AL_BUFFER BUFFER} | {@link #AL_SOURCE_STATE SOURCE_STATE} |
| {@link #AL_CONE_OUTER_GAIN CONE_OUTER_GAIN} | {@link #AL_SOURCE_TYPE SOURCE_TYPE} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} | {@link #AL_REFERENCE_DISTANCE REFERENCE_DISTANCE} | {@link #AL_ROLLOFF_FACTOR ROLLOFF_FACTOR} |
| {@link #AL_MAX_DISTANCE MAX_DISTANCE} |
| {@link #AL_CONE_INNER_ANGLE CONE_INNER_ANGLE} | {@link #AL_CONE_OUTER_ANGLE CONE_OUTER_ANGLE} | {@link #AL_PITCH PITCH} | {@link #AL_DIRECTION DIRECTION} | {@link #AL_LOOPING LOOPING} | {@link #AL_BUFFER BUFFER} | {@link #AL_SOURCE_STATE SOURCE_STATE} |
| {@link #AL_CONE_OUTER_GAIN CONE_OUTER_GAIN} | {@link #AL_SOURCE_TYPE SOURCE_TYPE} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} | {@link #AL_REFERENCE_DISTANCE REFERENCE_DISTANCE} | {@link #AL_ROLLOFF_FACTOR ROLLOFF_FACTOR} |
| {@link #AL_MAX_DISTANCE MAX_DISTANCE} |
| {@link #AL_CONE_INNER_ANGLE CONE_INNER_ANGLE} | {@link #AL_CONE_OUTER_ANGLE CONE_OUTER_ANGLE} | {@link #AL_PITCH PITCH} | {@link #AL_DIRECTION DIRECTION} | {@link #AL_LOOPING LOOPING} | {@link #AL_BUFFER BUFFER} | {@link #AL_SOURCE_STATE SOURCE_STATE} |
| {@link #AL_CONE_OUTER_GAIN CONE_OUTER_GAIN} | {@link #AL_SOURCE_TYPE SOURCE_TYPE} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} | {@link #AL_REFERENCE_DISTANCE REFERENCE_DISTANCE} | {@link #AL_ROLLOFF_FACTOR ROLLOFF_FACTOR} |
| {@link #AL_MAX_DISTANCE MAX_DISTANCE} |
| {@link #AL_CONE_INNER_ANGLE CONE_INNER_ANGLE} | {@link #AL_CONE_OUTER_ANGLE CONE_OUTER_ANGLE} | {@link #AL_PITCH PITCH} | {@link #AL_DIRECTION DIRECTION} | {@link #AL_LOOPING LOOPING} | {@link #AL_BUFFER BUFFER} | {@link #AL_SOURCE_STATE SOURCE_STATE} |
| {@link #AL_CONE_OUTER_GAIN CONE_OUTER_GAIN} | {@link #AL_SOURCE_TYPE SOURCE_TYPE} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} | {@link #AL_REFERENCE_DISTANCE REFERENCE_DISTANCE} | {@link #AL_ROLLOFF_FACTOR ROLLOFF_FACTOR} |
| {@link #AL_MAX_DISTANCE MAX_DISTANCE} |
| {@link #AL_CONE_INNER_ANGLE CONE_INNER_ANGLE} | {@link #AL_CONE_OUTER_ANGLE CONE_OUTER_ANGLE} | {@link #AL_PITCH PITCH} | {@link #AL_DIRECTION DIRECTION} | {@link #AL_LOOPING LOOPING} | {@link #AL_BUFFER BUFFER} | {@link #AL_SOURCE_STATE SOURCE_STATE} |
| {@link #AL_CONE_OUTER_GAIN CONE_OUTER_GAIN} | {@link #AL_SOURCE_TYPE SOURCE_TYPE} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} | {@link #AL_REFERENCE_DISTANCE REFERENCE_DISTANCE} | {@link #AL_ROLLOFF_FACTOR ROLLOFF_FACTOR} |
| {@link #AL_MAX_DISTANCE MAX_DISTANCE} |
| {@link #AL_CONE_INNER_ANGLE CONE_INNER_ANGLE} | {@link #AL_CONE_OUTER_ANGLE CONE_OUTER_ANGLE} | {@link #AL_PITCH PITCH} | {@link #AL_DIRECTION DIRECTION} | {@link #AL_LOOPING LOOPING} | {@link #AL_BUFFER BUFFER} | {@link #AL_SOURCE_STATE SOURCE_STATE} |
| {@link #AL_CONE_OUTER_GAIN CONE_OUTER_GAIN} | {@link #AL_SOURCE_TYPE SOURCE_TYPE} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} | {@link #AL_REFERENCE_DISTANCE REFERENCE_DISTANCE} | {@link #AL_ROLLOFF_FACTOR ROLLOFF_FACTOR} |
| {@link #AL_MAX_DISTANCE MAX_DISTANCE} |
| {@link #AL_CONE_INNER_ANGLE CONE_INNER_ANGLE} | {@link #AL_CONE_OUTER_ANGLE CONE_OUTER_ANGLE} | {@link #AL_PITCH PITCH} | {@link #AL_DIRECTION DIRECTION} | {@link #AL_LOOPING LOOPING} | {@link #AL_BUFFER BUFFER} | {@link #AL_SOURCE_STATE SOURCE_STATE} |
| {@link #AL_CONE_OUTER_GAIN CONE_OUTER_GAIN} | {@link #AL_SOURCE_TYPE SOURCE_TYPE} | {@link #AL_POSITION POSITION} | {@link #AL_VELOCITY VELOCITY} | {@link #AL_GAIN GAIN} | {@link #AL_REFERENCE_DISTANCE REFERENCE_DISTANCE} | {@link #AL_ROLLOFF_FACTOR ROLLOFF_FACTOR} |
| {@link #AL_MAX_DISTANCE MAX_DISTANCE} |
The buffers will be queued in the sequence in which they appear in the array. This command is legal on a source in any playback state (to allow for + * streaming, queuing has to be possible on a AL_PLAYING source). All buffers in a queue must have the same format and attributes, with the exception of + * the {@code NULL} buffer (i.e., 0) which can always be queued.
+ * + * @param sourceName the target source + * @param bufferNames the buffer names + */ + @NativeType("ALvoid") + public static void alSourceQueueBuffers(@NativeType("ALuint") int sourceName, @NativeType("ALuint *") IntBuffer bufferNames) { + nalSourceQueueBuffers(sourceName, bufferNames.remaining(), memAddress(bufferNames)); + } + + /** + * Queues up one or multiple buffer names to the specified source. + * + *The buffers will be queued in the sequence in which they appear in the array. This command is legal on a source in any playback state (to allow for + * streaming, queuing has to be possible on a AL_PLAYING source). All buffers in a queue must have the same format and attributes, with the exception of + * the {@code NULL} buffer (i.e., 0) which can always be queued.
+ * + * @param sourceName the target source + */ + @NativeType("ALvoid") + public static void alSourceQueueBuffers(@NativeType("ALuint") int sourceName, @NativeType("ALuint *") int bufferName) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer bufferNames = stack.ints(bufferName); + nalSourceQueueBuffers(sourceName, 1, memAddress(bufferNames)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alSourceUnqueueBuffers ] --- + + /** + * Unsafe version of: {@link #alSourceUnqueueBuffers SourceUnqueueBuffers} + * + * @param numEntries the number of buffers to unqueue + */ + public static void nalSourceUnqueueBuffers(int sourceName, int numEntries, long bufferNames) { + long __functionAddress = AL.getICD().alSourceUnqueueBuffers; + invokePV(sourceName, numEntries, bufferNames, __functionAddress); + } + + /** + * Removes a number of buffer entries that have finished processing, in the order of apperance, from the queue of the specified source. + * + *Once a queue entry for a buffer has been appended to a queue and is pending processing, it should not be changed. Removal of a given queue entry is not + * possible unless either the source is stopped (in which case then entire queue is considered processed), or if the queue entry has already been processed + * (AL_PLAYING or AL_PAUSED source). A playing source will enter the AL_STOPPED state if it completes playback of the last buffer in its queue (the same + * behavior as when a single buffer has been attached to a source and has finished playback).
+ * + * @param sourceName the target source + * @param bufferNames the buffer names + */ + @NativeType("ALvoid") + public static void alSourceUnqueueBuffers(@NativeType("ALuint") int sourceName, @NativeType("ALuint *") IntBuffer bufferNames) { + nalSourceUnqueueBuffers(sourceName, bufferNames.remaining(), memAddress(bufferNames)); + } + + /** + * Removes a number of buffer entries that have finished processing, in the order of apperance, from the queue of the specified source. + * + *Once a queue entry for a buffer has been appended to a queue and is pending processing, it should not be changed. Removal of a given queue entry is not + * possible unless either the source is stopped (in which case then entire queue is considered processed), or if the queue entry has already been processed + * (AL_PLAYING or AL_PAUSED source). A playing source will enter the AL_STOPPED state if it completes playback of the last buffer in its queue (the same + * behavior as when a single buffer has been attached to a source and has finished playback).
+ * + * @param sourceName the target source + */ + @NativeType("ALvoid") + public static int alSourceUnqueueBuffers(@NativeType("ALuint") int sourceName) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer bufferNames = stack.callocInt(1); + nalSourceUnqueueBuffers(sourceName, 1, memAddress(bufferNames)); + return bufferNames.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alSourcePlay ] --- + + /** + * Sets the source state to AL_PLAYING. + * + *alSourcePlay applied to an AL_INITIAL source will promote the source to AL_PLAYING, thus the data found in the buffer will be fed into the processing, + * starting at the beginning. alSourcePlay applied to a AL_PLAYING source will restart the source from the beginning. It will not affect the configuration, + * and will leave the source in AL_PLAYING state, but reset the sampling offset to the beginning. alSourcePlay applied to a AL_PAUSED source will resume + * processing using the source state as preserved at the alSourcePause operation. alSourcePlay applied to a AL_STOPPED source will propagate it to + * AL_INITIAL then to AL_PLAYING immediately.
+ * + * @param source the source to play + */ + @NativeType("ALvoid") + public static void alSourcePlay(@NativeType("ALuint") int source) { + long __functionAddress = AL.getICD().alSourcePlay; + invokeV(source, __functionAddress); + } + + // --- [ alSourcePause ] --- + + /** + * Sets the source state to AL_PAUSED. + * + *alSourcePause applied to an AL_INITIAL source is a legal NOP. alSourcePause applied to a AL_PLAYING source will change its state to AL_PAUSED. The + * source is exempt from processing, its current state is preserved. alSourcePause applied to a AL_PAUSED source is a legal NOP. alSourcePause applied to a + * AL_STOPPED source is a legal NOP.
+ * + * @param source the source to pause + */ + @NativeType("ALvoid") + public static void alSourcePause(@NativeType("ALuint") int source) { + long __functionAddress = AL.getICD().alSourcePause; + invokeV(source, __functionAddress); + } + + // --- [ alSourceStop ] --- + + /** + * Sets the source state to AL_STOPPED. + * + *alSourceStop applied to an AL_INITIAL source is a legal NOP. alSourceStop applied to a AL_PLAYING source will change its state to AL_STOPPED. The source + * is exempt from processing, its current state is preserved. alSourceStop applied to a AL_PAUSED source will change its state to AL_STOPPED, with the same + * consequences as on a AL_PLAYING source. alSourceStop applied to a AL_STOPPED source is a legal NOP.
+ * + * @param source the source to stop + */ + @NativeType("ALvoid") + public static void alSourceStop(@NativeType("ALuint") int source) { + long __functionAddress = AL.getICD().alSourceStop; + invokeV(source, __functionAddress); + } + + // --- [ alSourceRewind ] --- + + /** + * Sets the source state to AL_INITIAL. + * + *alSourceRewind applied to an AL_INITIAL source is a legal NOP. alSourceRewind applied to a AL_PLAYING source will change its state to AL_STOPPED then + * AL_INITIAL. The source is exempt from processing: its current state is preserved, with the exception of the sampling offset, which is reset to the + * beginning. alSourceRewind applied to a AL_PAUSED source will change its state to AL_INITIAL, with the same consequences as on a AL_PLAYING source. + * alSourceRewind applied to an AL_STOPPED source promotes the source to AL_INITIAL, resetting the sampling offset to the beginning.
+ * + * @param source the source to rewind + */ + @NativeType("ALvoid") + public static void alSourceRewind(@NativeType("ALuint") int source) { + long __functionAddress = AL.getICD().alSourceRewind; + invokeV(source, __functionAddress); + } + + // --- [ alSourcePlayv ] --- + + /** + * Unsafe version of: {@link #alSourcePlayv SourcePlayv} + * + * @param n the number of sources to play + */ + public static void nalSourcePlayv(int n, long sources) { + long __functionAddress = AL.getICD().alSourcePlayv; + invokePV(n, sources, __functionAddress); + } + + /** + * Pointer version of {@link #alSourcePlay SourcePlay}. + * + * @param sources the sources to play + */ + @NativeType("ALvoid") + public static void alSourcePlayv(@NativeType("ALuint const *") IntBuffer sources) { + nalSourcePlayv(sources.remaining(), memAddress(sources)); + } + + // --- [ alSourcePausev ] --- + + /** + * Unsafe version of: {@link #alSourcePausev SourcePausev} + * + * @param n the number of sources to pause + */ + public static void nalSourcePausev(int n, long sources) { + long __functionAddress = AL.getICD().alSourcePausev; + invokePV(n, sources, __functionAddress); + } + + /** + * Pointer version of {@link #alSourcePause SourcePause}. + * + * @param sources the sources to pause + */ + @NativeType("ALvoid") + public static void alSourcePausev(@NativeType("ALuint const *") IntBuffer sources) { + nalSourcePausev(sources.remaining(), memAddress(sources)); + } + + // --- [ alSourceStopv ] --- + + /** + * Unsafe version of: {@link #alSourceStopv SourceStopv} + * + * @param n the number of sources to stop + */ + public static void nalSourceStopv(int n, long sources) { + long __functionAddress = AL.getICD().alSourceStopv; + invokePV(n, sources, __functionAddress); + } + + /** + * Pointer version of {@link #alSourceStop SourceStop}. + * + * @param sources the sources to stop + */ + @NativeType("ALvoid") + public static void alSourceStopv(@NativeType("ALuint const *") IntBuffer sources) { + nalSourceStopv(sources.remaining(), memAddress(sources)); + } + + // --- [ alSourceRewindv ] --- + + /** + * Unsafe version of: {@link #alSourceRewindv SourceRewindv} + * + * @param n the number of sources to rewind + */ + public static void nalSourceRewindv(int n, long sources) { + long __functionAddress = AL.getICD().alSourceRewindv; + invokePV(n, sources, __functionAddress); + } + + /** + * Pointer version of {@link #alSourceRewind SourceRewind}. + * + * @param sources the sources to rewind + */ + @NativeType("ALvoid") + public static void alSourceRewindv(@NativeType("ALuint const *") IntBuffer sources) { + nalSourceRewindv(sources.remaining(), memAddress(sources)); + } + + // --- [ alGenBuffers ] --- + + /** + * Unsafe version of: {@link #alGenBuffers GenBuffers} + * + * @param n the number of buffer names to generate + */ + public static void nalGenBuffers(int n, long bufferNames) { + long __functionAddress = AL.getICD().alGenBuffers; + invokePV(n, bufferNames, __functionAddress); + } + + /** + * Requests a number of buffer names. + * + * @param bufferNames the buffer that will receive the buffer names + */ + @NativeType("ALvoid") + public static void alGenBuffers(@NativeType("ALuint *") IntBuffer bufferNames) { + nalGenBuffers(bufferNames.remaining(), memAddress(bufferNames)); + } + + /** Requests a number of buffer names. */ + @NativeType("ALvoid") + public static int alGenBuffers() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer bufferNames = stack.callocInt(1); + nalGenBuffers(1, memAddress(bufferNames)); + return bufferNames.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alDeleteBuffers ] --- + + /** + * Unsafe version of: {@link #alDeleteBuffers DeleteBuffers} + * + * @param n the number of buffers to delete + */ + public static void nalDeleteBuffers(int n, long bufferNames) { + long __functionAddress = AL.getICD().alDeleteBuffers; + invokePV(n, bufferNames, __functionAddress); + } + + /** + * Requests the deletion of a number of buffers. + * + * @param bufferNames the buffers to delete + */ + @NativeType("ALvoid") + public static void alDeleteBuffers(@NativeType("ALuint const *") IntBuffer bufferNames) { + nalDeleteBuffers(bufferNames.remaining(), memAddress(bufferNames)); + } + + /** Requests the deletion of a number of buffers. */ + @NativeType("ALvoid") + public static void alDeleteBuffers(@NativeType("ALuint const *") int bufferName) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer bufferNames = stack.ints(bufferName); + nalDeleteBuffers(1, memAddress(bufferNames)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alIsBuffer ] --- + + /** + * Verifies whether the specified object name is a buffer name. + * + * @param bufferName a value that may be a buffer name + */ + @NativeType("ALboolean") + public static boolean alIsBuffer(@NativeType("ALuint") int bufferName) { + long __functionAddress = AL.getICD().alIsBuffer; + return invokeZ(bufferName, __functionAddress); + } + + // --- [ alGetBufferf ] --- + + /** Unsafe version of: {@link #alGetBufferf GetBufferf} */ + public static void nalGetBufferf(int bufferName, int paramName, long value) { + long __functionAddress = AL.getICD().alGetBufferf; + invokePV(bufferName, paramName, value, __functionAddress); + } + + /** + * Returns the float value of the specified buffer parameter. + * + * @param bufferName the buffer to query + * @param paramName the parameter to query. One of:| {@link #AL_FREQUENCY FREQUENCY} | {@link #AL_BITS BITS} | {@link #AL_CHANNELS CHANNELS} | {@link #AL_SIZE SIZE} |
| {@link #AL_FREQUENCY FREQUENCY} | {@link #AL_BITS BITS} | {@link #AL_CHANNELS CHANNELS} | {@link #AL_SIZE SIZE} |
| {@link #AL_FREQUENCY FREQUENCY} | {@link #AL_BITS BITS} | {@link #AL_CHANNELS CHANNELS} | {@link #AL_SIZE SIZE} |
| {@link #AL_FREQUENCY FREQUENCY} | {@link #AL_BITS BITS} | {@link #AL_CHANNELS CHANNELS} | {@link #AL_SIZE SIZE} |
The data specified is copied to an internal software, or if possible, hardware buffer. The implementation is free to apply decompression, conversion, + * resampling, and filtering as needed.
+ * + *8-bit data is expressed as an unsigned value over the range 0 to 255, 128 being an audio output level of zero.
+ * + *16-bit data is expressed as a signed value over the range -32768 to 32767, 0 being an audio output level of zero. Byte order for 16-bit values is + * determined by the native format of the CPU.
+ * + *Stereo data is expressed in an interleaved format, left channel sample followed by the right channel sample.
+ * + *Buffers containing audio data with more than one channel will be played without 3D spatialization features – these formats are normally used for + * background music.
+ * + * @param bufferName the buffer to modify + * @param format the data format. One of:| {@link #AL_FORMAT_MONO8 FORMAT_MONO8} | {@link #AL_FORMAT_MONO16 FORMAT_MONO16} | {@link #AL_FORMAT_STEREO8 FORMAT_STEREO8} | {@link #AL_FORMAT_STEREO16 FORMAT_STEREO16} |
The data specified is copied to an internal software, or if possible, hardware buffer. The implementation is free to apply decompression, conversion, + * resampling, and filtering as needed.
+ * + *8-bit data is expressed as an unsigned value over the range 0 to 255, 128 being an audio output level of zero.
+ * + *16-bit data is expressed as a signed value over the range -32768 to 32767, 0 being an audio output level of zero. Byte order for 16-bit values is + * determined by the native format of the CPU.
+ * + *Stereo data is expressed in an interleaved format, left channel sample followed by the right channel sample.
+ * + *Buffers containing audio data with more than one channel will be played without 3D spatialization features – these formats are normally used for + * background music.
+ * + * @param bufferName the buffer to modify + * @param format the data format. One of:| {@link #AL_FORMAT_MONO8 FORMAT_MONO8} | {@link #AL_FORMAT_MONO16 FORMAT_MONO16} | {@link #AL_FORMAT_STEREO8 FORMAT_STEREO8} | {@link #AL_FORMAT_STEREO16 FORMAT_STEREO16} |
The data specified is copied to an internal software, or if possible, hardware buffer. The implementation is free to apply decompression, conversion, + * resampling, and filtering as needed.
+ * + *8-bit data is expressed as an unsigned value over the range 0 to 255, 128 being an audio output level of zero.
+ * + *16-bit data is expressed as a signed value over the range -32768 to 32767, 0 being an audio output level of zero. Byte order for 16-bit values is + * determined by the native format of the CPU.
+ * + *Stereo data is expressed in an interleaved format, left channel sample followed by the right channel sample.
+ * + *Buffers containing audio data with more than one channel will be played without 3D spatialization features – these formats are normally used for + * background music.
+ * + * @param bufferName the buffer to modify + * @param format the data format. One of:| {@link #AL_FORMAT_MONO8 FORMAT_MONO8} | {@link #AL_FORMAT_MONO16 FORMAT_MONO16} | {@link #AL_FORMAT_STEREO8 FORMAT_STEREO8} | {@link #AL_FORMAT_STEREO16 FORMAT_STEREO16} |
The data specified is copied to an internal software, or if possible, hardware buffer. The implementation is free to apply decompression, conversion, + * resampling, and filtering as needed.
+ * + *8-bit data is expressed as an unsigned value over the range 0 to 255, 128 being an audio output level of zero.
+ * + *16-bit data is expressed as a signed value over the range -32768 to 32767, 0 being an audio output level of zero. Byte order for 16-bit values is + * determined by the native format of the CPU.
+ * + *Stereo data is expressed in an interleaved format, left channel sample followed by the right channel sample.
+ * + *Buffers containing audio data with more than one channel will be played without 3D spatialization features – these formats are normally used for + * background music.
+ * + * @param bufferName the buffer to modify + * @param format the data format. One of:| {@link #AL_FORMAT_MONO8 FORMAT_MONO8} | {@link #AL_FORMAT_MONO16 FORMAT_MONO16} | {@link #AL_FORMAT_STEREO8 FORMAT_STEREO8} | {@link #AL_FORMAT_STEREO16 FORMAT_STEREO16} |
Returns {@code NULL} if no entry point with the name funcName can be found. Implementations are free to return {@code NULL} if an entry point is present, but not + * applicable for the current context. However the specification does not guarantee this behavior.
+ * + *Applications can use alGetProcAddress to obtain core API entry points, not just extensions. This is the recommended way to dynamically load and unload + * OpenAL DLL's as sound drivers.
+ * + * @param funcName the function name + */ + @NativeType("void *") + public static long alGetProcAddress(@NativeType("ALchar const *") ByteBuffer funcName) { + if (CHECKS) { + checkNT1(funcName); + } + return nalGetProcAddress(memAddress(funcName)); + } + + /** + * Retrieves extension entry points. + * + *Returns {@code NULL} if no entry point with the name funcName can be found. Implementations are free to return {@code NULL} if an entry point is present, but not + * applicable for the current context. However the specification does not guarantee this behavior.
+ * + *Applications can use alGetProcAddress to obtain core API entry points, not just extensions. This is the recommended way to dynamically load and unload + * OpenAL DLL's as sound drivers.
+ * + * @param funcName the function name + */ + @NativeType("void *") + public static long alGetProcAddress(@NativeType("ALchar const *") CharSequence funcName) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nASCII(funcName, true); + long funcNameEncoded = stack.getPointerAddress(); + return nalGetProcAddress(funcNameEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alIsExtensionPresent ] --- + + /** Unsafe version of: {@link #alIsExtensionPresent IsExtensionPresent} */ + public static boolean nalIsExtensionPresent(long extName) { + long __functionAddress = AL.getICD().alIsExtensionPresent; + return invokePZ(extName, __functionAddress); + } + + /** + * Verifies that a given extension is available for the current context and the device it is associated with. + * + *Invalid and unsupported string tokens return ALC_FALSE. {@code extName} is not case sensitive – the implementation will convert the name to all + * upper-case internally (and will express extension names in upper-case).
+ * + * @param extName the extension name + */ + @NativeType("ALCboolean") + public static boolean alIsExtensionPresent(@NativeType("ALchar const *") ByteBuffer extName) { + if (CHECKS) { + checkNT1(extName); + } + return nalIsExtensionPresent(memAddress(extName)); + } + + /** + * Verifies that a given extension is available for the current context and the device it is associated with. + * + *Invalid and unsupported string tokens return ALC_FALSE. {@code extName} is not case sensitive – the implementation will convert the name to all + * upper-case internally (and will express extension names in upper-case).
+ * + * @param extName the extension name + */ + @NativeType("ALCboolean") + public static boolean alIsExtensionPresent(@NativeType("ALchar const *") CharSequence extName) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nASCII(extName, true); + long extNameEncoded = stack.getPointerAddress(); + return nalIsExtensionPresent(extNameEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + /** Array version of: {@link #alGetIntegerv GetIntegerv} */ + @NativeType("ALvoid") + public static void alGetIntegerv(@NativeType("ALenum") int paramName, @NativeType("ALint *") int[] dest) { + long __functionAddress = AL.getICD().alGetIntegerv; + if (CHECKS) { + check(dest, 1); + } + invokePV(paramName, dest, __functionAddress); + } + + /** Array version of: {@link #alGetFloatv GetFloatv} */ + @NativeType("ALvoid") + public static void alGetFloatv(@NativeType("ALenum") int paramName, @NativeType("ALfloat *") float[] dest) { + long __functionAddress = AL.getICD().alGetFloatv; + if (CHECKS) { + check(dest, 1); + } + invokePV(paramName, dest, __functionAddress); + } + + /** Array version of: {@link #alGetDoublev GetDoublev} */ + @NativeType("ALvoid") + public static void alGetDoublev(@NativeType("ALenum") int paramName, @NativeType("ALdouble *") double[] dest) { + long __functionAddress = AL.getICD().alGetDoublev; + if (CHECKS) { + check(dest, 1); + } + invokePV(paramName, dest, __functionAddress); + } + + /** Array version of: {@link #alListenerfv Listenerfv} */ + @NativeType("ALvoid") + public static void alListenerfv(@NativeType("ALenum") int paramName, @NativeType("ALfloat const *") float[] values) { + long __functionAddress = AL.getICD().alListenerfv; + if (CHECKS) { + check(values, 1); + } + invokePV(paramName, values, __functionAddress); + } + + /** Array version of: {@link #alGetListenerf GetListenerf} */ + @NativeType("ALvoid") + public static void alGetListenerf(@NativeType("ALenum") int paramName, @NativeType("ALfloat *") float[] value) { + long __functionAddress = AL.getICD().alGetListenerf; + if (CHECKS) { + check(value, 1); + } + invokePV(paramName, value, __functionAddress); + } + + /** Array version of: {@link #alGetListeneri GetListeneri} */ + @NativeType("ALvoid") + public static void alGetListeneri(@NativeType("ALenum") int paramName, @NativeType("ALint *") int[] value) { + long __functionAddress = AL.getICD().alGetListeneri; + if (CHECKS) { + check(value, 1); + } + invokePV(paramName, value, __functionAddress); + } + + /** Array version of: {@link #alGetListener3f GetListener3f} */ + @NativeType("ALvoid") + public static void alGetListener3f(@NativeType("ALenum") int paramName, @NativeType("ALfloat *") float[] value1, @NativeType("ALfloat *") float[] value2, @NativeType("ALfloat *") float[] value3) { + long __functionAddress = AL.getICD().alGetListener3f; + if (CHECKS) { + check(value1, 1); + check(value2, 1); + check(value3, 1); + } + invokePPPV(paramName, value1, value2, value3, __functionAddress); + } + + /** Array version of: {@link #alGetListenerfv GetListenerfv} */ + @NativeType("ALvoid") + public static void alGetListenerfv(@NativeType("ALenum") int paramName, @NativeType("ALfloat *") float[] values) { + long __functionAddress = AL.getICD().alGetListenerfv; + if (CHECKS) { + check(values, 1); + } + invokePV(paramName, values, __functionAddress); + } + + /** Array version of: {@link #alGenSources GenSources} */ + @NativeType("ALvoid") + public static void alGenSources(@NativeType("ALuint *") int[] srcNames) { + long __functionAddress = AL.getICD().alGenSources; + invokePV(srcNames.length, srcNames, __functionAddress); + } + + /** Array version of: {@link #alDeleteSources DeleteSources} */ + @NativeType("ALvoid") + public static void alDeleteSources(@NativeType("ALuint *") int[] sources) { + long __functionAddress = AL.getICD().alDeleteSources; + invokePV(sources.length, sources, __functionAddress); + } + + /** Array version of: {@link #alSourcefv Sourcefv} */ + @NativeType("ALvoid") + public static void alSourcefv(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALfloat const *") float[] values) { + long __functionAddress = AL.getICD().alSourcefv; + if (CHECKS) { + check(values, 1); + } + invokePV(source, param, values, __functionAddress); + } + + /** Array version of: {@link #alGetSourcef GetSourcef} */ + @NativeType("ALvoid") + public static void alGetSourcef(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALfloat *") float[] value) { + long __functionAddress = AL.getICD().alGetSourcef; + if (CHECKS) { + check(value, 1); + } + invokePV(source, param, value, __functionAddress); + } + + /** Array version of: {@link #alGetSource3f GetSource3f} */ + @NativeType("ALvoid") + public static void alGetSource3f(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALfloat *") float[] v1, @NativeType("ALfloat *") float[] v2, @NativeType("ALfloat *") float[] v3) { + long __functionAddress = AL.getICD().alGetSource3f; + if (CHECKS) { + check(v1, 1); + check(v2, 1); + check(v3, 1); + } + invokePPPV(source, param, v1, v2, v3, __functionAddress); + } + + /** Array version of: {@link #alGetSourcefv GetSourcefv} */ + @NativeType("ALvoid") + public static void alGetSourcefv(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALfloat *") float[] values) { + long __functionAddress = AL.getICD().alGetSourcefv; + if (CHECKS) { + check(values, 1); + } + invokePV(source, param, values, __functionAddress); + } + + /** Array version of: {@link #alGetSourcei GetSourcei} */ + @NativeType("ALvoid") + public static void alGetSourcei(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALint *") int[] value) { + long __functionAddress = AL.getICD().alGetSourcei; + if (CHECKS) { + check(value, 1); + } + invokePV(source, param, value, __functionAddress); + } + + /** Array version of: {@link #alGetSourceiv GetSourceiv} */ + @NativeType("ALvoid") + public static void alGetSourceiv(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALint *") int[] values) { + long __functionAddress = AL.getICD().alGetSourceiv; + if (CHECKS) { + check(values, 1); + } + invokePV(source, param, values, __functionAddress); + } + + /** Array version of: {@link #alSourceQueueBuffers SourceQueueBuffers} */ + @NativeType("ALvoid") + public static void alSourceQueueBuffers(@NativeType("ALuint") int sourceName, @NativeType("ALuint *") int[] bufferNames) { + long __functionAddress = AL.getICD().alSourceQueueBuffers; + invokePV(sourceName, bufferNames.length, bufferNames, __functionAddress); + } + + /** Array version of: {@link #alSourceUnqueueBuffers SourceUnqueueBuffers} */ + @NativeType("ALvoid") + public static void alSourceUnqueueBuffers(@NativeType("ALuint") int sourceName, @NativeType("ALuint *") int[] bufferNames) { + long __functionAddress = AL.getICD().alSourceUnqueueBuffers; + invokePV(sourceName, bufferNames.length, bufferNames, __functionAddress); + } + + /** Array version of: {@link #alSourcePlayv SourcePlayv} */ + @NativeType("ALvoid") + public static void alSourcePlayv(@NativeType("ALuint const *") int[] sources) { + long __functionAddress = AL.getICD().alSourcePlayv; + invokePV(sources.length, sources, __functionAddress); + } + + /** Array version of: {@link #alSourcePausev SourcePausev} */ + @NativeType("ALvoid") + public static void alSourcePausev(@NativeType("ALuint const *") int[] sources) { + long __functionAddress = AL.getICD().alSourcePausev; + invokePV(sources.length, sources, __functionAddress); + } + + /** Array version of: {@link #alSourceStopv SourceStopv} */ + @NativeType("ALvoid") + public static void alSourceStopv(@NativeType("ALuint const *") int[] sources) { + long __functionAddress = AL.getICD().alSourceStopv; + invokePV(sources.length, sources, __functionAddress); + } + + /** Array version of: {@link #alSourceRewindv SourceRewindv} */ + @NativeType("ALvoid") + public static void alSourceRewindv(@NativeType("ALuint const *") int[] sources) { + long __functionAddress = AL.getICD().alSourceRewindv; + invokePV(sources.length, sources, __functionAddress); + } + + /** Array version of: {@link #alGenBuffers GenBuffers} */ + @NativeType("ALvoid") + public static void alGenBuffers(@NativeType("ALuint *") int[] bufferNames) { + long __functionAddress = AL.getICD().alGenBuffers; + invokePV(bufferNames.length, bufferNames, __functionAddress); + } + + /** Array version of: {@link #alDeleteBuffers DeleteBuffers} */ + @NativeType("ALvoid") + public static void alDeleteBuffers(@NativeType("ALuint const *") int[] bufferNames) { + long __functionAddress = AL.getICD().alDeleteBuffers; + invokePV(bufferNames.length, bufferNames, __functionAddress); + } + + /** Array version of: {@link #alGetBufferf GetBufferf} */ + @NativeType("ALvoid") + public static void alGetBufferf(@NativeType("ALuint") int bufferName, @NativeType("ALenum") int paramName, @NativeType("ALfloat *") float[] value) { + long __functionAddress = AL.getICD().alGetBufferf; + if (CHECKS) { + check(value, 1); + } + invokePV(bufferName, paramName, value, __functionAddress); + } + + /** Array version of: {@link #alGetBufferi GetBufferi} */ + @NativeType("ALvoid") + public static void alGetBufferi(@NativeType("ALuint") int bufferName, @NativeType("ALenum") int paramName, @NativeType("ALint *") int[] value) { + long __functionAddress = AL.getICD().alGetBufferi; + if (CHECKS) { + check(value, 1); + } + invokePV(bufferName, paramName, value, __functionAddress); + } + + /** Array version of: {@link #alBufferData BufferData} */ + @NativeType("ALvoid") + public static void alBufferData(@NativeType("ALuint") int bufferName, @NativeType("ALenum") int format, @NativeType("ALvoid const *") short[] data, @NativeType("ALsizei") int frequency) { + long __functionAddress = AL.getICD().alBufferData; + invokePV(bufferName, format, data, data.length << 1, frequency, __functionAddress); + } + + /** Array version of: {@link #alBufferData BufferData} */ + @NativeType("ALvoid") + public static void alBufferData(@NativeType("ALuint") int bufferName, @NativeType("ALenum") int format, @NativeType("ALvoid const *") int[] data, @NativeType("ALsizei") int frequency) { + long __functionAddress = AL.getICD().alBufferData; + invokePV(bufferName, format, data, data.length << 2, frequency, __functionAddress); + } + + /** Array version of: {@link #alBufferData BufferData} */ + @NativeType("ALvoid") + public static void alBufferData(@NativeType("ALuint") int bufferName, @NativeType("ALenum") int format, @NativeType("ALvoid const *") float[] data, @NativeType("ALsizei") int frequency) { + long __functionAddress = AL.getICD().alBufferData; + invokePV(bufferName, format, data, data.length << 2, frequency, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/AL11.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/AL11.java new file mode 100644 index 00000000..3e70cec6 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/AL11.java @@ -0,0 +1,433 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** Native bindings to AL 1.1 functionality. */ +public class AL11 extends AL10 { + + /** General tokens. */ + public static final int + AL_SEC_OFFSET = 0x1024, + AL_SAMPLE_OFFSET = 0x1025, + AL_BYTE_OFFSET = 0x1026, + AL_STATIC = 0x1028, + AL_STREAMING = 0x1029, + AL_UNDETERMINED = 0x1030, + AL_ILLEGAL_COMMAND = 0xA004, + AL_SPEED_OF_SOUND = 0xC003, + AL_LINEAR_DISTANCE = 0xD003, + AL_LINEAR_DISTANCE_CLAMPED = 0xD004, + AL_EXPONENT_DISTANCE = 0xD005, + AL_EXPONENT_DISTANCE_CLAMPED = 0xD006; + + protected AL11() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(ALCapabilities caps) { + return checkFunctions( + caps.alListener3i, caps.alGetListeneriv, caps.alSource3i, caps.alListeneriv, caps.alSourceiv, caps.alBufferf, caps.alBuffer3f, caps.alBufferfv, + caps.alBufferi, caps.alBuffer3i, caps.alBufferiv, caps.alGetBufferiv, caps.alGetBufferfv, caps.alSpeedOfSound + ); + } + + // --- [ alListener3i ] --- + + /** + * Sets the 3 dimensional integer values of a listener parameter. + * + * @param paramName the parameter to modify + * @param value1 the first value + * @param value2 the second value + * @param value3 the third value + */ + @NativeType("ALvoid") + public static void alListener3i(@NativeType("ALenum") int paramName, @NativeType("ALint") int value1, @NativeType("ALint") int value2, @NativeType("ALint") int value3) { + long __functionAddress = AL.getICD().alListener3i; + if (CHECKS) { + check(__functionAddress); + } + invokeV(paramName, value1, value2, value3, __functionAddress); + } + + // --- [ alGetListeneriv ] --- + + /** Unsafe version of: {@link #alGetListeneriv GetListeneriv} */ + public static void nalGetListeneriv(int param, long values) { + long __functionAddress = AL.getICD().alGetListeneriv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(param, values, __functionAddress); + } + + /** + * Returns the integer values of the specified listener parameter. + * + * @param param the parameter to query + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alGetListeneriv(@NativeType("ALenum") int param, @NativeType("ALint *") IntBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalGetListeneriv(param, memAddress(values)); + } + + // --- [ alSource3i ] --- + + /** + * Sets the 3 dimensional integer values of a source parameter. + * + * @param source the source to modify + * @param paramName the parameter to modify + * @param value1 the first value + * @param value2 the second value + * @param value3 the third value + */ + @NativeType("ALvoid") + public static void alSource3i(@NativeType("ALuint") int source, @NativeType("ALenum") int paramName, @NativeType("ALint") int value1, @NativeType("ALint") int value2, @NativeType("ALint") int value3) { + long __functionAddress = AL.getICD().alSource3i; + if (CHECKS) { + check(__functionAddress); + } + invokeV(source, paramName, value1, value2, value3, __functionAddress); + } + + // --- [ alListeneriv ] --- + + /** Unsafe version of: {@link #alListeneriv Listeneriv} */ + public static void nalListeneriv(int listener, long value) { + long __functionAddress = AL.getICD().alListeneriv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(listener, value, __functionAddress); + } + + /** + * Pointer version. + * + * @param listener the parameter to modify + * @param value the parameter values + */ + @NativeType("ALvoid") + public static void alListeneriv(@NativeType("ALenum") int listener, @NativeType("ALint const *") IntBuffer value) { + if (CHECKS) { + check(value, 1); + } + nalListeneriv(listener, memAddress(value)); + } + + // --- [ alSourceiv ] --- + + /** Unsafe version of: {@link #alSourceiv Sourceiv} */ + public static void nalSourceiv(int source, int paramName, long value) { + long __functionAddress = AL.getICD().alSourceiv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(source, paramName, value, __functionAddress); + } + + /** + * Pointer version. + * + * @param source the source to modify + * @param paramName the parameter to modify + * @param value the parameter values + */ + @NativeType("ALvoid") + public static void alSourceiv(@NativeType("ALuint") int source, @NativeType("ALenum") int paramName, @NativeType("ALint const *") IntBuffer value) { + if (CHECKS) { + check(value, 1); + } + nalSourceiv(source, paramName, memAddress(value)); + } + + // --- [ alBufferf ] --- + + /** + * Sets the float value of a buffer parameter. + * + * @param buffer the buffer to modify + * @param paramName the parameter to modify + * @param value the value + */ + @NativeType("ALvoid") + public static void alBufferf(@NativeType("ALuint") int buffer, @NativeType("ALenum") int paramName, @NativeType("ALfloat") float value) { + long __functionAddress = AL.getICD().alBufferf; + if (CHECKS) { + check(__functionAddress); + } + invokeV(buffer, paramName, value, __functionAddress); + } + + // --- [ alBuffer3f ] --- + + /** + * Sets the dimensional value of a buffer parameter. + * + * @param buffer the buffer to modify + * @param paramName the parameter to modify + * @param value1 the first value + * @param value2 the second value + * @param value3 the third value + */ + @NativeType("ALvoid") + public static void alBuffer3f(@NativeType("ALuint") int buffer, @NativeType("ALenum") int paramName, @NativeType("ALfloat") float value1, @NativeType("ALfloat") float value2, @NativeType("ALfloat") float value3) { + long __functionAddress = AL.getICD().alBuffer3f; + if (CHECKS) { + check(__functionAddress); + } + invokeV(buffer, paramName, value1, value2, value3, __functionAddress); + } + + // --- [ alBufferfv ] --- + + /** Unsafe version of: {@link #alBufferfv Bufferfv} */ + public static void nalBufferfv(int buffer, int paramName, long value) { + long __functionAddress = AL.getICD().alBufferfv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(buffer, paramName, value, __functionAddress); + } + + /** + * the pointer version of {@link #alBufferf Bufferf} + * + * @param buffer the buffer to modify + * @param paramName the parameter to modify + * @param value the parameter values + */ + @NativeType("ALvoid") + public static void alBufferfv(@NativeType("ALuint") int buffer, @NativeType("ALenum") int paramName, @NativeType("ALfloat const *") FloatBuffer value) { + if (CHECKS) { + check(value, 1); + } + nalBufferfv(buffer, paramName, memAddress(value)); + } + + // --- [ alBufferi ] --- + + /** + * Sets the integer value of a buffer parameter. + * + * @param buffer the buffer to modify + * @param paramName the parameter to modify + * @param value the value + */ + @NativeType("ALvoid") + public static void alBufferi(@NativeType("ALuint") int buffer, @NativeType("ALenum") int paramName, @NativeType("ALint") int value) { + long __functionAddress = AL.getICD().alBufferi; + if (CHECKS) { + check(__functionAddress); + } + invokeV(buffer, paramName, value, __functionAddress); + } + + // --- [ alBuffer3i ] --- + + /** + * Sets the integer 3 dimensional value of a buffer parameter. + * + * @param buffer the buffer to modify + * @param paramName the parameter to modify + * @param value1 the first value + * @param value2 the second value + * @param value3 the third value + */ + @NativeType("ALvoid") + public static void alBuffer3i(@NativeType("ALuint") int buffer, @NativeType("ALenum") int paramName, @NativeType("ALint") int value1, @NativeType("ALint") int value2, @NativeType("ALint") int value3) { + long __functionAddress = AL.getICD().alBuffer3i; + if (CHECKS) { + check(__functionAddress); + } + invokeV(buffer, paramName, value1, value2, value3, __functionAddress); + } + + // --- [ alBufferiv ] --- + + /** Unsafe version of: {@link #alBufferiv Bufferiv} */ + public static void nalBufferiv(int buffer, int paramName, long value) { + long __functionAddress = AL.getICD().alBufferiv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(buffer, paramName, value, __functionAddress); + } + + /** + * the pointer version of {@link #alBufferi Bufferi} + * + * @param buffer the buffer to modify + * @param paramName the parameter to modify + * @param value the parameter values + */ + @NativeType("ALvoid") + public static void alBufferiv(@NativeType("ALuint") int buffer, @NativeType("ALenum") int paramName, @NativeType("ALint const *") IntBuffer value) { + if (CHECKS) { + check(value, 1); + } + nalBufferiv(buffer, paramName, memAddress(value)); + } + + // --- [ alGetBufferiv ] --- + + /** Unsafe version of: {@link #alGetBufferiv GetBufferiv} */ + public static void nalGetBufferiv(int buffer, int param, long values) { + long __functionAddress = AL.getICD().alGetBufferiv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(buffer, param, values, __functionAddress); + } + + /** + * Returns the integer values of the specified buffer parameter. + * + * @param buffer the buffer to query + * @param param the parameter to query + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alGetBufferiv(@NativeType("ALuint") int buffer, @NativeType("ALenum") int param, @NativeType("ALint *") IntBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalGetBufferiv(buffer, param, memAddress(values)); + } + + // --- [ alGetBufferfv ] --- + + /** Unsafe version of: {@link #alGetBufferfv GetBufferfv} */ + public static void nalGetBufferfv(int buffer, int param, long values) { + long __functionAddress = AL.getICD().alGetBufferfv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(buffer, param, values, __functionAddress); + } + + /** + * Returns the float values of the specified buffer parameter. + * + * @param buffer the buffer to query + * @param param the parameter to query + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alGetBufferfv(@NativeType("ALuint") int buffer, @NativeType("ALenum") int param, @NativeType("ALfloat *") FloatBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalGetBufferfv(buffer, param, memAddress(values)); + } + + // --- [ alSpeedOfSound ] --- + + /** + * Sets the speed of sound. + * + * @param value the speed of sound + */ + @NativeType("ALvoid") + public static void alSpeedOfSound(@NativeType("ALfloat") float value) { + long __functionAddress = AL.getICD().alSpeedOfSound; + if (CHECKS) { + check(__functionAddress); + } + invokeV(value, __functionAddress); + } + + /** Array version of: {@link #alGetListeneriv GetListeneriv} */ + @NativeType("ALvoid") + public static void alGetListeneriv(@NativeType("ALenum") int param, @NativeType("ALint *") int[] values) { + long __functionAddress = AL.getICD().alGetListeneriv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(param, values, __functionAddress); + } + + /** Array version of: {@link #alListeneriv Listeneriv} */ + @NativeType("ALvoid") + public static void alListeneriv(@NativeType("ALenum") int listener, @NativeType("ALint const *") int[] value) { + long __functionAddress = AL.getICD().alListeneriv; + if (CHECKS) { + check(__functionAddress); + check(value, 1); + } + invokePV(listener, value, __functionAddress); + } + + /** Array version of: {@link #alSourceiv Sourceiv} */ + @NativeType("ALvoid") + public static void alSourceiv(@NativeType("ALuint") int source, @NativeType("ALenum") int paramName, @NativeType("ALint const *") int[] value) { + long __functionAddress = AL.getICD().alSourceiv; + if (CHECKS) { + check(__functionAddress); + check(value, 1); + } + invokePV(source, paramName, value, __functionAddress); + } + + /** Array version of: {@link #alBufferfv Bufferfv} */ + @NativeType("ALvoid") + public static void alBufferfv(@NativeType("ALuint") int buffer, @NativeType("ALenum") int paramName, @NativeType("ALfloat const *") float[] value) { + long __functionAddress = AL.getICD().alBufferfv; + if (CHECKS) { + check(__functionAddress); + check(value, 1); + } + invokePV(buffer, paramName, value, __functionAddress); + } + + /** Array version of: {@link #alBufferiv Bufferiv} */ + @NativeType("ALvoid") + public static void alBufferiv(@NativeType("ALuint") int buffer, @NativeType("ALenum") int paramName, @NativeType("ALint const *") int[] value) { + long __functionAddress = AL.getICD().alBufferiv; + if (CHECKS) { + check(__functionAddress); + check(value, 1); + } + invokePV(buffer, paramName, value, __functionAddress); + } + + /** Array version of: {@link #alGetBufferiv GetBufferiv} */ + @NativeType("ALvoid") + public static void alGetBufferiv(@NativeType("ALuint") int buffer, @NativeType("ALenum") int param, @NativeType("ALint *") int[] values) { + long __functionAddress = AL.getICD().alGetBufferiv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(buffer, param, values, __functionAddress); + } + + /** Array version of: {@link #alGetBufferfv GetBufferfv} */ + @NativeType("ALvoid") + public static void alGetBufferfv(@NativeType("ALuint") int buffer, @NativeType("ALenum") int param, @NativeType("ALfloat *") float[] values) { + long __functionAddress = AL.getICD().alGetBufferfv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(buffer, param, values, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/ALC.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/ALC.java new file mode 100644 index 00000000..1a8f636e --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/ALC.java @@ -0,0 +1,234 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + */ +package org.lwjgl.openal; + +import org.lwjgl.system.*; + +import javax.annotation.*; +import java.nio.*; +import java.util.*; + +import static org.lwjgl.openal.ALC10.*; +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * This class must be used before any OpenAL function is called. It has the following responsibilities: + *The OpenAL library is loaded automatically when this class is initialized. Set the {@link Configuration#OPENAL_EXPLICIT_INIT} option to override this + * behavior. Manual loading/unloading can be achieved with the {@link #create} and {@link #destroy} functions. The name of the library loaded can be overridden + * with the {@link Configuration#OPENAL_LIBRARY_NAME} option.
+ * + *Instances of {@code ALCCapabilities} can be created with the {@link #createCapabilities} method. Calling this method is expensive, so + * {@code ALCCapabilities} instances should be cached in user code.
+ * + * @see AL + */ +public final class ALC { + + @Nullable + private static FunctionProviderLocal functionProvider; + + @Nullable + private static ALCCapabilities icd; + + static { + if (!Configuration.OPENAL_EXPLICIT_INIT.get(false)) { + create(); + } + } + + private ALC() {} + + /** Loads the OpenAL native library, using the default library name. */ + public static void create() { + String libName; + switch (Platform.get()) { + case FCL: + create("libopenal.so"); + return; + case LINUX: + case MACOSX: + libName = "openal"; + break; + case WINDOWS: + libName = "OpenAL"; + break; + default: + throw new IllegalStateException(); + } + + create(Configuration.OPENAL_LIBRARY_NAME.get(Platform.mapLibraryNameBundled(libName))); + } + + private static class SharedLibraryAL extends SharedLibrary.Delegate implements FunctionProviderLocal { + + private final long alcGetProcAddress = getFunctionAddress("alcGetProcAddress"); + + protected SharedLibraryAL(SharedLibrary library) { + super(library); + if (alcGetProcAddress == NULL) { + throw new RuntimeException("A core ALC function is missing. Make sure that the OpenAL library has been loaded correctly."); + } + } + + @Override + public long getFunctionAddress(ByteBuffer functionName) { + long address = library.getFunctionAddress(functionName); + if (address == NULL && Checks.DEBUG_FUNCTIONS) { + apiLog("Failed to locate address for ALC core function " + memASCII(functionName)); + } + return address; + } + + @Override + public long getFunctionAddress(long handle, ByteBuffer functionName) { + long address = invokePPP(handle, memAddress(functionName), alcGetProcAddress); + if (address == NULL && Checks.DEBUG_FUNCTIONS) { + apiLog("Failed to locate address for ALC extension function " + memASCII(functionName)); + } + return address; + } + + } + + /** + * Loads the OpenAL native library, using the specified library name. + * + * @param libName the native library name + */ + public static void create(String libName) { + SharedLibrary OPENAL = Library.loadNative(ALC.class, "org.lwjgl.openal", libName, true); + try { + create(new SharedLibraryAL(OPENAL)); + } catch (RuntimeException e) { + OPENAL.free(); + throw e; + } + } + + /** + * Initializes ALC with the specified {@link FunctionProviderLocal}. This method can be used to implement custom ALC library loading. + * + * @param functionProvider the provider of ALC function addresses + */ + public static void create(FunctionProviderLocal functionProvider) { + if (ALC.functionProvider != null) { + throw new IllegalStateException("ALC has already been created."); + } + + ALC.functionProvider = functionProvider; + + icd = new ALCCapabilities(functionProvider, NULL, Collections.emptySet()); + + AL.init(); + } + + /** Unloads the OpenAL native library. */ + public static void destroy() { + if (functionProvider == null) { + return; + } + + AL.destroy(); + + icd = null; + + if (functionProvider instanceof NativeResource) { + ((NativeResource)functionProvider).free(); + } + functionProvider = null; + } + + staticIf the function returns {@code NULL}, then no sound driver/device has been found. The argument is a null terminated string that requests a certain device or + * device configuration. If {@code NULL} is specified, the implementation will provide an implementation specific default.
+ * + * @param deviceSpecifier the requested device or device configuration + */ + @NativeType("ALCdevice *") + public static long alcOpenDevice(@Nullable @NativeType("ALCchar const *") ByteBuffer deviceSpecifier) { + if (CHECKS) { + checkNT1Safe(deviceSpecifier); + } + return nalcOpenDevice(memAddressSafe(deviceSpecifier)); + } + + /** + * Allows the application to connect to a device. + * + *If the function returns {@code NULL}, then no sound driver/device has been found. The argument is a null terminated string that requests a certain device or + * device configuration. If {@code NULL} is specified, the implementation will provide an implementation specific default.
+ * + * @param deviceSpecifier the requested device or device configuration + */ + @NativeType("ALCdevice *") + public static long alcOpenDevice(@Nullable @NativeType("ALCchar const *") CharSequence deviceSpecifier) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8Safe(deviceSpecifier, true); + long deviceSpecifierEncoded = deviceSpecifier == null ? NULL : stack.getPointerAddress(); + return nalcOpenDevice(deviceSpecifierEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alcCloseDevice ] --- + + /** + * Allows the application to disconnect from a device. + * + *The return code will be ALC_TRUE or ALC_FALSE, indicating success or failure. Failure will occur if all the device's contexts and buffers have not been + * destroyed. Once closed, the {@code deviceHandle} is invalid.
+ * + * @param deviceHandle the device to close + */ + @NativeType("ALCboolean") + public static boolean alcCloseDevice(@NativeType("ALCdevice const *") long deviceHandle) { + long __functionAddress = ALC.getICD().alcCloseDevice; + if (CHECKS) { + check(deviceHandle); + } + return invokePZ(deviceHandle, __functionAddress); + } + + // --- [ alcCreateContext ] --- + + /** Unsafe version of: {@link #alcCreateContext CreateContext} */ + public static long nalcCreateContext(long deviceHandle, long attrList) { + long __functionAddress = ALC.getICD().alcCreateContext; + if (CHECKS) { + check(deviceHandle); + } + return invokePPP(deviceHandle, attrList, __functionAddress); + } + + /** + * Creates an AL context. + * + * @param deviceHandle a valid device + * @param attrList null or a zero terminated list of integer pairs composed of valid ALC attribute tokens and requested values. One of:| {@link #ALC_FREQUENCY FREQUENCY} | {@link #ALC_REFRESH REFRESH} | {@link #ALC_SYNC SYNC} | {@link ALC11#ALC_MONO_SOURCES MONO_SOURCES} | {@link ALC11#ALC_STEREO_SOURCES STEREO_SOURCES} |
The context parameter can be {@code NULL} or a valid context pointer. Using {@code NULL} results in no context being current, which is useful when shutting OpenAL down. + * The operation will apply to the device that the context was created for.
+ * + *For each OS process (usually this means for each application), only one context can be current at any given time. All AL commands apply to the current + * context. Commands that affect objects shared among contexts (e.g. buffers) have side effects on other contexts.
+ * + * @param context the context to make current + */ + @NativeType("ALCboolean") + public static boolean alcMakeContextCurrent(@NativeType("ALCcontext *") long context) { + long __functionAddress = ALC.getICD().alcMakeContextCurrent; + return invokePZ(context, __functionAddress); + } + + // --- [ alcProcessContext ] --- + + /** + * The current context is the only context accessible to state changes by AL commands (aside from state changes affecting shared objects). However, + * multiple contexts can be processed at the same time. To indicate that a context should be processed (i.e. that internal execution state such as the + * offset increments are to be performed), the application uses {@code alcProcessContext}. + * + *Repeated calls to alcProcessContext are legal, and do not affect a context that is already marked as processing. The default state of a context created + * by alcCreateContext is that it is processing.
+ * + * @param context the context to mark for processing + */ + @NativeType("ALCvoid") + public static void alcProcessContext(@NativeType("ALCcontext *") long context) { + long __functionAddress = ALC.getICD().alcProcessContext; + if (CHECKS) { + check(context); + } + invokePV(context, __functionAddress); + } + + // --- [ alcSuspendContext ] --- + + /** + * The application can suspend any context from processing (including the current one). To indicate that a context should be suspended from processing + * (i.e. that internal execution state such as offset increments are not to be changed), the application uses {@code alcSuspendContext}. + * + *Repeated calls to alcSuspendContext are legal, and do not affect a context that is already marked as suspended.
+ * + * @param context the context to mark as suspended + */ + @NativeType("ALCvoid") + public static void alcSuspendContext(@NativeType("ALCcontext *") long context) { + long __functionAddress = ALC.getICD().alcSuspendContext; + if (CHECKS) { + check(context); + } + invokePV(context, __functionAddress); + } + + // --- [ alcDestroyContext ] --- + + /** + * Destroys a context. + * + *The correct way to destroy a context is to first release it using alcMakeCurrent with a {@code NULL} context. Applications should not attempt to destroy a + * current context – doing so will not work and will result in an ALC_INVALID_OPERATION error. All sources within a context will automatically be deleted + * during context destruction.
+ * + * @param context the context to destroy + */ + @NativeType("ALCvoid") + public static void alcDestroyContext(@NativeType("ALCcontext *") long context) { + long __functionAddress = ALC.getICD().alcDestroyContext; + if (CHECKS) { + check(context); + } + invokePV(context, __functionAddress); + } + + // --- [ alcGetCurrentContext ] --- + + /** Queries for, and obtains a handle to, the current context for the application. If there is no current context, {@code NULL} is returned. */ + @NativeType("ALCcontext *") + public static long alcGetCurrentContext() { + long __functionAddress = ALC.getICD().alcGetCurrentContext; + return invokeP(__functionAddress); + } + + // --- [ alcGetContextsDevice ] --- + + /** + * Queries for, and obtains a handle to, the device of a given context. + * + * @param context the context to query + */ + @NativeType("ALCdevice *") + public static long alcGetContextsDevice(@NativeType("ALCcontext *") long context) { + long __functionAddress = ALC.getICD().alcGetContextsDevice; + if (CHECKS) { + check(context); + } + return invokePP(context, __functionAddress); + } + + // --- [ alcIsExtensionPresent ] --- + + /** Unsafe version of: {@link #alcIsExtensionPresent IsExtensionPresent} */ + public static boolean nalcIsExtensionPresent(long deviceHandle, long extName) { + long __functionAddress = ALC.getICD().alcIsExtensionPresent; + return invokePPZ(deviceHandle, extName, __functionAddress); + } + + /** + * Verifies that a given extension is available for the current context and the device it is associated with. + * + *Invalid and unsupported string tokens return ALC_FALSE. A {@code NULL} deviceHandle is acceptable. {@code extName} is not case sensitive – the implementation + * will convert the name to all upper-case internally (and will express extension names in upper-case).
+ * + * @param deviceHandle the device to query + * @param extName the extension name + */ + @NativeType("ALCboolean") + public static boolean alcIsExtensionPresent(@NativeType("ALCdevice const *") long deviceHandle, @NativeType("ALCchar const *") ByteBuffer extName) { + if (CHECKS) { + checkNT1(extName); + } + return nalcIsExtensionPresent(deviceHandle, memAddress(extName)); + } + + /** + * Verifies that a given extension is available for the current context and the device it is associated with. + * + *Invalid and unsupported string tokens return ALC_FALSE. A {@code NULL} deviceHandle is acceptable. {@code extName} is not case sensitive – the implementation + * will convert the name to all upper-case internally (and will express extension names in upper-case).
+ * + * @param deviceHandle the device to query + * @param extName the extension name + */ + @NativeType("ALCboolean") + public static boolean alcIsExtensionPresent(@NativeType("ALCdevice const *") long deviceHandle, @NativeType("ALCchar const *") CharSequence extName) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nASCII(extName, true); + long extNameEncoded = stack.getPointerAddress(); + return nalcIsExtensionPresent(deviceHandle, extNameEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alcGetProcAddress ] --- + + /** Unsafe version of: {@link #alcGetProcAddress GetProcAddress} */ + public static long nalcGetProcAddress(long deviceHandle, long funcName) { + long __functionAddress = ALC.getICD().alcGetProcAddress; + return invokePPP(deviceHandle, funcName, __functionAddress); + } + + /** + * Retrieves extension entry points. + * + *The application is expected to verify the applicability of an extension or core function entry point before requesting it by name, by use of + * {@link #alcIsExtensionPresent IsExtensionPresent}.
+ * + *Entry points can be device specific, but are not context specific. Using a {@code NULL} device handle does not guarantee that the entry point is returned, + * even if available for one of the available devices.
+ * + * @param deviceHandle the device to query + * @param funcName the function name + */ + @NativeType("void *") + public static long alcGetProcAddress(@NativeType("ALCdevice const *") long deviceHandle, @NativeType("ALchar const *") ByteBuffer funcName) { + if (CHECKS) { + checkNT1(funcName); + } + return nalcGetProcAddress(deviceHandle, memAddress(funcName)); + } + + /** + * Retrieves extension entry points. + * + *The application is expected to verify the applicability of an extension or core function entry point before requesting it by name, by use of + * {@link #alcIsExtensionPresent IsExtensionPresent}.
+ * + *Entry points can be device specific, but are not context specific. Using a {@code NULL} device handle does not guarantee that the entry point is returned, + * even if available for one of the available devices.
+ * + * @param deviceHandle the device to query + * @param funcName the function name + */ + @NativeType("void *") + public static long alcGetProcAddress(@NativeType("ALCdevice const *") long deviceHandle, @NativeType("ALchar const *") CharSequence funcName) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nASCII(funcName, true); + long funcNameEncoded = stack.getPointerAddress(); + return nalcGetProcAddress(deviceHandle, funcNameEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alcGetEnumValue ] --- + + /** Unsafe version of: {@link #alcGetEnumValue GetEnumValue} */ + public static int nalcGetEnumValue(long deviceHandle, long enumName) { + long __functionAddress = ALC.getICD().alcGetEnumValue; + return invokePPI(deviceHandle, enumName, __functionAddress); + } + + /** + * Returns extension enum values. + * + *Enumeration/token values are device independent, but tokens defined for extensions might not be present for a given device. Using a {@code NULL} handle is + * legal, but only the tokens defined by the AL core are guaranteed. Availability of extension tokens depends on the ALC extension.
+ * + * @param deviceHandle the device to query + * @param enumName the enum name + */ + @NativeType("ALCenum") + public static int alcGetEnumValue(@NativeType("ALCdevice const *") long deviceHandle, @NativeType("ALCchar const *") ByteBuffer enumName) { + if (CHECKS) { + checkNT1(enumName); + } + return nalcGetEnumValue(deviceHandle, memAddress(enumName)); + } + + /** + * Returns extension enum values. + * + *Enumeration/token values are device independent, but tokens defined for extensions might not be present for a given device. Using a {@code NULL} handle is + * legal, but only the tokens defined by the AL core are guaranteed. Availability of extension tokens depends on the ALC extension.
+ * + * @param deviceHandle the device to query + * @param enumName the enum name + */ + @NativeType("ALCenum") + public static int alcGetEnumValue(@NativeType("ALCdevice const *") long deviceHandle, @NativeType("ALCchar const *") CharSequence enumName) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nASCII(enumName, true); + long enumNameEncoded = stack.getPointerAddress(); + return nalcGetEnumValue(deviceHandle, enumNameEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alcGetError ] --- + + /** + * Queries ALC errors. + * + *ALC uses the same conventions and mechanisms as AL for error handling. In particular, ALC does not use conventions derived from X11 (GLX) or Windows + * (WGL).
+ * + *Error conditions are specific to the device, and (like AL) a call to alcGetError resets the error state.
+ * + * @param deviceHandle the device to query + */ + @NativeType("ALCenum") + public static int alcGetError(@NativeType("ALCdevice *") long deviceHandle) { + long __functionAddress = ALC.getICD().alcGetError; + return invokePI(deviceHandle, __functionAddress); + } + + // --- [ alcGetString ] --- + + /** Unsafe version of: {@link #alcGetString GetString} */ + public static long nalcGetString(long deviceHandle, int token) { + long __functionAddress = ALC.getICD().alcGetString; + return invokePP(deviceHandle, token, __functionAddress); + } + + /** + * Obtains string value(s) from ALC. + * + *LWJGL note: Use {@link ALUtil#getStringList} for those tokens that return multiple values.
+ * + * @param deviceHandle the device to query + * @param token the information to query. One of:| {@link #ALC_DEFAULT_DEVICE_SPECIFIER DEFAULT_DEVICE_SPECIFIER} | {@link #ALC_DEVICE_SPECIFIER DEVICE_SPECIFIER} | {@link #ALC_EXTENSIONS EXTENSIONS} |
| {@link ALC11#ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER CAPTURE_DEFAULT_DEVICE_SPECIFIER} | {@link ALC11#ALC_CAPTURE_DEVICE_SPECIFIER CAPTURE_DEVICE_SPECIFIER} |
| {@link #ALC_MAJOR_VERSION MAJOR_VERSION} | {@link #ALC_MINOR_VERSION MINOR_VERSION} | {@link #ALC_ATTRIBUTES_SIZE ATTRIBUTES_SIZE} | {@link #ALC_ALL_ATTRIBUTES ALL_ATTRIBUTES} | {@link ALC11#ALC_CAPTURE_SAMPLES CAPTURE_SAMPLES} |
| {@link #ALC_MAJOR_VERSION MAJOR_VERSION} | {@link #ALC_MINOR_VERSION MINOR_VERSION} | {@link #ALC_ATTRIBUTES_SIZE ATTRIBUTES_SIZE} | {@link #ALC_ALL_ATTRIBUTES ALL_ATTRIBUTES} | {@link ALC11#ALC_CAPTURE_SAMPLES CAPTURE_SAMPLES} |
The {@code deviceName} argument is a null terminated string that requests a certain device or device configuration. If {@code NULL} is specified, the implementation + * will provide an implementation specific default.
+ * + * @param deviceName the device or device configuration + * @param frequency the audio frequency + * @param format the audio format + * @param samples the number of sample frames to buffer in the AL + */ + @NativeType("ALCdevice *") + public static long alcCaptureOpenDevice(@Nullable @NativeType("ALCchar const *") ByteBuffer deviceName, @NativeType("ALCuint") int frequency, @NativeType("ALCenum") int format, @NativeType("ALCsizei") int samples) { + if (CHECKS) { + checkNT1Safe(deviceName); + } + return nalcCaptureOpenDevice(memAddressSafe(deviceName), frequency, format, samples); + } + + /** + * Allows the application to connect to a capture device. + * + *The {@code deviceName} argument is a null terminated string that requests a certain device or device configuration. If {@code NULL} is specified, the implementation + * will provide an implementation specific default.
+ * + * @param deviceName the device or device configuration + * @param frequency the audio frequency + * @param format the audio format + * @param samples the number of sample frames to buffer in the AL + */ + @NativeType("ALCdevice *") + public static long alcCaptureOpenDevice(@Nullable @NativeType("ALCchar const *") CharSequence deviceName, @NativeType("ALCuint") int frequency, @NativeType("ALCenum") int format, @NativeType("ALCsizei") int samples) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8Safe(deviceName, true); + long deviceNameEncoded = deviceName == null ? NULL : stack.getPointerAddress(); + return nalcCaptureOpenDevice(deviceNameEncoded, frequency, format, samples); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alcCaptureCloseDevice ] --- + + /** + * Allows the application to disconnect from a capture device. + * + * @param device the capture device to close + */ + @NativeType("ALCboolean") + public static boolean alcCaptureCloseDevice(@NativeType("ALCdevice *") long device) { + long __functionAddress = ALC.getICD().alcCaptureCloseDevice; + if (CHECKS) { + check(__functionAddress); + check(device); + } + return invokePZ(device, __functionAddress); + } + + // --- [ alcCaptureStart ] --- + + /** + * Starts recording audio on the specific capture device. + * + *Once started, the device will record audio to an internal ring buffer, the size of which was specified when opening the device. The application may + * query the capture device to discover how much data is currently available via the alcGetInteger with the ALC_CAPTURE_SAMPLES token. This will report the + * number of sample frames currently available.
+ * + * @param device the capture device + */ + @NativeType("ALCvoid") + public static void alcCaptureStart(@NativeType("ALCdevice *") long device) { + long __functionAddress = ALC.getICD().alcCaptureStart; + if (CHECKS) { + check(__functionAddress); + check(device); + } + invokePV(device, __functionAddress); + } + + // --- [ alcCaptureStop ] --- + + /** + * Halts audio capturing without closing the capture device. + * + *The implementation is encouraged to optimize for this case. The amount of audio samples available after restarting a stopped capture device is reset to + * zero. The application does not need to stop the capture device to read from it.
+ * + * @param device the capture device + */ + @NativeType("ALCvoid") + public static void alcCaptureStop(@NativeType("ALCdevice *") long device) { + long __functionAddress = ALC.getICD().alcCaptureStop; + if (CHECKS) { + check(__functionAddress); + check(device); + } + invokePV(device, __functionAddress); + } + + // --- [ alcCaptureSamples ] --- + + /** Unsafe version of: {@link #alcCaptureSamples CaptureSamples} */ + public static void nalcCaptureSamples(long device, long buffer, int samples) { + long __functionAddress = ALC.getICD().alcCaptureSamples; + if (CHECKS) { + check(__functionAddress); + check(device); + } + invokePPV(device, buffer, samples, __functionAddress); + } + + /** + * Obtains captured audio samples from the AL. + * + *The implementation may defer conversion and resampling until this point. Requesting more sample frames than are currently available is an error.
+ * + * @param device the capture device + * @param buffer the buffer that will receive the samples. It must be big enough to contain at least {@code samples} sample frames. + * @param samples the number of sample frames to obtain + */ + @NativeType("ALCvoid") + public static void alcCaptureSamples(@NativeType("ALCdevice *") long device, @NativeType("ALCvoid *") ByteBuffer buffer, @NativeType("ALCsizei") int samples) { + nalcCaptureSamples(device, memAddress(buffer), samples); + } + + /** + * Obtains captured audio samples from the AL. + * + *The implementation may defer conversion and resampling until this point. Requesting more sample frames than are currently available is an error.
+ * + * @param device the capture device + * @param buffer the buffer that will receive the samples. It must be big enough to contain at least {@code samples} sample frames. + * @param samples the number of sample frames to obtain + */ + @NativeType("ALCvoid") + public static void alcCaptureSamples(@NativeType("ALCdevice *") long device, @NativeType("ALCvoid *") ShortBuffer buffer, @NativeType("ALCsizei") int samples) { + nalcCaptureSamples(device, memAddress(buffer), samples); + } + + /** + * Obtains captured audio samples from the AL. + * + *The implementation may defer conversion and resampling until this point. Requesting more sample frames than are currently available is an error.
+ * + * @param device the capture device + * @param buffer the buffer that will receive the samples. It must be big enough to contain at least {@code samples} sample frames. + * @param samples the number of sample frames to obtain + */ + @NativeType("ALCvoid") + public static void alcCaptureSamples(@NativeType("ALCdevice *") long device, @NativeType("ALCvoid *") IntBuffer buffer, @NativeType("ALCsizei") int samples) { + nalcCaptureSamples(device, memAddress(buffer), samples); + } + + /** + * Obtains captured audio samples from the AL. + * + *The implementation may defer conversion and resampling until this point. Requesting more sample frames than are currently available is an error.
+ * + * @param device the capture device + * @param buffer the buffer that will receive the samples. It must be big enough to contain at least {@code samples} sample frames. + * @param samples the number of sample frames to obtain + */ + @NativeType("ALCvoid") + public static void alcCaptureSamples(@NativeType("ALCdevice *") long device, @NativeType("ALCvoid *") FloatBuffer buffer, @NativeType("ALCsizei") int samples) { + nalcCaptureSamples(device, memAddress(buffer), samples); + } + + /** Array version of: {@link #alcCaptureSamples CaptureSamples} */ + @NativeType("ALCvoid") + public static void alcCaptureSamples(@NativeType("ALCdevice *") long device, @NativeType("ALCvoid *") short[] buffer, @NativeType("ALCsizei") int samples) { + long __functionAddress = ALC.getICD().alcCaptureSamples; + if (CHECKS) { + check(__functionAddress); + check(device); + } + invokePPV(device, buffer, samples, __functionAddress); + } + + /** Array version of: {@link #alcCaptureSamples CaptureSamples} */ + @NativeType("ALCvoid") + public static void alcCaptureSamples(@NativeType("ALCdevice *") long device, @NativeType("ALCvoid *") int[] buffer, @NativeType("ALCsizei") int samples) { + long __functionAddress = ALC.getICD().alcCaptureSamples; + if (CHECKS) { + check(__functionAddress); + check(device); + } + invokePPV(device, buffer, samples, __functionAddress); + } + + /** Array version of: {@link #alcCaptureSamples CaptureSamples} */ + @NativeType("ALCvoid") + public static void alcCaptureSamples(@NativeType("ALCdevice *") long device, @NativeType("ALCvoid *") float[] buffer, @NativeType("ALCsizei") int samples) { + long __functionAddress = ALC.getICD().alcCaptureSamples; + if (CHECKS) { + check(__functionAddress); + check(device); + } + invokePPV(device, buffer, samples, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/ALCCapabilities.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/ALCCapabilities.java new file mode 100644 index 00000000..a07b8522 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/ALCCapabilities.java @@ -0,0 +1,144 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +import org.lwjgl.system.*; +import java.util.Set; + +import static org.lwjgl.system.APIUtil.*; + +/** Defines the capabilities of the OpenAL Context API. */ +public final class ALCCapabilities { + + public final long + alcOpenDevice, + alcCloseDevice, + alcCreateContext, + alcMakeContextCurrent, + alcProcessContext, + alcSuspendContext, + alcDestroyContext, + alcGetCurrentContext, + alcGetContextsDevice, + alcIsExtensionPresent, + alcGetProcAddress, + alcGetEnumValue, + alcGetError, + alcGetString, + alcGetIntegerv, + alcCaptureOpenDevice, + alcCaptureCloseDevice, + alcCaptureStart, + alcCaptureStop, + alcCaptureSamples, + alcSetThreadContext, + alcGetThreadContext, + alcGetInteger64vSOFT, + alcGetStringiSOFT, + alcResetDeviceSOFT, + alcLoopbackOpenDeviceSOFT, + alcIsRenderFormatSupportedSOFT, + alcRenderSamplesSOFT, + alcDevicePauseSOFT, + alcDeviceResumeSOFT; + + /** When true, {@link ALC10} is supported. */ + public final boolean OpenALC10; + /** When true, {@link ALC11} is supported. */ + public final boolean OpenALC11; + /** When true, {@link EnumerateAllExt} is supported. */ + public final boolean ALC_ENUMERATE_ALL_EXT; + /** + * An OpenAL 1.1 implementation will always support the {@code ALC_ENUMERATION_EXT} extension. This extension provides for enumeration of the available OpenAL devices + * through {@link ALC10#alcGetString GetString}. An {@link ALC10#alcGetString GetString} query of {@link ALC10#ALC_DEVICE_SPECIFIER DEVICE_SPECIFIER} with a {@code NULL} device passed in will return a list of devices. Each + * device name will be separated by a single {@code NULL} character and the list will be terminated with two {@code NULL} characters. + */ + public final boolean ALC_ENUMERATION_EXT; + /** When true, {@link EXTCapture} is supported. */ + public final boolean ALC_EXT_CAPTURE; + /** When true, {@link EXTDedicated} is supported. */ + public final boolean ALC_EXT_DEDICATED; + /** When true, {@link EXTDefaultFilterOrder} is supported. */ + public final boolean ALC_EXT_DEFAULT_FILTER_ORDER; + /** When true, {@link EXTDisconnect} is supported. */ + public final boolean ALC_EXT_disconnect; + /** When true, {@link EXTEfx} is supported. */ + public final boolean ALC_EXT_EFX; + /** When true, {@link EXTThreadLocalContext} is supported. */ + public final boolean ALC_EXT_thread_local_context; + /** When true, {@link LOKIAudioChannel} is supported. */ + public final boolean ALC_LOKI_audio_channel; + /** When true, {@link SOFTDeviceClock} is supported. */ + public final boolean ALC_SOFT_device_clock; + /** When true, {@link SOFTHRTF} is supported. */ + public final boolean ALC_SOFT_HRTF; + /** When true, {@link SOFTLoopback} is supported. */ + public final boolean ALC_SOFT_loopback; + /** When true, {@link SOFTOutputLimiter} is supported. */ + public final boolean ALC_SOFT_output_limiter; + /** When true, {@link SOFTPauseDevice} is supported. */ + public final boolean ALC_SOFT_pause_device; + + ALCCapabilities(FunctionProviderLocal provider, long device, SetThis extension indicates support for the {@link #AL_FORMAT_BFORMAT2D_8 FORMAT_BFORMAT2D_8}, {@link #AL_FORMAT_BFORMAT2D_16 FORMAT_BFORMAT2D_16}, {@link #AL_FORMAT_BFORMAT2D_FLOAT32 FORMAT_BFORMAT2D_FLOAT32}, {@link #AL_FORMAT_BFORMAT3D_8 FORMAT_BFORMAT3D_8}, + * {@link #AL_FORMAT_BFORMAT3D_16 FORMAT_BFORMAT3D_16} and {@link #AL_FORMAT_BFORMAT3D_FLOAT32 FORMAT_BFORMAT3D_FLOAT32} buffer formats. These provide 2D (WXY) and 3D (WXYZ) 8bit int, 16bit int and ALfloat support for + * Ambisonic three- or four-channel B-Format (using W X Y Z channel ordering, encoded as the first three or four channels of Furse-Malham higher order + * Ambisonics). Use of these formats indicate that sources are Ambisonic sources. Such sources can be oriented via {@link AL10#alSourcefv Sourcefv} using the + * {@link AL10#AL_ORIENTATION ORIENTATION} tag, which takes the same parameters as {@code alListenerfv(AL_ORIENTATION,...)}. Such sources DO support {@link AL10#AL_SOURCE_RELATIVE SOURCE_RELATIVE} and the + * soundfield will rotate to reflect the listener's orientation if this is off (the default). Other behaviour is as for stereo or multichannel assets.
+ * + *Note that Ambisonics orients X, Y and Z axes in a different way to OpenAL. For clarity, we ignore the Ambisonic coordinate system in the API and stick + * to the OpenAL one, making sure that the Front of the Ambisonic soundfield (actually Ambisonic +X) matches the Front of the OpenAL coordinate system (-Z + * by default) etc. For instance, if the orientation of the source is set so that the "at" vector is to the left, then the front of the B-Format + * soundfield will be presented to the left.
+ */ +public final class EXTBFormat { + + /** Ambisonic formats. */ + public static final int + AL_FORMAT_BFORMAT2D_16 = 0x20022, + AL_FORMAT_BFORMAT2D_8 = 0x20021, + AL_FORMAT_BFORMAT2D_FLOAT32 = 0x20023, + AL_FORMAT_BFORMAT3D_16 = 0x20032, + AL_FORMAT_BFORMAT3D_8 = 0x20031, + AL_FORMAT_BFORMAT3D_FLOAT32 = 0x20033; + + private EXTBFormat() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTCapture.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTCapture.java new file mode 100644 index 00000000..8c1e745b --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTCapture.java @@ -0,0 +1,205 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the {@code ALC_EXT_CAPTURE} extension. + * + *An OpenAL 1.1 implementation will always support the {@code ALC_EXT_CAPTURE} extension. This allows an application written to the OpenAL 1.0 specification to + * access the capture abilities.
+ */ +public class EXTCapture { + + /** String queries. */ + public static final int + ALC_CAPTURE_DEVICE_SPECIFIER = 0x310, + ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER = 0x311; + + /** Integer queries. */ + public static final int ALC_CAPTURE_SAMPLES = 0x312; + + protected EXTCapture() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(ALCCapabilities caps) { + return checkFunctions( + caps.alcCaptureOpenDevice, caps.alcCaptureCloseDevice, caps.alcCaptureStart, caps.alcCaptureStop, caps.alcCaptureSamples + ); + } + + // --- [ alcCaptureOpenDevice ] --- + + /** Unsafe version of: {@link #alcCaptureOpenDevice CaptureOpenDevice} */ + public static long nalcCaptureOpenDevice(long deviceName, int frequency, int format, int samples) { + return ALC11.nalcCaptureOpenDevice(deviceName, frequency, format, samples); + } + + /** + * Allows the application to connect to a capture device. + * + *The {@code deviceName} argument is a null terminated string that requests a certain device or device configuration. If {@code NULL} is specified, the implementation + * will provide an implementation specific default.
+ * + * @param deviceName the device or device configuration + * @param frequency the audio frequency + * @param format the audio format + * @param samples the number of sample frames to buffer in the AL + */ + @NativeType("ALCdevice *") + public static long alcCaptureOpenDevice(@Nullable @NativeType("ALCchar const *") ByteBuffer deviceName, @NativeType("ALCuint") int frequency, @NativeType("ALCenum") int format, @NativeType("ALCsizei") int samples) { + return ALC11.alcCaptureOpenDevice(deviceName, frequency, format, samples); + } + + /** + * Allows the application to connect to a capture device. + * + *The {@code deviceName} argument is a null terminated string that requests a certain device or device configuration. If {@code NULL} is specified, the implementation + * will provide an implementation specific default.
+ * + * @param deviceName the device or device configuration + * @param frequency the audio frequency + * @param format the audio format + * @param samples the number of sample frames to buffer in the AL + */ + @NativeType("ALCdevice *") + public static long alcCaptureOpenDevice(@Nullable @NativeType("ALCchar const *") CharSequence deviceName, @NativeType("ALCuint") int frequency, @NativeType("ALCenum") int format, @NativeType("ALCsizei") int samples) { + return ALC11.alcCaptureOpenDevice(deviceName, frequency, format, samples); + } + + // --- [ alcCaptureCloseDevice ] --- + + /** + * Allows the application to disconnect from a capture device. + * + * @param device the capture device to close + */ + @NativeType("ALCboolean") + public static boolean alcCaptureCloseDevice(@NativeType("ALCdevice *") long device) { + return ALC11.alcCaptureCloseDevice(device); + } + + // --- [ alcCaptureStart ] --- + + /** + * Starts recording audio on the specific capture device. + * + *Once started, the device will record audio to an internal ring buffer, the size of which was specified when opening the device. The application may + * query the capture device to discover how much data is currently available via the alcGetInteger with the ALC_CAPTURE_SAMPLES token. This will report the + * number of sample frames currently available.
+ * + * @param device the capture device + */ + @NativeType("ALCvoid") + public static void alcCaptureStart(@NativeType("ALCdevice *") long device) { + ALC11.alcCaptureStart(device); + } + + // --- [ alcCaptureStop ] --- + + /** + * Halts audio capturing without closing the capture device. + * + *The implementation is encouraged to optimize for this case. The amount of audio samples available after restarting a stopped capture device is reset to + * zero. The application does not need to stop the capture device to read from it.
+ * + * @param device the capture device + */ + @NativeType("ALCvoid") + public static void alcCaptureStop(@NativeType("ALCdevice *") long device) { + ALC11.alcCaptureStop(device); + } + + // --- [ alcCaptureSamples ] --- + + /** Unsafe version of: {@link #alcCaptureSamples CaptureSamples} */ + public static void nalcCaptureSamples(long device, long buffer, int samples) { + ALC11.nalcCaptureSamples(device, buffer, samples); + } + + /** + * Obtains captured audio samples from the AL. + * + *The implementation may defer conversion and resampling until this point. Requesting more sample frames than are currently available is an error.
+ * + * @param device the capture device + * @param buffer the buffer that will receive the samples. It must be big enough to contain at least {@code samples} sample frames. + * @param samples the number of sample frames to obtain + */ + @NativeType("ALCvoid") + public static void alcCaptureSamples(@NativeType("ALCdevice *") long device, @NativeType("ALCvoid *") ByteBuffer buffer, @NativeType("ALCsizei") int samples) { + ALC11.alcCaptureSamples(device, buffer, samples); + } + + /** + * Obtains captured audio samples from the AL. + * + *The implementation may defer conversion and resampling until this point. Requesting more sample frames than are currently available is an error.
+ * + * @param device the capture device + * @param buffer the buffer that will receive the samples. It must be big enough to contain at least {@code samples} sample frames. + * @param samples the number of sample frames to obtain + */ + @NativeType("ALCvoid") + public static void alcCaptureSamples(@NativeType("ALCdevice *") long device, @NativeType("ALCvoid *") ShortBuffer buffer, @NativeType("ALCsizei") int samples) { + ALC11.alcCaptureSamples(device, buffer, samples); + } + + /** + * Obtains captured audio samples from the AL. + * + *The implementation may defer conversion and resampling until this point. Requesting more sample frames than are currently available is an error.
+ * + * @param device the capture device + * @param buffer the buffer that will receive the samples. It must be big enough to contain at least {@code samples} sample frames. + * @param samples the number of sample frames to obtain + */ + @NativeType("ALCvoid") + public static void alcCaptureSamples(@NativeType("ALCdevice *") long device, @NativeType("ALCvoid *") IntBuffer buffer, @NativeType("ALCsizei") int samples) { + ALC11.alcCaptureSamples(device, buffer, samples); + } + + /** + * Obtains captured audio samples from the AL. + * + *The implementation may defer conversion and resampling until this point. Requesting more sample frames than are currently available is an error.
+ * + * @param device the capture device + * @param buffer the buffer that will receive the samples. It must be big enough to contain at least {@code samples} sample frames. + * @param samples the number of sample frames to obtain + */ + @NativeType("ALCvoid") + public static void alcCaptureSamples(@NativeType("ALCdevice *") long device, @NativeType("ALCvoid *") FloatBuffer buffer, @NativeType("ALCsizei") int samples) { + ALC11.alcCaptureSamples(device, buffer, samples); + } + + /** Array version of: {@link #alcCaptureSamples CaptureSamples} */ + @NativeType("ALCvoid") + public static void alcCaptureSamples(@NativeType("ALCdevice *") long device, @NativeType("ALCvoid *") short[] buffer, @NativeType("ALCsizei") int samples) { + ALC11.alcCaptureSamples(device, buffer, samples); + } + + /** Array version of: {@link #alcCaptureSamples CaptureSamples} */ + @NativeType("ALCvoid") + public static void alcCaptureSamples(@NativeType("ALCdevice *") long device, @NativeType("ALCvoid *") int[] buffer, @NativeType("ALCsizei") int samples) { + ALC11.alcCaptureSamples(device, buffer, samples); + } + + /** Array version of: {@link #alcCaptureSamples CaptureSamples} */ + @NativeType("ALCvoid") + public static void alcCaptureSamples(@NativeType("ALCdevice *") long device, @NativeType("ALCvoid *") float[] buffer, @NativeType("ALCsizei") int samples) { + ALC11.alcCaptureSamples(device, buffer, samples); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTDedicated.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTDedicated.java new file mode 100644 index 00000000..c4a76a0a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTDedicated.java @@ -0,0 +1,29 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the {@code ALC_EXT_DEDICATED} extension. + * + *This extension provides two "routing" EFX effects that allow sounds to be sent to dedicated speaker channels. Audio rendered to the dedicated low + * frequency effect ({@link #AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT}) is routed to a subwoofer if one is present. Otherwise, it is discarded.
+ * + *Audio rendered to the dedicated dialogue effect ({@link #AL_EFFECT_DEDICATED_DIALOGUE EFFECT_DEDICATED_DIALOGUE}) is routed to a front centre speaker if one is present. Otherwise, it is + * rendered to the front centre using the normal spatialisation logic.
+ * + *Both effects support a gain control parameter {@link #AL_DEDICATED_GAIN DEDICATED_GAIN}, which defaults to 1.
+ */ +public final class EXTDedicated { + + /** {@code ALC_EXT_DEDICATED} tokens. */ + public static final int + AL_DEDICATED_GAIN = 0x1, + AL_EFFECT_DEDICATED_DIALOGUE = 0x9001, + AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT = 0x9000; + + private EXTDedicated() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTDefaultFilterOrder.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTDefaultFilterOrder.java new file mode 100644 index 00000000..1c1e4821 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTDefaultFilterOrder.java @@ -0,0 +1,23 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the {@code ALC_EXT_DEFAULT_FILTER_ORDER} extension. + * + *This extension allows the default filter order (i.e. slope) to be selected at context creation time. Attibute {@link #ALC_DEFAULT_FILTER_ORDER DEFAULT_FILTER_ORDER} can be used with a + * value of 1 (for -6dB/oct) or 2 (for -12dB/oct).
+ * + *{@link #ALC_DEFAULT_FILTER_ORDER DEFAULT_FILTER_ORDER} can also be used with {@link ALC10#alcGetIntegerv GetIntegerv} to find out the current default filter order.
+ */ +public final class EXTDefaultFilterOrder { + + /** {@code ALC_EXT_DEFAULT_FILTER_ORDER} tokens. */ + public static final int ALC_DEFAULT_FILTER_ORDER = 0x1100; + + private EXTDefaultFilterOrder() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTDisconnect.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTDisconnect.java new file mode 100644 index 00000000..4cb48da3 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTDisconnect.java @@ -0,0 +1,66 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the {@code ALC_EXT_disconnect} extension. + * + *In OpenAL, there is no way to know if a device has been lost, nor is there a spec-approved means to deal with this properly. While most people are + * using either PCI audio cards or a chip welded to their motherboard, there are many devices that are more dynamic in nature, such as USB and Firewire + * based-units. Such units may lose external power seperate from the system, or may have their cables unplugged at runtime. The OS may reassign the + * hardware to a higher-priority process. If nothing else, a user may unplug the hardware without a proper shutdown (or properly shut them down at the OS + * level and not within the application).
+ * + *Other audio "devices" may vanish, too, such as the network connection that hosts a remote audio device like esound, nas, or arts.
+ * + *In these cases, the OpenAL spec says nothing, which we must assume means that all resulting behaviour is totally undefined, including everything from + * continued function without audio output to a crash within the AL.
+ * + *This extension, ALC_EXT_disconnect, strives to define AL behaviour in these cases and give the application a means to discover and deal with total + * device failure.
+ * + *If a device is unplugged, lost or otherwise damaged beyond functioning, the device is flagged as "disconnected" and the ALCdevice handle is considered + * a "zombie" device.
+ * + *When a device is disconnected, the implementation will, in most respects, keep processing as normal. For example, even though there is no longer any + * output when a USB audio device is removed, setting and querying state on the Listener should keep functioning as expected.
+ * + *All sources in the {@link AL10#AL_PLAYING PLAYING} state will immediately progress to {@link AL10#AL_STOPPED STOPPED} upon disconnect of their containing device. Any source started after the + * disconnect will immediately progress to {@link AL10#AL_STOPPED STOPPED}. As in any stopped source, this also means that queued buffers all go to {@link AL10#AL_PROCESSED PROCESSED} as well. Sources + * that are in the {@link AL10#AL_PAUSED PAUSED} or {@link AL10#AL_INITIAL INITIAL} state do not change on disconnect, but will follow this behaviour if the application later tries to promote them to + * the {@link AL10#AL_PLAYING PLAYING} state.
+ * + *Zombie devices may not have new contexts created on them; {@link ALC10#alcCreateContext CreateContext} will fail, returning a {@code NULL} pointer, if the specified device has been + * disconnected.
+ * + *The application may determine if a device has been disconnected by using the {@link #ALC_CONNECTED CONNECTED} token with {@link ALC10#alcGetIntegerv GetIntegerv}. When a device has been + * disconnected, the application is permitted to close the zombie device's handle in the normal way, and may choose to open a new device.
+ * + *Applications that use {@link #ALC_CONNECTED CONNECTED} are encouraged to query it with relative frequency. A game, for example, should call it once per rendering frame, per + * device. A device may become disconnected at any time without warning.
+ * + *Once a device is disconnected, it will never become reconnected. Even if the user plugs the device back in, the application must close the existing + * zombie device handle and reopen it with {@code alc*OpenDevice()}.
+ * + *If device enumeration is available via ALC_ENUMERATION_EXT, ALC_ENUMERATE_ALL_EXT, or AL 1.1, the list of devices may change between calls as devices + * become disconnected and reconnected. To prevent race conditions, the pointer to device list strings provided to the application will remain valid until + * the next call to {@link ALC10#alcGetString GetString}. The implementation may either cache the result of the previous request or perform a complete device redetection + * during the {@link ALC10#alcGetString GetString} call. As such, enumeration may not be a "fast call" and should not be called in time-sensitive code. If capture devices + * are available via ALC_EXT_capture or AL 1.1, disconnection management can be used with both output and capture devices. A disconnected capture device + * will continue to function, but will not report a larger number in the {@link ALC11#ALC_CAPTURE_SAMPLES CAPTURE_SAMPLES} query. If the capture device had reported some number of + * samples were available but the samples were not transferred from the device to the AL at the time of disconnect, the AL should feed the application + * that amount of silence in the {@link ALC11#alcCaptureSamples CaptureSamples} call. Future queries of {@link ALC11#ALC_CAPTURE_SAMPLES CAPTURE_SAMPLES} should report zero samples available.
+ */ +public final class EXTDisconnect { + + /** {@code ALC_EXT_disconnect} tokens. */ + public static final int ALC_CONNECTED = 0x313; + + private EXTDisconnect() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTDouble.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTDouble.java new file mode 100644 index 00000000..a7db63ff --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTDouble.java @@ -0,0 +1,18 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** Native bindings to the {@code AL_EXT_DOUBLE} extension. */ +public final class EXTDouble { + + /** Buffer formats. */ + public static final int + AL_FORMAT_MONO_DOUBLE_EXT = 0x10012, + AL_FORMAT_STEREO_DOUBLE_EXT = 0x10013; + + private EXTDouble() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTEfx.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTEfx.java new file mode 100644 index 00000000..8baa5eef --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTEfx.java @@ -0,0 +1,1878 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the {@code ALC_EXT_EFX} extension. + * + *The Effects Extension is designed to provide a generic, cross-platform framework for adding advanced DSP effects to OpenAL.
+ */ +public class EXTEfx { + + /** ALC tokens. */ + public static final int + ALC_EFX_MAJOR_VERSION = 0x20001, + ALC_EFX_MINOR_VERSION = 0x20002, + ALC_MAX_AUXILIARY_SENDS = 0x20003; + + /** Listener properties. */ + public static final int AL_METERS_PER_UNIT = 0x20004; + + /** Source properties. */ + public static final int + AL_DIRECT_FILTER = 0x20005, + AL_AUXILIARY_SEND_FILTER = 0x20006, + AL_AIR_ABSORPTION_FACTOR = 0x20007, + AL_ROOM_ROLLOFF_FACTOR = 0x20008, + AL_CONE_OUTER_GAINHF = 0x20009, + AL_DIRECT_FILTER_GAINHF_AUTO = 0x2000A, + AL_AUXILIARY_SEND_FILTER_GAIN_AUTO = 0x2000B, + AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO = 0x2000C; + + /** Auxiliary effect slot properties. */ + public static final int + AL_EFFECTSLOT_NULL = 0x0, + AL_EFFECTSLOT_EFFECT = 0x1, + AL_EFFECTSLOT_GAIN = 0x2, + AL_EFFECTSLOT_AUXILIARY_SEND_AUTO = 0x3; + + /** Reverb effect parameters. */ + public static final int + AL_REVERB_DENSITY = 0x1, + AL_REVERB_DIFFUSION = 0x2, + AL_REVERB_GAIN = 0x3, + AL_REVERB_GAINHF = 0x4, + AL_REVERB_DECAY_TIME = 0x5, + AL_REVERB_DECAY_HFRATIO = 0x6, + AL_REVERB_REFLECTIONS_GAIN = 0x7, + AL_REVERB_REFLECTIONS_DELAY = 0x8, + AL_REVERB_LATE_REVERB_GAIN = 0x9, + AL_REVERB_LATE_REVERB_DELAY = 0xA, + AL_REVERB_AIR_ABSORPTION_GAINHF = 0xB, + AL_REVERB_ROOM_ROLLOFF_FACTOR = 0xC, + AL_REVERB_DECAY_HFLIMIT = 0xD; + + /** EAX Reverb effect parameters. */ + public static final int + AL_EAXREVERB_DENSITY = 0x1, + AL_EAXREVERB_DIFFUSION = 0x2, + AL_EAXREVERB_GAIN = 0x3, + AL_EAXREVERB_GAINHF = 0x4, + AL_EAXREVERB_GAINLF = 0x5, + AL_EAXREVERB_DECAY_TIME = 0x6, + AL_EAXREVERB_DECAY_HFRATIO = 0x7, + AL_EAXREVERB_DECAY_LFRATIO = 0x8, + AL_EAXREVERB_REFLECTIONS_GAIN = 0x9, + AL_EAXREVERB_REFLECTIONS_DELAY = 0xA, + AL_EAXREVERB_REFLECTIONS_PAN = 0xB, + AL_EAXREVERB_LATE_REVERB_GAIN = 0xC, + AL_EAXREVERB_LATE_REVERB_DELAY = 0xD, + AL_EAXREVERB_LATE_REVERB_PAN = 0xE, + AL_EAXREVERB_ECHO_TIME = 0xF, + AL_EAXREVERB_ECHO_DEPTH = 0x10, + AL_EAXREVERB_MODULATION_TIME = 0x11, + AL_EAXREVERB_MODULATION_DEPTH = 0x12, + AL_EAXREVERB_AIR_ABSORPTION_GAINHF = 0x13, + AL_EAXREVERB_HFREFERENCE = 0x14, + AL_EAXREVERB_LFREFERENCE = 0x15, + AL_EAXREVERB_ROOM_ROLLOFF_FACTOR = 0x16, + AL_EAXREVERB_DECAY_HFLIMIT = 0x17; + + /** Chorus effect parameters. */ + public static final int + AL_CHORUS_WAVEFORM = 0x1, + AL_CHORUS_PHASE = 0x2, + AL_CHORUS_RATE = 0x3, + AL_CHORUS_DEPTH = 0x4, + AL_CHORUS_FEEDBACK = 0x5, + AL_CHORUS_DELAY = 0x6; + + /** Distortion effect parameters. */ + public static final int + AL_DISTORTION_EDGE = 0x1, + AL_DISTORTION_GAIN = 0x2, + AL_DISTORTION_LOWPASS_CUTOFF = 0x3, + AL_DISTORTION_EQCENTER = 0x4, + AL_DISTORTION_EQBANDWIDTH = 0x5; + + /** Echo effect parameters. */ + public static final int + AL_ECHO_DELAY = 0x1, + AL_ECHO_LRDELAY = 0x2, + AL_ECHO_DAMPING = 0x3, + AL_ECHO_FEEDBACK = 0x4, + AL_ECHO_SPREAD = 0x5; + + /** Flanger effect parameters. */ + public static final int + AL_FLANGER_WAVEFORM = 0x1, + AL_FLANGER_PHASE = 0x2, + AL_FLANGER_RATE = 0x3, + AL_FLANGER_DEPTH = 0x4, + AL_FLANGER_FEEDBACK = 0x5, + AL_FLANGER_DELAY = 0x6; + + /** Frequency shifter effect parameters. */ + public static final int + AL_FREQUENCY_SHIFTER_FREQUENCY = 0x1, + AL_FREQUENCY_SHIFTER_LEFT_DIRECTION = 0x2, + AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION = 0x3; + + /** Vocal morpher effect parameters. */ + public static final int + AL_VOCMORPHER_PHONEMEA = 0x1, + AL_VOCMORPHER_PHONEMEA_COARSE_TUNING = 0x2, + AL_VOCMORPHER_PHONEMEB = 0x3, + AL_VOCMORPHER_PHONEMEB_COARSE_TUNING = 0x4, + AL_VOCMORPHER_WAVEFORM = 0x5, + AL_VOCMORPHER_RATE = 0x6; + + /** Pitch shifter effect parameters. */ + public static final int + AL_PITCH_SHIFTER_COARSE_TUNE = 0x1, + AL_PITCH_SHIFTER_FINE_TUNE = 0x2; + + /** Ring modulator effect parameters. */ + public static final int + AL_RING_MODULATOR_FREQUENCY = 0x1, + AL_RING_MODULATOR_HIGHPASS_CUTOFF = 0x2, + AL_RING_MODULATOR_WAVEFORM = 0x3; + + /** Autowah effect parameters. */ + public static final int + AL_AUTOWAH_ATTACK_TIME = 0x1, + AL_AUTOWAH_RELEASE_TIME = 0x2, + AL_AUTOWAH_RESONANCE = 0x3, + AL_AUTOWAH_PEAK_GAIN = 0x4; + + /** Compressor effect parameters. */ + public static final int AL_COMPRESSOR_ONOFF = 0x1; + + /** Equalizer effect parameters. */ + public static final int + AL_EQUALIZER_LOW_GAIN = 0x1, + AL_EQUALIZER_LOW_CUTOFF = 0x2, + AL_EQUALIZER_MID1_GAIN = 0x3, + AL_EQUALIZER_MID1_CENTER = 0x4, + AL_EQUALIZER_MID1_WIDTH = 0x5, + AL_EQUALIZER_MID2_GAIN = 0x6, + AL_EQUALIZER_MID2_CENTER = 0x7, + AL_EQUALIZER_MID2_WIDTH = 0x8, + AL_EQUALIZER_HIGH_GAIN = 0x9, + AL_EQUALIZER_HIGH_CUTOFF = 0xA; + + /** Effect type effect parameters. */ + public static final int + AL_EFFECT_FIRST_PARAMETER = 0x0, + AL_EFFECT_LAST_PARAMETER = 0x8000, + AL_EFFECT_TYPE = 0x8001; + + /** Effect types */ + public static final int + AL_EFFECT_NULL = 0x0, + AL_EFFECT_REVERB = 0x1, + AL_EFFECT_CHORUS = 0x2, + AL_EFFECT_DISTORTION = 0x3, + AL_EFFECT_ECHO = 0x4, + AL_EFFECT_FLANGER = 0x5, + AL_EFFECT_FREQUENCY_SHIFTER = 0x6, + AL_EFFECT_VOCAL_MORPHER = 0x7, + AL_EFFECT_PITCH_SHIFTER = 0x8, + AL_EFFECT_RING_MODULATOR = 0x9, + AL_EFFECT_AUTOWAH = 0xA, + AL_EFFECT_COMPRESSOR = 0xB, + AL_EFFECT_EQUALIZER = 0xC, + AL_EFFECT_EAXREVERB = 0x8000; + + /** Lowpass filter properties */ + public static final int + AL_LOWPASS_GAIN = 0x1, + AL_LOWPASS_GAINHF = 0x2; + + /** Highpass filter properties */ + public static final int + AL_HIGHPASS_GAIN = 0x1, + AL_HIGHPASS_GAINLF = 0x2; + + /** Bandpass filter properties */ + public static final int + AL_BANDPASS_GAIN = 0x1, + AL_BANDPASS_GAINLF = 0x2, + AL_BANDPASS_GAINHF = 0x3; + + /** Filter type */ + public static final int + AL_FILTER_FIRST_PARAMETER = 0x0, + AL_FILTER_LAST_PARAMETER = 0x8000, + AL_FILTER_TYPE = 0x8001; + + /** Filter types. */ + public static final int + AL_FILTER_NULL = 0x0, + AL_FILTER_LOWPASS = 0x1, + AL_FILTER_HIGHPASS = 0x2, + AL_FILTER_BANDPASS = 0x3; + + /** Source property value ranges and defaults */ + public static final float + AL_MIN_AIR_ABSORPTION_FACTOR = 0.0f, + AL_MAX_AIR_ABSORPTION_FACTOR = 10.0f, + AL_DEFAULT_AIR_ABSORPTION_FACTOR = 0.0f, + AL_MIN_ROOM_ROLLOFF_FACTOR = 0.0f, + AL_MAX_ROOM_ROLLOFF_FACTOR = 10.0f, + AL_DEFAULT_ROOM_ROLLOFF_FACTOR = 0.0f, + AL_MIN_CONE_OUTER_GAINHF = 0.0f, + AL_MAX_CONE_OUTER_GAINHF = 1.0f, + AL_DEFAULT_CONE_OUTER_GAINHF = 1.0f; + + /** Source property value ranges and defaults */ + public static final int + AL_MIN_DIRECT_FILTER_GAINHF_AUTO = 0x0, + AL_MAX_DIRECT_FILTER_GAINHF_AUTO = 0x1, + AL_DEFAULT_DIRECT_FILTER_GAINHF_AUTO = 0x1, + AL_MIN_AUXILIARY_SEND_FILTER_GAIN_AUTO = 0x0, + AL_MAX_AUXILIARY_SEND_FILTER_GAIN_AUTO = 0x1, + AL_DEFAULT_AUXILIARY_SEND_FILTER_GAIN_AUTO = 0x1, + AL_MIN_AUXILIARY_SEND_FILTER_GAINHF_AUTO = 0x0, + AL_MAX_AUXILIARY_SEND_FILTER_GAINHF_AUTO = 0x1, + AL_DEFAULT_AUXILIARY_SEND_FILTER_GAINHF_AUTO = 0x1; + + /** Listener property value ranges and defaults. */ + public static final float + AL_MIN_METERS_PER_UNIT = 0x0.000002P-126f, + AL_MAX_METERS_PER_UNIT = 0x1.fffffeP+127f, + AL_DEFAULT_METERS_PER_UNIT = 1.0f; + + /** Reverb effect parameter ranges and defaults */ + public static final float + AL_REVERB_MIN_DENSITY = 0.0f, + AL_REVERB_MAX_DENSITY = 1.0f, + AL_REVERB_DEFAULT_DENSITY = 1.0f, + AL_REVERB_MIN_DIFFUSION = 0.0f, + AL_REVERB_MAX_DIFFUSION = 1.0f, + AL_REVERB_DEFAULT_DIFFUSION = 1.0f, + AL_REVERB_MIN_GAIN = 0.0f, + AL_REVERB_MAX_GAIN = 1.0f, + AL_REVERB_DEFAULT_GAIN = 0.32f, + AL_REVERB_MIN_GAINHF = 0.0f, + AL_REVERB_MAX_GAINHF = 1.0f, + AL_REVERB_DEFAULT_GAINHF = 0.89f, + AL_REVERB_MIN_DECAY_TIME = 0.1f, + AL_REVERB_MAX_DECAY_TIME = 20.0f, + AL_REVERB_DEFAULT_DECAY_TIME = 1.49f, + AL_REVERB_MIN_DECAY_HFRATIO = 0.1f, + AL_REVERB_MAX_DECAY_HFRATIO = 2.0f, + AL_REVERB_DEFAULT_DECAY_HFRATIO = 0.83f, + AL_REVERB_MIN_REFLECTIONS_GAIN = 0.0f, + AL_REVERB_MAX_REFLECTIONS_GAIN = 3.16f, + AL_REVERB_DEFAULT_REFLECTIONS_GAIN = 0.05f, + AL_REVERB_MIN_REFLECTIONS_DELAY = 0.0f, + AL_REVERB_MAX_REFLECTIONS_DELAY = 0.3f, + AL_REVERB_DEFAULT_REFLECTIONS_DELAY = 0.007f, + AL_REVERB_MIN_LATE_REVERB_GAIN = 0.0f, + AL_REVERB_MAX_LATE_REVERB_GAIN = 10.0f, + AL_REVERB_DEFAULT_LATE_REVERB_GAIN = 1.26f, + AL_REVERB_MIN_LATE_REVERB_DELAY = 0.0f, + AL_REVERB_MAX_LATE_REVERB_DELAY = 0.1f, + AL_REVERB_DEFAULT_LATE_REVERB_DELAY = 0.011f, + AL_REVERB_MIN_AIR_ABSORPTION_GAINHF = 0.892f, + AL_REVERB_MAX_AIR_ABSORPTION_GAINHF = 1.0f, + AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF = 0.994f, + AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR = 0.0f, + AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR = 10.0f, + AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR = 0.0f; + + /** Reverb effect parameter ranges and defaults */ + public static final int + AL_REVERB_MIN_DECAY_HFLIMIT = 0x0, + AL_REVERB_MAX_DECAY_HFLIMIT = 0x1, + AL_REVERB_DEFAULT_DECAY_HFLIMIT = 0x1; + + /** EAX reverb effect parameter ranges and defaults */ + public static final float + AL_EAXREVERB_MIN_DENSITY = 0.0f, + AL_EAXREVERB_MAX_DENSITY = 1.0f, + AL_EAXREVERB_DEFAULT_DENSITY = 1.0f, + AL_EAXREVERB_MIN_DIFFUSION = 0.0f, + AL_EAXREVERB_MAX_DIFFUSION = 1.0f, + AL_EAXREVERB_DEFAULT_DIFFUSION = 1.0f, + AL_EAXREVERB_MIN_GAIN = 0.0f, + AL_EAXREVERB_MAX_GAIN = 1.0f, + AL_EAXREVERB_DEFAULT_GAIN = 0.32f, + AL_EAXREVERB_MIN_GAINHF = 0.0f, + AL_EAXREVERB_MAX_GAINHF = 1.0f, + AL_EAXREVERB_DEFAULT_GAINHF = 0.89f, + AL_EAXREVERB_MIN_GAINLF = 0.0f, + AL_EAXREVERB_MAX_GAINLF = 1.0f, + AL_EAXREVERB_DEFAULT_GAINLF = 1.0f, + AL_EAXREVERB_MIN_DECAY_TIME = 0.1f, + AL_EAXREVERB_MAX_DECAY_TIME = 20.0f, + AL_EAXREVERB_DEFAULT_DECAY_TIME = 1.49f, + AL_EAXREVERB_MIN_DECAY_HFRATIO = 0.1f, + AL_EAXREVERB_MAX_DECAY_HFRATIO = 2.0f, + AL_EAXREVERB_DEFAULT_DECAY_HFRATIO = 0.83f, + AL_EAXREVERB_MIN_DECAY_LFRATIO = 0.1f, + AL_EAXREVERB_MAX_DECAY_LFRATIO = 2.0f, + AL_EAXREVERB_DEFAULT_DECAY_LFRATIO = 1.0f, + AL_EAXREVERB_MIN_REFLECTIONS_GAIN = 0.0f, + AL_EAXREVERB_MAX_REFLECTIONS_GAIN = 3.16f, + AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN = 0.05f, + AL_EAXREVERB_MIN_REFLECTIONS_DELAY = 0.0f, + AL_EAXREVERB_MAX_REFLECTIONS_DELAY = 0.3f, + AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY = 0.007f, + AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ = 0.0f, + AL_EAXREVERB_MIN_LATE_REVERB_GAIN = 0.0f, + AL_EAXREVERB_MAX_LATE_REVERB_GAIN = 10.0f, + AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN = 1.26f, + AL_EAXREVERB_MIN_LATE_REVERB_DELAY = 0.0f, + AL_EAXREVERB_MAX_LATE_REVERB_DELAY = 0.1f, + AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY = 0.011f, + AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ = 0.0f, + AL_EAXREVERB_MIN_ECHO_TIME = 0.075f, + AL_EAXREVERB_MAX_ECHO_TIME = 0.25f, + AL_EAXREVERB_DEFAULT_ECHO_TIME = 0.25f, + AL_EAXREVERB_MIN_ECHO_DEPTH = 0.0f, + AL_EAXREVERB_MAX_ECHO_DEPTH = 1.0f, + AL_EAXREVERB_DEFAULT_ECHO_DEPTH = 0.0f, + AL_EAXREVERB_MIN_MODULATION_TIME = 0.04f, + AL_EAXREVERB_MAX_MODULATION_TIME = 4.0f, + AL_EAXREVERB_DEFAULT_MODULATION_TIME = 0.25f, + AL_EAXREVERB_MIN_MODULATION_DEPTH = 0.0f, + AL_EAXREVERB_MAX_MODULATION_DEPTH = 1.0f, + AL_EAXREVERB_DEFAULT_MODULATION_DEPTH = 0.0f, + AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF = 0.892f, + AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF = 1.0f, + AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF = 0.994f, + AL_EAXREVERB_MIN_HFREFERENCE = 1000.0f, + AL_EAXREVERB_MAX_HFREFERENCE = 20000.0f, + AL_EAXREVERB_DEFAULT_HFREFERENCE = 5000.0f, + AL_EAXREVERB_MIN_LFREFERENCE = 20.0f, + AL_EAXREVERB_MAX_LFREFERENCE = 1000.0f, + AL_EAXREVERB_DEFAULT_LFREFERENCE = 250.0f, + AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR = 0.0f, + AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR = 10.0f, + AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR = 0.0f; + + /** EAX reverb effect parameter ranges and defaults */ + public static final int + AL_EAXREVERB_MIN_DECAY_HFLIMIT = 0x0, + AL_EAXREVERB_MAX_DECAY_HFLIMIT = 0x1, + AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT = 0x1; + + /** Chorus effect parameter ranges and defaults */ + public static final int + AL_CHORUS_WAVEFORM_SINUSOID = 0, + AL_CHORUS_WAVEFORM_TRIANGLE = 1, + AL_CHORUS_MIN_WAVEFORM = 0, + AL_CHORUS_MAX_WAVEFORM = 1, + AL_CHORUS_DEFAULT_WAVEFORM = 1, + AL_CHORUS_MIN_PHASE = -180, + AL_CHORUS_MAX_PHASE = 180, + AL_CHORUS_DEFAULT_PHASE = 90; + + /** Chorus effect parameter ranges and defaults */ + public static final float + AL_CHORUS_MIN_RATE = 0.0f, + AL_CHORUS_MAX_RATE = 10.0f, + AL_CHORUS_DEFAULT_RATE = 1.1f, + AL_CHORUS_MIN_DEPTH = 0.0f, + AL_CHORUS_MAX_DEPTH = 1.0f, + AL_CHORUS_DEFAULT_DEPTH = 0.1f, + AL_CHORUS_MIN_FEEDBACK = -1.0f, + AL_CHORUS_MAX_FEEDBACK = 1.0f, + AL_CHORUS_DEFAULT_FEEDBACK = 0.25f, + AL_CHORUS_MIN_DELAY = 0.0f, + AL_CHORUS_MAX_DELAY = 0.016f, + AL_CHORUS_DEFAULT_DELAY = 0.016f; + + /** Distortion effect parameter ranges and defaults */ + public static final float + AL_DISTORTION_MIN_EDGE = 0.0f, + AL_DISTORTION_MAX_EDGE = 1.0f, + AL_DISTORTION_DEFAULT_EDGE = 0.2f, + AL_DISTORTION_MIN_GAIN = 0.01f, + AL_DISTORTION_MAX_GAIN = 1.0f, + AL_DISTORTION_DEFAULT_GAIN = 0.05f, + AL_DISTORTION_MIN_LOWPASS_CUTOFF = 80.0f, + AL_DISTORTION_MAX_LOWPASS_CUTOFF = 24000.0f, + AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF = 8000.0f, + AL_DISTORTION_MIN_EQCENTER = 80.0f, + AL_DISTORTION_MAX_EQCENTER = 24000.0f, + AL_DISTORTION_DEFAULT_EQCENTER = 3600.0f, + AL_DISTORTION_MIN_EQBANDWIDTH = 80.0f, + AL_DISTORTION_MAX_EQBANDWIDTH = 24000.0f, + AL_DISTORTION_DEFAULT_EQBANDWIDTH = 3600.0f; + + /** Echo effect parameter ranges and defaults */ + public static final float + AL_ECHO_MIN_DELAY = 0.0f, + AL_ECHO_MAX_DELAY = 0.207f, + AL_ECHO_DEFAULT_DELAY = 0.1f, + AL_ECHO_MIN_LRDELAY = 0.0f, + AL_ECHO_MAX_LRDELAY = 0.404f, + AL_ECHO_DEFAULT_LRDELAY = 0.1f, + AL_ECHO_MIN_DAMPING = 0.0f, + AL_ECHO_MAX_DAMPING = 0.99f, + AL_ECHO_DEFAULT_DAMPING = 0.5f, + AL_ECHO_MIN_FEEDBACK = 0.0f, + AL_ECHO_MAX_FEEDBACK = 1.0f, + AL_ECHO_DEFAULT_FEEDBACK = 0.5f, + AL_ECHO_MIN_SPREAD = -1.0f, + AL_ECHO_MAX_SPREAD = 1.0f, + AL_ECHO_DEFAULT_SPREAD = -1.0f; + + /** Flanger effect parameter ranges and defaults */ + public static final int + AL_FLANGER_WAVEFORM_SINUSOID = 0, + AL_FLANGER_WAVEFORM_TRIANGLE = 1, + AL_FLANGER_MIN_WAVEFORM = 0, + AL_FLANGER_MAX_WAVEFORM = 1, + AL_FLANGER_DEFAULT_WAVEFORM = 1, + AL_FLANGER_MIN_PHASE = -180, + AL_FLANGER_MAX_PHASE = 180, + AL_FLANGER_DEFAULT_PHASE = 0; + + /** Flanger effect parameter ranges and defaults */ + public static final float + AL_FLANGER_MIN_RATE = 0.0f, + AL_FLANGER_MAX_RATE = 10.0f, + AL_FLANGER_DEFAULT_RATE = 0.27f, + AL_FLANGER_MIN_DEPTH = 0.0f, + AL_FLANGER_MAX_DEPTH = 1.0f, + AL_FLANGER_DEFAULT_DEPTH = 1.0f, + AL_FLANGER_MIN_FEEDBACK = -1.0f, + AL_FLANGER_MAX_FEEDBACK = 1.0f, + AL_FLANGER_DEFAULT_FEEDBACK = -0.5f, + AL_FLANGER_MIN_DELAY = 0.0f, + AL_FLANGER_MAX_DELAY = 0.004f, + AL_FLANGER_DEFAULT_DELAY = 0.002f; + + /** Frequency shifter effect parameter ranges and defaults */ + public static final float + AL_FREQUENCY_SHIFTER_MIN_FREQUENCY = 0.0f, + AL_FREQUENCY_SHIFTER_MAX_FREQUENCY = 24000.0f, + AL_FREQUENCY_SHIFTER_DEFAULT_FREQUENCY = 0.0f; + + /** Frequency shifter effect parameter ranges and defaults */ + public static final int + AL_FREQUENCY_SHIFTER_MIN_LEFT_DIRECTION = 0, + AL_FREQUENCY_SHIFTER_MAX_LEFT_DIRECTION = 2, + AL_FREQUENCY_SHIFTER_DEFAULT_LEFT_DIRECTION = 0, + AL_FREQUENCY_SHIFTER_DIRECTION_DOWN = 0, + AL_FREQUENCY_SHIFTER_DIRECTION_UP = 1, + AL_FREQUENCY_SHIFTER_DIRECTION_OFF = 2, + AL_FREQUENCY_SHIFTER_MIN_RIGHT_DIRECTION = 0, + AL_FREQUENCY_SHIFTER_MAX_RIGHT_DIRECTION = 2, + AL_FREQUENCY_SHIFTER_DEFAULT_RIGHT_DIRECTION = 0; + + /** Vocal morpher effect parameter ranges and defaults */ + public static final int + AL_VOCAL_MORPHER_MIN_PHONEMEA = 0, + AL_VOCAL_MORPHER_MAX_PHONEMEA = 29, + AL_VOCAL_MORPHER_DEFAULT_PHONEMEA = 0, + AL_VOCAL_MORPHER_MIN_PHONEMEA_COARSE_TUNING = -24, + AL_VOCAL_MORPHER_MAX_PHONEMEA_COARSE_TUNING = 24, + AL_VOCAL_MORPHER_DEFAULT_PHONEMEA_COARSE_TUNING = 0, + AL_VOCAL_MORPHER_MIN_PHONEMEB = 0, + AL_VOCAL_MORPHER_MAX_PHONEMEB = 29, + AL_VOCAL_MORPHER_DEFAULT_PHONEMEB = 10, + AL_VOCAL_MORPHER_MIN_PHONEMEB_COARSE_TUNING = -24, + AL_VOCAL_MORPHER_MAX_PHONEMEB_COARSE_TUNING = 24, + AL_VOCAL_MORPHER_DEFAULT_PHONEMEB_COARSE_TUNING = 0, + AL_VOCAL_MORPHER_PHONEME_A = 0, + AL_VOCAL_MORPHER_PHONEME_E = 1, + AL_VOCAL_MORPHER_PHONEME_I = 2, + AL_VOCAL_MORPHER_PHONEME_O = 3, + AL_VOCAL_MORPHER_PHONEME_U = 4, + AL_VOCAL_MORPHER_PHONEME_AA = 5, + AL_VOCAL_MORPHER_PHONEME_AE = 6, + AL_VOCAL_MORPHER_PHONEME_AH = 7, + AL_VOCAL_MORPHER_PHONEME_AO = 8, + AL_VOCAL_MORPHER_PHONEME_EH = 9, + AL_VOCAL_MORPHER_PHONEME_ER = 10, + AL_VOCAL_MORPHER_PHONEME_IH = 11, + AL_VOCAL_MORPHER_PHONEME_IY = 12, + AL_VOCAL_MORPHER_PHONEME_UH = 13, + AL_VOCAL_MORPHER_PHONEME_UW = 14, + AL_VOCAL_MORPHER_PHONEME_B = 15, + AL_VOCAL_MORPHER_PHONEME_D = 16, + AL_VOCAL_MORPHER_PHONEME_F = 17, + AL_VOCAL_MORPHER_PHONEME_G = 18, + AL_VOCAL_MORPHER_PHONEME_J = 19, + AL_VOCAL_MORPHER_PHONEME_K = 20, + AL_VOCAL_MORPHER_PHONEME_L = 21, + AL_VOCAL_MORPHER_PHONEME_M = 22, + AL_VOCAL_MORPHER_PHONEME_N = 23, + AL_VOCAL_MORPHER_PHONEME_P = 24, + AL_VOCAL_MORPHER_PHONEME_R = 25, + AL_VOCAL_MORPHER_PHONEME_S = 26, + AL_VOCAL_MORPHER_PHONEME_T = 27, + AL_VOCAL_MORPHER_PHONEME_V = 28, + AL_VOCAL_MORPHER_PHONEME_Z = 29, + AL_VOCAL_MORPHER_WAVEFORM_SINUSOID = 0, + AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE = 1, + AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH = 2, + AL_VOCAL_MORPHER_MIN_WAVEFORM = 0, + AL_VOCAL_MORPHER_MAX_WAVEFORM = 2, + AL_VOCAL_MORPHER_DEFAULT_WAVEFORM = 0; + + /** Vocal morpher effect parameter ranges and defaults */ + public static final float + AL_VOCAL_MORPHER_MIN_RATE = 0.0f, + AL_VOCAL_MORPHER_MAX_RATE = 10.0f, + AL_VOCAL_MORPHER_DEFAULT_RATE = 1.41f; + + /** Pitch shifter effect parameter ranges and defaults */ + public static final int + AL_PITCH_SHIFTER_MIN_COARSE_TUNE = -12, + AL_PITCH_SHIFTER_MAX_COARSE_TUNE = 12, + AL_PITCH_SHIFTER_DEFAULT_COARSE_TUNE = 12, + AL_PITCH_SHIFTER_MIN_FINE_TUNE = -50, + AL_PITCH_SHIFTER_MAX_FINE_TUNE = 50, + AL_PITCH_SHIFTER_DEFAULT_FINE_TUNE = 0; + + /** Ring modulator effect parameter ranges and defaults */ + public static final float + AL_RING_MODULATOR_MIN_FREQUENCY = 0.0f, + AL_RING_MODULATOR_MAX_FREQUENCY = 8000.0f, + AL_RING_MODULATOR_DEFAULT_FREQUENCY = 440.0f, + AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF = 0.0f, + AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF = 24000.0f, + AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF = 800.0f; + + /** Ring modulator effect parameter ranges and defaults */ + public static final int + AL_RING_MODULATOR_SINUSOID = 0, + AL_RING_MODULATOR_SAWTOOTH = 1, + AL_RING_MODULATOR_SQUARE = 2, + AL_RING_MODULATOR_MIN_WAVEFORM = 0, + AL_RING_MODULATOR_MAX_WAVEFORM = 2, + AL_RING_MODULATOR_DEFAULT_WAVEFORM = 0; + + /** Autowah effect parameter ranges and defaults */ + public static final float + AL_AUTOWAH_MIN_ATTACK_TIME = 1.0E-4f, + AL_AUTOWAH_MAX_ATTACK_TIME = 1.0f, + AL_AUTOWAH_DEFAULT_ATTACK_TIME = 0.06f, + AL_AUTOWAH_MIN_RELEASE_TIME = 1.0E-4f, + AL_AUTOWAH_MAX_RELEASE_TIME = 1.0f, + AL_AUTOWAH_DEFAULT_RELEASE_TIME = 0.06f, + AL_AUTOWAH_MIN_RESONANCE = 2.0f, + AL_AUTOWAH_MAX_RESONANCE = 1000.0f, + AL_AUTOWAH_DEFAULT_RESONANCE = 1000.0f, + AL_AUTOWAH_MIN_PEAK_GAIN = 3.0E-5f, + AL_AUTOWAH_MAX_PEAK_GAIN = 31621.0f, + AL_AUTOWAH_DEFAULT_PEAK_GAIN = 11.22f; + + /** Compressor effect parameter ranges and defaults */ + public static final int + AL_COMPRESSOR_MIN_ONOFF = 0, + AL_COMPRESSOR_MAX_ONOFF = 1, + AL_COMPRESSOR_DEFAULT_ONOFF = 1; + + /** Equalizer effect parameter ranges and defaults */ + public static final float + AL_EQUALIZER_MIN_LOW_GAIN = 0.126f, + AL_EQUALIZER_MAX_LOW_GAIN = 7.943f, + AL_EQUALIZER_DEFAULT_LOW_GAIN = 1.0f, + AL_EQUALIZER_MIN_LOW_CUTOFF = 50.0f, + AL_EQUALIZER_MAX_LOW_CUTOFF = 800.0f, + AL_EQUALIZER_DEFAULT_LOW_CUTOFF = 200.0f, + AL_EQUALIZER_MIN_MID1_GAIN = 0.126f, + AL_EQUALIZER_MAX_MID1_GAIN = 7.943f, + AL_EQUALIZER_DEFAULT_MID1_GAIN = 1.0f, + AL_EQUALIZER_MIN_MID1_CENTER = 200.0f, + AL_EQUALIZER_MAX_MID1_CENTER = 3000.0f, + AL_EQUALIZER_DEFAULT_MID1_CENTER = 500.0f, + AL_EQUALIZER_MIN_MID1_WIDTH = 0.01f, + AL_EQUALIZER_MAX_MID1_WIDTH = 1.0f, + AL_EQUALIZER_DEFAULT_MID1_WIDTH = 1.0f, + AL_EQUALIZER_MIN_MID2_GAIN = 0.126f, + AL_EQUALIZER_MAX_MID2_GAIN = 7.943f, + AL_EQUALIZER_DEFAULT_MID2_GAIN = 1.0f, + AL_EQUALIZER_MIN_MID2_CENTER = 1000.0f, + AL_EQUALIZER_MAX_MID2_CENTER = 8000.0f, + AL_EQUALIZER_DEFAULT_MID2_CENTER = 3000.0f, + AL_EQUALIZER_MIN_MID2_WIDTH = 0.01f, + AL_EQUALIZER_MAX_MID2_WIDTH = 1.0f, + AL_EQUALIZER_DEFAULT_MID2_WIDTH = 1.0f, + AL_EQUALIZER_MIN_HIGH_GAIN = 0.126f, + AL_EQUALIZER_MAX_HIGH_GAIN = 7.943f, + AL_EQUALIZER_DEFAULT_HIGH_GAIN = 1.0f, + AL_EQUALIZER_MIN_HIGH_CUTOFF = 4000.0f, + AL_EQUALIZER_MAX_HIGH_CUTOFF = 16000.0f, + AL_EQUALIZER_DEFAULT_HIGH_CUTOFF = 6000.0f; + + /** Lowpass filter parameter ranges and defaults */ + public static final float + AL_LOWPASS_MIN_GAIN = 0.0f, + AL_LOWPASS_MAX_GAIN = 1.0f, + AL_LOWPASS_DEFAULT_GAIN = 1.0f, + AL_LOWPASS_MIN_GAINHF = 0.0f, + AL_LOWPASS_MAX_GAINHF = 1.0f, + AL_LOWPASS_DEFAULT_GAINHF = 1.0f; + + /** Highpass filter parameter ranges and defaults */ + public static final float + AL_HIGHPASS_MIN_GAIN = 0.0f, + AL_HIGHPASS_MAX_GAIN = 1.0f, + AL_HIGHPASS_DEFAULT_GAIN = 1.0f, + AL_HIGHPASS_MIN_GAINLF = 0.0f, + AL_HIGHPASS_MAX_GAINLF = 1.0f, + AL_HIGHPASS_DEFAULT_GAINLF = 1.0f; + + /** Bandpass filter parameter ranges and defaults */ + public static final float + AL_BANDPASS_MIN_GAIN = 0.0f, + AL_BANDPASS_MAX_GAIN = 1.0f, + AL_BANDPASS_DEFAULT_GAIN = 1.0f, + AL_BANDPASS_MIN_GAINHF = 0.0f, + AL_BANDPASS_MAX_GAINHF = 1.0f, + AL_BANDPASS_DEFAULT_GAINHF = 1.0f, + AL_BANDPASS_MIN_GAINLF = 0.0f, + AL_BANDPASS_MAX_GAINLF = 1.0f, + AL_BANDPASS_DEFAULT_GAINLF = 1.0f; + + protected EXTEfx() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(ALCapabilities caps) { + return checkFunctions( + caps.alGenEffects, caps.alDeleteEffects, caps.alIsEffect, caps.alEffecti, caps.alEffectiv, caps.alEffectf, caps.alEffectfv, caps.alGetEffecti, + caps.alGetEffectiv, caps.alGetEffectf, caps.alGetEffectfv, caps.alGenFilters, caps.alDeleteFilters, caps.alIsFilter, caps.alFilteri, + caps.alFilteriv, caps.alFilterf, caps.alFilterfv, caps.alGetFilteri, caps.alGetFilteriv, caps.alGetFilterf, caps.alGetFilterfv, + caps.alGenAuxiliaryEffectSlots, caps.alDeleteAuxiliaryEffectSlots, caps.alIsAuxiliaryEffectSlot, caps.alAuxiliaryEffectSloti, + caps.alAuxiliaryEffectSlotiv, caps.alAuxiliaryEffectSlotf, caps.alAuxiliaryEffectSlotfv, caps.alGetAuxiliaryEffectSloti, + caps.alGetAuxiliaryEffectSlotiv, caps.alGetAuxiliaryEffectSlotf, caps.alGetAuxiliaryEffectSlotfv + ); + } + + // --- [ alGenEffects ] --- + + /** + * Unsafe version of: {@link #alGenEffects GenEffects} + * + * @param n the number of effects be to generated + */ + public static void nalGenEffects(int n, long effects) { + long __functionAddress = AL.getICD().alGenEffects; + if (CHECKS) { + check(__functionAddress); + } + invokePV(n, effects, __functionAddress); + } + + /** + * Requests a number of effects. + * + * @param effects the buffer that will receive the effects + */ + @NativeType("ALvoid") + public static void alGenEffects(@NativeType("ALuint *") IntBuffer effects) { + nalGenEffects(effects.remaining(), memAddress(effects)); + } + + /** Requests a number of effects. */ + @NativeType("ALvoid") + public static int alGenEffects() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer effects = stack.callocInt(1); + nalGenEffects(1, memAddress(effects)); + return effects.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alDeleteEffects ] --- + + /** + * Unsafe version of: {@link #alDeleteEffects DeleteEffects} + * + * @param n the number of effects be to deleted + */ + public static void nalDeleteEffects(int n, long effects) { + long __functionAddress = AL.getICD().alDeleteEffects; + if (CHECKS) { + check(__functionAddress); + } + invokePV(n, effects, __functionAddress); + } + + /** + * Deletes a number of effects. + * + * @param effects the effect to delete + */ + @NativeType("ALvoid") + public static void alDeleteEffects(@NativeType("ALuint *") IntBuffer effects) { + nalDeleteEffects(effects.remaining(), memAddress(effects)); + } + + /** Deletes a number of effects. */ + @NativeType("ALvoid") + public static void alDeleteEffects(@NativeType("ALuint *") int effect) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer effects = stack.ints(effect); + nalDeleteEffects(1, memAddress(effects)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alIsEffect ] --- + + /** + * Verifies whether the given object name is an effect. + * + * @param effect a value that may be a effect name + */ + @NativeType("ALboolean") + public static boolean alIsEffect(@NativeType("ALuint") int effect) { + long __functionAddress = AL.getICD().alIsEffect; + if (CHECKS) { + check(__functionAddress); + } + return invokeZ(effect, __functionAddress); + } + + // --- [ alEffecti ] --- + + /** + * Sets the integer value of an effect parameter. + * + * @param effect the effect to modify + * @param param the parameter to modify + * @param value the parameter value + */ + @NativeType("ALvoid") + public static void alEffecti(@NativeType("ALuint") int effect, @NativeType("ALenum") int param, @NativeType("ALint") int value) { + long __functionAddress = AL.getICD().alEffecti; + if (CHECKS) { + check(__functionAddress); + } + invokeV(effect, param, value, __functionAddress); + } + + // --- [ alEffectiv ] --- + + /** Unsafe version of: {@link #alEffectiv Effectiv} */ + public static void nalEffectiv(int effect, int param, long values) { + long __functionAddress = AL.getICD().alEffectiv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effect, param, values, __functionAddress); + } + + /** + * Pointer version of {@link #alEffecti Effecti}. + * + * @param effect the effect to modify + * @param param the parameter to modify + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alEffectiv(@NativeType("ALuint") int effect, @NativeType("ALenum") int param, @NativeType("ALint const *") IntBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalEffectiv(effect, param, memAddress(values)); + } + + // --- [ alEffectf ] --- + + /** + * Sets the float value of an effect parameter. + * + * @param effect the effect to modify + * @param param the parameter to modify + * @param value the parameter value + */ + @NativeType("ALvoid") + public static void alEffectf(@NativeType("ALuint") int effect, @NativeType("ALenum") int param, @NativeType("ALfloat") float value) { + long __functionAddress = AL.getICD().alEffectf; + if (CHECKS) { + check(__functionAddress); + } + invokeV(effect, param, value, __functionAddress); + } + + // --- [ alEffectfv ] --- + + /** Unsafe version of: {@link #alEffectfv Effectfv} */ + public static void nalEffectfv(int effect, int param, long values) { + long __functionAddress = AL.getICD().alEffectfv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effect, param, values, __functionAddress); + } + + /** + * Pointer version of {@link #alEffectf Effectf}. + * + * @param effect the effect to modify + * @param param the parameter to modify + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alEffectfv(@NativeType("ALuint") int effect, @NativeType("ALenum") int param, @NativeType("ALfloat const *") FloatBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalEffectfv(effect, param, memAddress(values)); + } + + // --- [ alGetEffecti ] --- + + /** Unsafe version of: {@link #alGetEffecti GetEffecti} */ + public static void nalGetEffecti(int effect, int param, long value) { + long __functionAddress = AL.getICD().alGetEffecti; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effect, param, value, __functionAddress); + } + + /** + * Returns the integer value of the specified effect parameter. + * + * @param effect the effect to query + * @param param the parameter to query + * @param value the parameter value + */ + @NativeType("ALvoid") + public static void alGetEffecti(@NativeType("ALuint") int effect, @NativeType("ALenum") int param, @NativeType("ALint *") IntBuffer value) { + if (CHECKS) { + check(value, 1); + } + nalGetEffecti(effect, param, memAddress(value)); + } + + /** + * Returns the integer value of the specified effect parameter. + * + * @param effect the effect to query + * @param param the parameter to query + */ + @NativeType("ALvoid") + public static int alGetEffecti(@NativeType("ALuint") int effect, @NativeType("ALenum") int param) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer value = stack.callocInt(1); + nalGetEffecti(effect, param, memAddress(value)); + return value.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alGetEffectiv ] --- + + /** Unsafe version of: {@link #alGetEffectiv GetEffectiv} */ + public static void nalGetEffectiv(int effect, int param, long values) { + long __functionAddress = AL.getICD().alGetEffectiv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effect, param, values, __functionAddress); + } + + /** + * Returns the integer values of the specified effect parameter. + * + * @param effect the effect to query + * @param param the parameter to query + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alGetEffectiv(@NativeType("ALuint") int effect, @NativeType("ALenum") int param, @NativeType("ALint *") IntBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalGetEffectiv(effect, param, memAddress(values)); + } + + // --- [ alGetEffectf ] --- + + /** Unsafe version of: {@link #alGetEffectf GetEffectf} */ + public static void nalGetEffectf(int effect, int param, long value) { + long __functionAddress = AL.getICD().alGetEffectf; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effect, param, value, __functionAddress); + } + + /** + * Returns the float value of the specified effect parameter. + * + * @param effect the effect to query + * @param param the parameter to query + * @param value the parameter value + */ + @NativeType("ALvoid") + public static void alGetEffectf(@NativeType("ALuint") int effect, @NativeType("ALenum") int param, @NativeType("ALfloat *") FloatBuffer value) { + if (CHECKS) { + check(value, 1); + } + nalGetEffectf(effect, param, memAddress(value)); + } + + /** + * Returns the float value of the specified effect parameter. + * + * @param effect the effect to query + * @param param the parameter to query + */ + @NativeType("ALvoid") + public static float alGetEffectf(@NativeType("ALuint") int effect, @NativeType("ALenum") int param) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + FloatBuffer value = stack.callocFloat(1); + nalGetEffectf(effect, param, memAddress(value)); + return value.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alGetEffectfv ] --- + + /** Unsafe version of: {@link #alGetEffectfv GetEffectfv} */ + public static void nalGetEffectfv(int effect, int param, long values) { + long __functionAddress = AL.getICD().alGetEffectfv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effect, param, values, __functionAddress); + } + + /** + * Returns the float values of the specified effect parameter. + * + * @param effect the effect to query + * @param param the parameter to query + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alGetEffectfv(@NativeType("ALuint") int effect, @NativeType("ALenum") int param, @NativeType("ALfloat *") FloatBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalGetEffectfv(effect, param, memAddress(values)); + } + + // --- [ alGenFilters ] --- + + /** + * Unsafe version of: {@link #alGenFilters GenFilters} + * + * @param n the number of filters be to generated + */ + public static void nalGenFilters(int n, long filters) { + long __functionAddress = AL.getICD().alGenFilters; + if (CHECKS) { + check(__functionAddress); + } + invokePV(n, filters, __functionAddress); + } + + /** + * Requests a number of filters. + * + * @param filters the buffer that will receive the filters + */ + @NativeType("ALvoid") + public static void alGenFilters(@NativeType("ALuint *") IntBuffer filters) { + nalGenFilters(filters.remaining(), memAddress(filters)); + } + + /** Requests a number of filters. */ + @NativeType("ALvoid") + public static int alGenFilters() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer filters = stack.callocInt(1); + nalGenFilters(1, memAddress(filters)); + return filters.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alDeleteFilters ] --- + + /** + * Unsafe version of: {@link #alDeleteFilters DeleteFilters} + * + * @param n the number of filters be to deleted + */ + public static void nalDeleteFilters(int n, long filters) { + long __functionAddress = AL.getICD().alDeleteFilters; + if (CHECKS) { + check(__functionAddress); + } + invokePV(n, filters, __functionAddress); + } + + /** + * Deletes a number of filters. + * + * @param filters the filter to delete + */ + @NativeType("ALvoid") + public static void alDeleteFilters(@NativeType("ALuint *") IntBuffer filters) { + nalDeleteFilters(filters.remaining(), memAddress(filters)); + } + + /** Deletes a number of filters. */ + @NativeType("ALvoid") + public static void alDeleteFilters(@NativeType("ALuint *") int filter) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer filters = stack.ints(filter); + nalDeleteFilters(1, memAddress(filters)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alIsFilter ] --- + + /** + * Verifies whether the given object name is a filter. + * + * @param filter a value that may be a filter name + */ + @NativeType("ALboolean") + public static boolean alIsFilter(@NativeType("ALuint") int filter) { + long __functionAddress = AL.getICD().alIsFilter; + if (CHECKS) { + check(__functionAddress); + } + return invokeZ(filter, __functionAddress); + } + + // --- [ alFilteri ] --- + + /** + * Sets the integer value of a filter parameter. + * + * @param filter the filter to modify + * @param param the parameter to modify + * @param value the parameter value + */ + @NativeType("ALvoid") + public static void alFilteri(@NativeType("ALuint") int filter, @NativeType("ALenum") int param, @NativeType("ALint") int value) { + long __functionAddress = AL.getICD().alFilteri; + if (CHECKS) { + check(__functionAddress); + } + invokeV(filter, param, value, __functionAddress); + } + + // --- [ alFilteriv ] --- + + /** Unsafe version of: {@link #alFilteriv Filteriv} */ + public static void nalFilteriv(int filter, int param, long values) { + long __functionAddress = AL.getICD().alFilteriv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(filter, param, values, __functionAddress); + } + + /** + * Pointer version of {@link #alFilteri Filteri}. + * + * @param filter the filter to modify + * @param param the parameter to modify + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alFilteriv(@NativeType("ALuint") int filter, @NativeType("ALenum") int param, @NativeType("ALint const *") IntBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalFilteriv(filter, param, memAddress(values)); + } + + // --- [ alFilterf ] --- + + /** + * Sets the float value of a filter parameter. + * + * @param filter the filter to modify + * @param param the parameter to modify + * @param value the parameter value + */ + @NativeType("ALvoid") + public static void alFilterf(@NativeType("ALuint") int filter, @NativeType("ALenum") int param, @NativeType("ALfloat") float value) { + long __functionAddress = AL.getICD().alFilterf; + if (CHECKS) { + check(__functionAddress); + } + invokeV(filter, param, value, __functionAddress); + } + + // --- [ alFilterfv ] --- + + /** Unsafe version of: {@link #alFilterfv Filterfv} */ + public static void nalFilterfv(int filter, int param, long values) { + long __functionAddress = AL.getICD().alFilterfv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(filter, param, values, __functionAddress); + } + + /** + * Pointer version of {@link #alFilterf Filterf}. + * + * @param filter the filter to modify + * @param param the parameter to modify + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alFilterfv(@NativeType("ALuint") int filter, @NativeType("ALenum") int param, @NativeType("ALfloat const *") FloatBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalFilterfv(filter, param, memAddress(values)); + } + + // --- [ alGetFilteri ] --- + + /** Unsafe version of: {@link #alGetFilteri GetFilteri} */ + public static void nalGetFilteri(int filter, int param, long value) { + long __functionAddress = AL.getICD().alGetFilteri; + if (CHECKS) { + check(__functionAddress); + } + invokePV(filter, param, value, __functionAddress); + } + + /** + * Returns the integer value of the specified filter parameter. + * + * @param filter the filter to query + * @param param the parameter to query + * @param value the parameter value + */ + @NativeType("ALvoid") + public static void alGetFilteri(@NativeType("ALuint") int filter, @NativeType("ALenum") int param, @NativeType("ALint *") IntBuffer value) { + if (CHECKS) { + check(value, 1); + } + nalGetFilteri(filter, param, memAddress(value)); + } + + /** + * Returns the integer value of the specified filter parameter. + * + * @param filter the filter to query + * @param param the parameter to query + */ + @NativeType("ALvoid") + public static int alGetFilteri(@NativeType("ALuint") int filter, @NativeType("ALenum") int param) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer value = stack.callocInt(1); + nalGetFilteri(filter, param, memAddress(value)); + return value.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alGetFilteriv ] --- + + /** Unsafe version of: {@link #alGetFilteriv GetFilteriv} */ + public static void nalGetFilteriv(int filter, int param, long values) { + long __functionAddress = AL.getICD().alGetFilteriv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(filter, param, values, __functionAddress); + } + + /** + * Returns the integer values of the specified filter parameter. + * + * @param filter the filter to query + * @param param the parameter to query + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alGetFilteriv(@NativeType("ALuint") int filter, @NativeType("ALenum") int param, @NativeType("ALint *") IntBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalGetFilteriv(filter, param, memAddress(values)); + } + + // --- [ alGetFilterf ] --- + + /** Unsafe version of: {@link #alGetFilterf GetFilterf} */ + public static void nalGetFilterf(int filter, int param, long value) { + long __functionAddress = AL.getICD().alGetFilterf; + if (CHECKS) { + check(__functionAddress); + } + invokePV(filter, param, value, __functionAddress); + } + + /** + * Returns the float value of the specified filter parameter. + * + * @param filter the effect to query + * @param param the parameter to query + * @param value the parameter value + */ + @NativeType("ALvoid") + public static void alGetFilterf(@NativeType("ALuint") int filter, @NativeType("ALenum") int param, @NativeType("ALfloat *") FloatBuffer value) { + if (CHECKS) { + check(value, 1); + } + nalGetFilterf(filter, param, memAddress(value)); + } + + /** + * Returns the float value of the specified filter parameter. + * + * @param filter the effect to query + * @param param the parameter to query + */ + @NativeType("ALvoid") + public static float alGetFilterf(@NativeType("ALuint") int filter, @NativeType("ALenum") int param) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + FloatBuffer value = stack.callocFloat(1); + nalGetFilterf(filter, param, memAddress(value)); + return value.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alGetFilterfv ] --- + + /** Unsafe version of: {@link #alGetFilterfv GetFilterfv} */ + public static void nalGetFilterfv(int filter, int param, long values) { + long __functionAddress = AL.getICD().alGetFilterfv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(filter, param, values, __functionAddress); + } + + /** + * Returns the float values of the specified filter parameter. + * + * @param filter the effect to query + * @param param the parameter to query + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alGetFilterfv(@NativeType("ALuint") int filter, @NativeType("ALenum") int param, @NativeType("ALfloat *") FloatBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalGetFilterfv(filter, param, memAddress(values)); + } + + // --- [ alGenAuxiliaryEffectSlots ] --- + + /** + * Unsafe version of: {@link #alGenAuxiliaryEffectSlots GenAuxiliaryEffectSlots} + * + * @param n the number of effect slots be to generated + */ + public static void nalGenAuxiliaryEffectSlots(int n, long effectSlots) { + long __functionAddress = AL.getICD().alGenAuxiliaryEffectSlots; + if (CHECKS) { + check(__functionAddress); + } + invokePV(n, effectSlots, __functionAddress); + } + + /** + * Requests a number of effect slots. + * + * @param effectSlots the buffer that will receive the effect slots + */ + @NativeType("ALvoid") + public static void alGenAuxiliaryEffectSlots(@NativeType("ALuint *") IntBuffer effectSlots) { + nalGenAuxiliaryEffectSlots(effectSlots.remaining(), memAddress(effectSlots)); + } + + /** Requests a number of effect slots. */ + @NativeType("ALvoid") + public static int alGenAuxiliaryEffectSlots() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer effectSlots = stack.callocInt(1); + nalGenAuxiliaryEffectSlots(1, memAddress(effectSlots)); + return effectSlots.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alDeleteAuxiliaryEffectSlots ] --- + + /** + * Unsafe version of: {@link #alDeleteAuxiliaryEffectSlots DeleteAuxiliaryEffectSlots} + * + * @param n the number of effect slots be to deleted + */ + public static void nalDeleteAuxiliaryEffectSlots(int n, long effectSlots) { + long __functionAddress = AL.getICD().alDeleteAuxiliaryEffectSlots; + if (CHECKS) { + check(__functionAddress); + } + invokePV(n, effectSlots, __functionAddress); + } + + /** + * Deletes a number of effect slots. + * + * @param effectSlots the effectSlot to delete + */ + @NativeType("ALvoid") + public static void alDeleteAuxiliaryEffectSlots(@NativeType("ALuint *") IntBuffer effectSlots) { + nalDeleteAuxiliaryEffectSlots(effectSlots.remaining(), memAddress(effectSlots)); + } + + /** Deletes a number of effect slots. */ + @NativeType("ALvoid") + public static void alDeleteAuxiliaryEffectSlots(@NativeType("ALuint *") int effectSlot) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer effectSlots = stack.ints(effectSlot); + nalDeleteAuxiliaryEffectSlots(1, memAddress(effectSlots)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alIsAuxiliaryEffectSlot ] --- + + /** + * Verifies whether the given object name is an effect slot. + * + * @param effectSlot a value that may be an effect slot name + */ + @NativeType("ALboolean") + public static boolean alIsAuxiliaryEffectSlot(@NativeType("ALuint") int effectSlot) { + long __functionAddress = AL.getICD().alIsAuxiliaryEffectSlot; + if (CHECKS) { + check(__functionAddress); + } + return invokeZ(effectSlot, __functionAddress); + } + + // --- [ alAuxiliaryEffectSloti ] --- + + /** + * Sets the integer value of an effect slot parameter. + * + * @param effectSlot the effect slot to modify + * @param param the parameter to modify + * @param value the parameter value + */ + @NativeType("ALvoid") + public static void alAuxiliaryEffectSloti(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param, @NativeType("ALint") int value) { + long __functionAddress = AL.getICD().alAuxiliaryEffectSloti; + if (CHECKS) { + check(__functionAddress); + } + invokeV(effectSlot, param, value, __functionAddress); + } + + // --- [ alAuxiliaryEffectSlotiv ] --- + + /** Unsafe version of: {@link #alAuxiliaryEffectSlotiv AuxiliaryEffectSlotiv} */ + public static void nalAuxiliaryEffectSlotiv(int effectSlot, int param, long values) { + long __functionAddress = AL.getICD().alAuxiliaryEffectSlotiv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effectSlot, param, values, __functionAddress); + } + + /** + * Pointer version of {@link #alAuxiliaryEffectSloti AuxiliaryEffectSloti}. + * + * @param effectSlot the effect slot to modify + * @param param the parameter to modify + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alAuxiliaryEffectSlotiv(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param, @NativeType("ALint const *") IntBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalAuxiliaryEffectSlotiv(effectSlot, param, memAddress(values)); + } + + // --- [ alAuxiliaryEffectSlotf ] --- + + /** + * Sets the float value of an effect slot parameter. + * + * @param effectSlot the effect slot to modify + * @param param the parameter to modify + * @param value the parameter value + */ + @NativeType("ALvoid") + public static void alAuxiliaryEffectSlotf(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param, @NativeType("ALfloat") float value) { + long __functionAddress = AL.getICD().alAuxiliaryEffectSlotf; + if (CHECKS) { + check(__functionAddress); + } + invokeV(effectSlot, param, value, __functionAddress); + } + + // --- [ alAuxiliaryEffectSlotfv ] --- + + /** Unsafe version of: {@link #alAuxiliaryEffectSlotfv AuxiliaryEffectSlotfv} */ + public static void nalAuxiliaryEffectSlotfv(int effectSlot, int param, long values) { + long __functionAddress = AL.getICD().alAuxiliaryEffectSlotfv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effectSlot, param, values, __functionAddress); + } + + /** + * Pointer version of {@link #alAuxiliaryEffectSlotf AuxiliaryEffectSlotf}. + * + * @param effectSlot the effect slot to modify + * @param param the parameter to modify + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alAuxiliaryEffectSlotfv(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param, @NativeType("ALfloat const *") FloatBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalAuxiliaryEffectSlotfv(effectSlot, param, memAddress(values)); + } + + // --- [ alGetAuxiliaryEffectSloti ] --- + + /** Unsafe version of: {@link #alGetAuxiliaryEffectSloti GetAuxiliaryEffectSloti} */ + public static void nalGetAuxiliaryEffectSloti(int effectSlot, int param, long value) { + long __functionAddress = AL.getICD().alGetAuxiliaryEffectSloti; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effectSlot, param, value, __functionAddress); + } + + /** + * Returns the integer value of the specified effect slot parameter. + * + * @param effectSlot the effect slot to query + * @param param the parameter to query + * @param value the parameter value + */ + @NativeType("ALvoid") + public static void alGetAuxiliaryEffectSloti(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param, @NativeType("ALint *") IntBuffer value) { + if (CHECKS) { + check(value, 1); + } + nalGetAuxiliaryEffectSloti(effectSlot, param, memAddress(value)); + } + + /** + * Returns the integer value of the specified effect slot parameter. + * + * @param effectSlot the effect slot to query + * @param param the parameter to query + */ + @NativeType("ALvoid") + public static int alGetAuxiliaryEffectSloti(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer value = stack.callocInt(1); + nalGetAuxiliaryEffectSloti(effectSlot, param, memAddress(value)); + return value.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alGetAuxiliaryEffectSlotiv ] --- + + /** Unsafe version of: {@link #alGetAuxiliaryEffectSlotiv GetAuxiliaryEffectSlotiv} */ + public static void nalGetAuxiliaryEffectSlotiv(int effectSlot, int param, long values) { + long __functionAddress = AL.getICD().alGetAuxiliaryEffectSlotiv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effectSlot, param, values, __functionAddress); + } + + /** + * Returns the integer values of the specified effect slot parameter. + * + * @param effectSlot the effect slot to query + * @param param the parameter to query + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alGetAuxiliaryEffectSlotiv(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param, @NativeType("ALint *") IntBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalGetAuxiliaryEffectSlotiv(effectSlot, param, memAddress(values)); + } + + // --- [ alGetAuxiliaryEffectSlotf ] --- + + /** Unsafe version of: {@link #alGetAuxiliaryEffectSlotf GetAuxiliaryEffectSlotf} */ + public static void nalGetAuxiliaryEffectSlotf(int effectSlot, int param, long value) { + long __functionAddress = AL.getICD().alGetAuxiliaryEffectSlotf; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effectSlot, param, value, __functionAddress); + } + + /** + * Returns the float value of the specified filter parameter. + * + * @param effectSlot the effect slot to query + * @param param the parameter to query + * @param value the parameter value + */ + @NativeType("ALvoid") + public static void alGetAuxiliaryEffectSlotf(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param, @NativeType("ALfloat *") FloatBuffer value) { + if (CHECKS) { + check(value, 1); + } + nalGetAuxiliaryEffectSlotf(effectSlot, param, memAddress(value)); + } + + /** + * Returns the float value of the specified filter parameter. + * + * @param effectSlot the effect slot to query + * @param param the parameter to query + */ + @NativeType("ALvoid") + public static float alGetAuxiliaryEffectSlotf(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + FloatBuffer value = stack.callocFloat(1); + nalGetAuxiliaryEffectSlotf(effectSlot, param, memAddress(value)); + return value.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alGetAuxiliaryEffectSlotfv ] --- + + /** Unsafe version of: {@link #alGetAuxiliaryEffectSlotfv GetAuxiliaryEffectSlotfv} */ + public static void nalGetAuxiliaryEffectSlotfv(int effectSlot, int param, long values) { + long __functionAddress = AL.getICD().alGetAuxiliaryEffectSlotfv; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effectSlot, param, values, __functionAddress); + } + + /** + * Returns the float values of the specified effect slot parameter. + * + * @param effectSlot the effect to query + * @param param the parameter to query + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alGetAuxiliaryEffectSlotfv(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param, @NativeType("ALfloat *") FloatBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalGetAuxiliaryEffectSlotfv(effectSlot, param, memAddress(values)); + } + + /** Array version of: {@link #alGenEffects GenEffects} */ + @NativeType("ALvoid") + public static void alGenEffects(@NativeType("ALuint *") int[] effects) { + long __functionAddress = AL.getICD().alGenEffects; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effects.length, effects, __functionAddress); + } + + /** Array version of: {@link #alDeleteEffects DeleteEffects} */ + @NativeType("ALvoid") + public static void alDeleteEffects(@NativeType("ALuint *") int[] effects) { + long __functionAddress = AL.getICD().alDeleteEffects; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effects.length, effects, __functionAddress); + } + + /** Array version of: {@link #alEffectiv Effectiv} */ + @NativeType("ALvoid") + public static void alEffectiv(@NativeType("ALuint") int effect, @NativeType("ALenum") int param, @NativeType("ALint const *") int[] values) { + long __functionAddress = AL.getICD().alEffectiv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(effect, param, values, __functionAddress); + } + + /** Array version of: {@link #alEffectfv Effectfv} */ + @NativeType("ALvoid") + public static void alEffectfv(@NativeType("ALuint") int effect, @NativeType("ALenum") int param, @NativeType("ALfloat const *") float[] values) { + long __functionAddress = AL.getICD().alEffectfv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(effect, param, values, __functionAddress); + } + + /** Array version of: {@link #alGetEffecti GetEffecti} */ + @NativeType("ALvoid") + public static void alGetEffecti(@NativeType("ALuint") int effect, @NativeType("ALenum") int param, @NativeType("ALint *") int[] value) { + long __functionAddress = AL.getICD().alGetEffecti; + if (CHECKS) { + check(__functionAddress); + check(value, 1); + } + invokePV(effect, param, value, __functionAddress); + } + + /** Array version of: {@link #alGetEffectiv GetEffectiv} */ + @NativeType("ALvoid") + public static void alGetEffectiv(@NativeType("ALuint") int effect, @NativeType("ALenum") int param, @NativeType("ALint *") int[] values) { + long __functionAddress = AL.getICD().alGetEffectiv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(effect, param, values, __functionAddress); + } + + /** Array version of: {@link #alGetEffectf GetEffectf} */ + @NativeType("ALvoid") + public static void alGetEffectf(@NativeType("ALuint") int effect, @NativeType("ALenum") int param, @NativeType("ALfloat *") float[] value) { + long __functionAddress = AL.getICD().alGetEffectf; + if (CHECKS) { + check(__functionAddress); + check(value, 1); + } + invokePV(effect, param, value, __functionAddress); + } + + /** Array version of: {@link #alGetEffectfv GetEffectfv} */ + @NativeType("ALvoid") + public static void alGetEffectfv(@NativeType("ALuint") int effect, @NativeType("ALenum") int param, @NativeType("ALfloat *") float[] values) { + long __functionAddress = AL.getICD().alGetEffectfv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(effect, param, values, __functionAddress); + } + + /** Array version of: {@link #alGenFilters GenFilters} */ + @NativeType("ALvoid") + public static void alGenFilters(@NativeType("ALuint *") int[] filters) { + long __functionAddress = AL.getICD().alGenFilters; + if (CHECKS) { + check(__functionAddress); + } + invokePV(filters.length, filters, __functionAddress); + } + + /** Array version of: {@link #alDeleteFilters DeleteFilters} */ + @NativeType("ALvoid") + public static void alDeleteFilters(@NativeType("ALuint *") int[] filters) { + long __functionAddress = AL.getICD().alDeleteFilters; + if (CHECKS) { + check(__functionAddress); + } + invokePV(filters.length, filters, __functionAddress); + } + + /** Array version of: {@link #alFilteriv Filteriv} */ + @NativeType("ALvoid") + public static void alFilteriv(@NativeType("ALuint") int filter, @NativeType("ALenum") int param, @NativeType("ALint const *") int[] values) { + long __functionAddress = AL.getICD().alFilteriv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(filter, param, values, __functionAddress); + } + + /** Array version of: {@link #alFilterfv Filterfv} */ + @NativeType("ALvoid") + public static void alFilterfv(@NativeType("ALuint") int filter, @NativeType("ALenum") int param, @NativeType("ALfloat const *") float[] values) { + long __functionAddress = AL.getICD().alFilterfv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(filter, param, values, __functionAddress); + } + + /** Array version of: {@link #alGetFilteri GetFilteri} */ + @NativeType("ALvoid") + public static void alGetFilteri(@NativeType("ALuint") int filter, @NativeType("ALenum") int param, @NativeType("ALint *") int[] value) { + long __functionAddress = AL.getICD().alGetFilteri; + if (CHECKS) { + check(__functionAddress); + check(value, 1); + } + invokePV(filter, param, value, __functionAddress); + } + + /** Array version of: {@link #alGetFilteriv GetFilteriv} */ + @NativeType("ALvoid") + public static void alGetFilteriv(@NativeType("ALuint") int filter, @NativeType("ALenum") int param, @NativeType("ALint *") int[] values) { + long __functionAddress = AL.getICD().alGetFilteriv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(filter, param, values, __functionAddress); + } + + /** Array version of: {@link #alGetFilterf GetFilterf} */ + @NativeType("ALvoid") + public static void alGetFilterf(@NativeType("ALuint") int filter, @NativeType("ALenum") int param, @NativeType("ALfloat *") float[] value) { + long __functionAddress = AL.getICD().alGetFilterf; + if (CHECKS) { + check(__functionAddress); + check(value, 1); + } + invokePV(filter, param, value, __functionAddress); + } + + /** Array version of: {@link #alGetFilterfv GetFilterfv} */ + @NativeType("ALvoid") + public static void alGetFilterfv(@NativeType("ALuint") int filter, @NativeType("ALenum") int param, @NativeType("ALfloat *") float[] values) { + long __functionAddress = AL.getICD().alGetFilterfv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(filter, param, values, __functionAddress); + } + + /** Array version of: {@link #alGenAuxiliaryEffectSlots GenAuxiliaryEffectSlots} */ + @NativeType("ALvoid") + public static void alGenAuxiliaryEffectSlots(@NativeType("ALuint *") int[] effectSlots) { + long __functionAddress = AL.getICD().alGenAuxiliaryEffectSlots; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effectSlots.length, effectSlots, __functionAddress); + } + + /** Array version of: {@link #alDeleteAuxiliaryEffectSlots DeleteAuxiliaryEffectSlots} */ + @NativeType("ALvoid") + public static void alDeleteAuxiliaryEffectSlots(@NativeType("ALuint *") int[] effectSlots) { + long __functionAddress = AL.getICD().alDeleteAuxiliaryEffectSlots; + if (CHECKS) { + check(__functionAddress); + } + invokePV(effectSlots.length, effectSlots, __functionAddress); + } + + /** Array version of: {@link #alAuxiliaryEffectSlotiv AuxiliaryEffectSlotiv} */ + @NativeType("ALvoid") + public static void alAuxiliaryEffectSlotiv(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param, @NativeType("ALint const *") int[] values) { + long __functionAddress = AL.getICD().alAuxiliaryEffectSlotiv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(effectSlot, param, values, __functionAddress); + } + + /** Array version of: {@link #alAuxiliaryEffectSlotfv AuxiliaryEffectSlotfv} */ + @NativeType("ALvoid") + public static void alAuxiliaryEffectSlotfv(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param, @NativeType("ALfloat const *") float[] values) { + long __functionAddress = AL.getICD().alAuxiliaryEffectSlotfv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(effectSlot, param, values, __functionAddress); + } + + /** Array version of: {@link #alGetAuxiliaryEffectSloti GetAuxiliaryEffectSloti} */ + @NativeType("ALvoid") + public static void alGetAuxiliaryEffectSloti(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param, @NativeType("ALint *") int[] value) { + long __functionAddress = AL.getICD().alGetAuxiliaryEffectSloti; + if (CHECKS) { + check(__functionAddress); + check(value, 1); + } + invokePV(effectSlot, param, value, __functionAddress); + } + + /** Array version of: {@link #alGetAuxiliaryEffectSlotiv GetAuxiliaryEffectSlotiv} */ + @NativeType("ALvoid") + public static void alGetAuxiliaryEffectSlotiv(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param, @NativeType("ALint *") int[] values) { + long __functionAddress = AL.getICD().alGetAuxiliaryEffectSlotiv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(effectSlot, param, values, __functionAddress); + } + + /** Array version of: {@link #alGetAuxiliaryEffectSlotf GetAuxiliaryEffectSlotf} */ + @NativeType("ALvoid") + public static void alGetAuxiliaryEffectSlotf(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param, @NativeType("ALfloat *") float[] value) { + long __functionAddress = AL.getICD().alGetAuxiliaryEffectSlotf; + if (CHECKS) { + check(__functionAddress); + check(value, 1); + } + invokePV(effectSlot, param, value, __functionAddress); + } + + /** Array version of: {@link #alGetAuxiliaryEffectSlotfv GetAuxiliaryEffectSlotfv} */ + @NativeType("ALvoid") + public static void alGetAuxiliaryEffectSlotfv(@NativeType("ALuint") int effectSlot, @NativeType("ALenum") int param, @NativeType("ALfloat *") float[] values) { + long __functionAddress = AL.getICD().alGetAuxiliaryEffectSlotfv; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(effectSlot, param, values, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTExponentDistance.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTExponentDistance.java new file mode 100644 index 00000000..d7a09e1f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTExponentDistance.java @@ -0,0 +1,23 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the {@code AL_EXT_EXPONENT_DISTANCE} extension. + * + *An OpenAL 1.1 implementation will always support the {@code AL_EXT_EXPONENT_DISTANCE} extension. This allows an application written to the OpenAL 1.0 specification to + * access the exponent distance abilities.
+ */ +public final class EXTExponentDistance { + + /** {@code AL_EXT_EXPONENT_DISTANCE} tokens. */ + public static final int + AL_EXPONENT_DISTANCE = 0xD005, + AL_EXPONENT_DISTANCE_CLAMPED = 0xD006; + + private EXTExponentDistance() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTFloat32.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTFloat32.java new file mode 100644 index 00000000..655388e3 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTFloat32.java @@ -0,0 +1,18 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** Native bindings to the {@code AL_EXT_FLOAT32} extension. */ +public final class EXTFloat32 { + + /** Buffer formats. */ + public static final int + AL_FORMAT_MONO_FLOAT32 = 0x10010, + AL_FORMAT_STEREO_FLOAT32 = 0x10011; + + private EXTFloat32() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTIma4.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTIma4.java new file mode 100644 index 00000000..291ae714 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTIma4.java @@ -0,0 +1,18 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** Native bindings to the {@code AL_EXT_IMA4} extension. */ +public final class EXTIma4 { + + /** Buffer formats. */ + public static final int + AL_FORMAT_MONO_IMA4 = 0x1300, + AL_FORMAT_STEREO_IMA4 = 0x1301; + + private EXTIma4() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTLinearDistance.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTLinearDistance.java new file mode 100644 index 00000000..84ee13aa --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTLinearDistance.java @@ -0,0 +1,23 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the {@code AL_EXT_LINEAR_DISTANCE} extension. + * + *An OpenAL 1.1 implementation will always support the {@code AL_EXT_LINEAR_DISTANCE} extension. This allows an application written to the OpenAL 1.0 specification to + * access the offset abilities.
+ */ +public final class EXTLinearDistance { + + /** {@code AL_EXT_LINEAR_DISTANCE} tokens. */ + public static final int + AL_LINEAR_DISTANCE = 0xD003, + AL_LINEAR_DISTANCE_CLAMPED = 0xD004; + + private EXTLinearDistance() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTMCFormats.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTMCFormats.java new file mode 100644 index 00000000..13fd2475 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTMCFormats.java @@ -0,0 +1,31 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** Native bindings to the {@code AL_EXT_MCFORMATS} extension. */ +public final class EXTMCFormats { + + /** Buffer formats. */ + public static final int + AL_FORMAT_QUAD8 = 0x1204, + AL_FORMAT_QUAD16 = 0x1205, + AL_FORMAT_QUAD32 = 0x1206, + AL_FORMAT_REAR8 = 0x1207, + AL_FORMAT_REAR16 = 0x1208, + AL_FORMAT_REAR32 = 0x1209, + AL_FORMAT_51CHN8 = 0x120A, + AL_FORMAT_51CHN16 = 0x120B, + AL_FORMAT_51CHN32 = 0x120C, + AL_FORMAT_61CHN8 = 0x120D, + AL_FORMAT_61CHN16 = 0x120E, + AL_FORMAT_61CHN32 = 0x120F, + AL_FORMAT_71CHN8 = 0x1210, + AL_FORMAT_71CHN16 = 0x1211, + AL_FORMAT_71CHN32 = 0x1212; + + private EXTMCFormats() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTMulaw.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTMulaw.java new file mode 100644 index 00000000..711272e7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTMulaw.java @@ -0,0 +1,18 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** Native bindings to the {@code AL_EXT_MULAW} extension. */ +public final class EXTMulaw { + + /** Buffer formats. */ + public static final int + AL_FORMAT_MONO_MULAW_EXT = 0x10014, + AL_FORMAT_STEREO_MULAW_EXT = 0x10015; + + private EXTMulaw() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTMulawBFormat.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTMulawBFormat.java new file mode 100644 index 00000000..9600ba63 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTMulawBFormat.java @@ -0,0 +1,24 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the {@code AL_EXT_MULAW_BFORMAT} extension. + * + *This extension implies two MULAW formats are available, based on 2D and 3D Ambisonic B-Format.
+ * + *See {@link EXTBFormat EXT_BFORMAT} for a discussion of the channel numberings and meanings.
+ */ +public final class EXTMulawBFormat { + + /** Buffer formats. */ + public static final int + AL_FORMAT_BFORMAT2D_MULAW = 0x10031, + AL_FORMAT_BFORMAT3D_MULAW = 0x10032; + + private EXTMulawBFormat() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTMulawMCFormats.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTMulawMCFormats.java new file mode 100644 index 00000000..d336a35b --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTMulawMCFormats.java @@ -0,0 +1,23 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** Native bindings to the {@code AL_EXT_MULAW_MCFORMATS} extension. */ +public final class EXTMulawMCFormats { + + /** Buffer formats. */ + public static final int + AL_FORMAT_MONO_MULAW = 0x10014, + AL_FORMAT_STEREO_MULAW = 0x10015, + AL_FORMAT_QUAD_MULAW = 0x10021, + AL_FORMAT_REAR_MULAW = 0x10022, + AL_FORMAT_51CHN_MULAW = 0x10023, + AL_FORMAT_61CHN_MULAW = 0x10024, + AL_FORMAT_71CHN_MULAW = 0x10025; + + private EXTMulawMCFormats() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTOffset.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTOffset.java new file mode 100644 index 00000000..43a3a73d --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTOffset.java @@ -0,0 +1,24 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the {@code AL_EXT_OFFSET} extension. + * + *An OpenAL 1.1 implementation will always support the {@code AL_EXT_OFFSET} extension. This allows an application written to the OpenAL 1.0 specification to + * access the offset abilities.
+ */ +public final class EXTOffset { + + /** {@code AL_EXT_OFFSET} tokens. */ + public static final int + AL_SEC_OFFSET = 0x1024, + AL_SAMPLE_OFFSET = 0x1025, + AL_BYTE_OFFSET = 0x1026; + + private EXTOffset() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTSourceDistanceModel.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTSourceDistanceModel.java new file mode 100644 index 00000000..2e6db2ba --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTSourceDistanceModel.java @@ -0,0 +1,22 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the EXT_source_distance_model extension. + * + *This extension allows each source to specify a distance model, instead of being restricted to one distance model for every source in the context. It + * provides a mechanism for applications to apply different models to each source, without the burden of manually applying the attenuation through the + * source gain.
+ */ +public final class EXTSourceDistanceModel { + + /** Accepted by the {@code target} parameter of {@link AL10#alEnable Enable}, {@link AL10#alDisable Disable}, and {@link AL10#alIsEnabled IsEnabled}. */ + public static final int AL_SOURCE_DISTANCE_MODEL = 0x200; + + private EXTSourceDistanceModel() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTSourceRadius.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTSourceRadius.java new file mode 100644 index 00000000..66dd2879 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTSourceRadius.java @@ -0,0 +1,23 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the {@code AL_EXT_SOURCE_RADIUS} extension. + * + *This extension allows any mono source to be changed to be a "large" source with a radius. The source has a raised cosine shape.
+ */ +public final class EXTSourceRadius { + + /** + * Can be used with {@link AL10#alSourcef Sourcef} to set the source radius. Units are consistent with the coordinate system in use. The value must be at least zero. Use + * a value of zero to reset to a point source. + */ + public static final int AL_SOURCE_RADIUS = 0x1031; + + private EXTSourceRadius() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTStaticBuffer.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTStaticBuffer.java new file mode 100644 index 00000000..fe904dfc --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTStaticBuffer.java @@ -0,0 +1,132 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the {@code AL_EXT_static_buffer} extension. + * + *This extension provides a means for the caller to avoid the overhead associated with the {@link AL10#alBufferData BufferData} call which performs a physical copy of the + * data provided by the caller to internal buffers. When using the {@code AL_EXT_static_buffer} extension, OpenAL's internal buffers use the data pointer provided by + * the caller for all data access.
+ */ +public class EXTStaticBuffer { + + protected EXTStaticBuffer() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(ALCapabilities caps) { + return checkFunctions( + caps.alBufferDataStatic + ); + } + + // --- [ alBufferDataStatic ] --- + + /** + * Unsafe version of: {@link #alBufferDataStatic BufferDataStatic} + * + * @param len the data buffer size, in bytes + */ + public static void nalBufferDataStatic(int buffer, int format, long data, int len, int freq) { + long __functionAddress = AL.getICD().alBufferDataStatic; + if (CHECKS) { + check(__functionAddress); + } + invokePV(buffer, format, data, len, freq, __functionAddress); + } + + /** + * Sets the sample data of the specified buffer. + * + * @param buffer the buffer handle + * @param format the data format + * @param data the sample data + * @param freq the data frequency + */ + @NativeType("ALvoid") + public static void alBufferDataStatic(@NativeType("ALint") int buffer, @NativeType("ALenum") int format, @NativeType("ALvoid *") ByteBuffer data, @NativeType("ALsizei") int freq) { + nalBufferDataStatic(buffer, format, memAddress(data), data.remaining(), freq); + } + + /** + * Sets the sample data of the specified buffer. + * + * @param buffer the buffer handle + * @param format the data format + * @param data the sample data + * @param freq the data frequency + */ + @NativeType("ALvoid") + public static void alBufferDataStatic(@NativeType("ALint") int buffer, @NativeType("ALenum") int format, @NativeType("ALvoid *") ShortBuffer data, @NativeType("ALsizei") int freq) { + nalBufferDataStatic(buffer, format, memAddress(data), data.remaining() << 1, freq); + } + + /** + * Sets the sample data of the specified buffer. + * + * @param buffer the buffer handle + * @param format the data format + * @param data the sample data + * @param freq the data frequency + */ + @NativeType("ALvoid") + public static void alBufferDataStatic(@NativeType("ALint") int buffer, @NativeType("ALenum") int format, @NativeType("ALvoid *") IntBuffer data, @NativeType("ALsizei") int freq) { + nalBufferDataStatic(buffer, format, memAddress(data), data.remaining() << 2, freq); + } + + /** + * Sets the sample data of the specified buffer. + * + * @param buffer the buffer handle + * @param format the data format + * @param data the sample data + * @param freq the data frequency + */ + @NativeType("ALvoid") + public static void alBufferDataStatic(@NativeType("ALint") int buffer, @NativeType("ALenum") int format, @NativeType("ALvoid *") FloatBuffer data, @NativeType("ALsizei") int freq) { + nalBufferDataStatic(buffer, format, memAddress(data), data.remaining() << 2, freq); + } + + /** Array version of: {@link #alBufferDataStatic BufferDataStatic} */ + @NativeType("ALvoid") + public static void alBufferDataStatic(@NativeType("ALint") int buffer, @NativeType("ALenum") int format, @NativeType("ALvoid *") short[] data, @NativeType("ALsizei") int freq) { + long __functionAddress = AL.getICD().alBufferDataStatic; + if (CHECKS) { + check(__functionAddress); + } + invokePV(buffer, format, data, data.length << 1, freq, __functionAddress); + } + + /** Array version of: {@link #alBufferDataStatic BufferDataStatic} */ + @NativeType("ALvoid") + public static void alBufferDataStatic(@NativeType("ALint") int buffer, @NativeType("ALenum") int format, @NativeType("ALvoid *") int[] data, @NativeType("ALsizei") int freq) { + long __functionAddress = AL.getICD().alBufferDataStatic; + if (CHECKS) { + check(__functionAddress); + } + invokePV(buffer, format, data, data.length << 2, freq, __functionAddress); + } + + /** Array version of: {@link #alBufferDataStatic BufferDataStatic} */ + @NativeType("ALvoid") + public static void alBufferDataStatic(@NativeType("ALint") int buffer, @NativeType("ALenum") int format, @NativeType("ALvoid *") float[] data, @NativeType("ALsizei") int freq) { + long __functionAddress = AL.getICD().alBufferDataStatic; + if (CHECKS) { + check(__functionAddress); + } + invokePV(buffer, format, data, data.length << 2, freq, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTStereoAngles.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTStereoAngles.java new file mode 100644 index 00000000..e32bb93f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTStereoAngles.java @@ -0,0 +1,25 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the {@code AL_EXT_STEREO_ANGLES} extension. + * + *This extension allows any stereo source to be "steered" by setting the angles at which the left and right channels should play.
+ */ +public final class EXTStereoAngles { + + /** + * Can be used with {@link AL10#alSourcefv Sourcefv} and two angles. The angles are specified anticlockwise relative to the real front, so a normal 60degree front stage is + * specified with {@code alSourcefv(sid,AL_STEREO_ANGLES,+M_PI/6,-M_PI/6)}. + * + *Angles are always specified in radians, anticlockwise relative to the real front ({@link AL10#AL_SOURCE_RELATIVE SOURCE_RELATIVE} is not supported).
+ */ + public static final int AL_STEREO_ANGLES = 0x1030; + + private EXTStereoAngles() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTThreadLocalContext.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTThreadLocalContext.java new file mode 100644 index 00000000..df103e7a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTThreadLocalContext.java @@ -0,0 +1,60 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** + * Native bindings to the EXT_thread_local_context extension. + * + *This extension introduces the concept of a current thread-local context, with each thread able to have its own current context. The current context is + * what the al- functions work on, effectively allowing multiple threads to independently drive separate OpenAL playback contexts.
+ */ +public class EXTThreadLocalContext { + + protected EXTThreadLocalContext() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(ALCCapabilities caps) { + return checkFunctions( + caps.alcSetThreadContext, caps.alcGetThreadContext + ); + } + + // --- [ alcSetThreadContext ] --- + + /** + * Makes a context current with respect to OpenAL operation on the current thread. The context parameter can be {@code NULL} or a valid context pointer. Using + * {@code NULL} results in no thread-specific context being current in the calling thread, which is useful when shutting OpenAL down. + * + * @param context the context to make current + */ + @NativeType("ALCboolean") + public static boolean alcSetThreadContext(@NativeType("ALCcontext *") long context) { + long __functionAddress = ALC.getICD().alcSetThreadContext; + if (CHECKS) { + check(__functionAddress); + } + return invokePZ(context, __functionAddress); + } + + // --- [ alcGetThreadContext ] --- + + /** Retrieves a handle to the thread-specific context of the calling thread. This function will return {@code NULL} if no thread-specific context is set. */ + @NativeType("ALCcontext *") + public static long alcGetThreadContext() { + long __functionAddress = ALC.getICD().alcGetThreadContext; + if (CHECKS) { + check(__functionAddress); + } + return invokeP(__functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTVorbis.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTVorbis.java new file mode 100644 index 00000000..9bbe98a4 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EXTVorbis.java @@ -0,0 +1,16 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** Native bindings to the {@code AL_EXT_vorbis} extension. */ +public final class EXTVorbis { + + /** {@code AL_EXT_vorbis} tokens. */ + public static final int AL_FORMAT_VORBIS_EXT = 0x10003; + + private EXTVorbis() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EnumerateAllExt.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EnumerateAllExt.java new file mode 100644 index 00000000..94adfe0e --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/EnumerateAllExt.java @@ -0,0 +1,26 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the {@code ALC_ENUMERATE_ALL_EXT} extension. + * + *The Enumerate All Extension enables the application developer to retrieve a complete list of device strings identifying all the available OpenAL + * rendering devices and paths present on the user's PC. It works in exactly the same manner as the Enumeration Extension, but it detects additional audio + * paths that the standard extension will ignore. For instance, it will return all the possible outputs in situations where the user has more than one + * audio device installed, or under Windows Vista where the audio system specifies different “endpoints” for sound such as Speakers, S/PDIF, etc... If you + * don’t require such complete control over the choice of output path, then use the standard Enumeration Extension.
+ */ +public final class EnumerateAllExt { + + /** {@code ALC_ENUMERATE_ALL_EXT} tokens. */ + public static final int + ALC_DEFAULT_ALL_DEVICES_SPECIFIER = 0x1012, + ALC_ALL_DEVICES_SPECIFIER = 0x1013; + + private EnumerateAllExt() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/LOKIAudioChannel.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/LOKIAudioChannel.java new file mode 100644 index 00000000..f21ab013 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/LOKIAudioChannel.java @@ -0,0 +1,19 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** Native bindings to the {@code ALC_LOKI_audio_channel} extension. */ +public final class LOKIAudioChannel { + + /** {@code ALC_LOKI_audio_channel} tokens. */ + public static final int + ALC_CHAN_MAIN_LOKI = 0x500001, + ALC_CHAN_PCM_LOKI = 0x500002, + ALC_CHAN_CD_LOKI = 0x500003; + + private LOKIAudioChannel() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/LOKIIMAADPCM.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/LOKIIMAADPCM.java new file mode 100644 index 00000000..bc0b5d4f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/LOKIIMAADPCM.java @@ -0,0 +1,18 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** Native bindings to the {@code AL_LOKI_IMA_ADPCM} extension. */ +public final class LOKIIMAADPCM { + + /** Buffer formats. */ + public static final int + AL_FORMAT_IMA_ADPCM_MONO16_EXT = 0x10000, + AL_FORMAT_IMA_ADPCM_STEREO16_EXT = 0x10001; + + private LOKIIMAADPCM() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/LOKIQuadriphonic.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/LOKIQuadriphonic.java new file mode 100644 index 00000000..39c3b7d1 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/LOKIQuadriphonic.java @@ -0,0 +1,18 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** Native bindings to the {@code AL_LOKI_quadriphonic} extension. */ +public final class LOKIQuadriphonic { + + /** Buffer formats. */ + public static final int + AL_FORMAT_QUAD8_LOKI = 0x10004, + AL_FORMAT_QUAD16_LOKI = 0x10005; + + private LOKIQuadriphonic() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/LOKIWAVEFormat.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/LOKIWAVEFormat.java new file mode 100644 index 00000000..5f5728af --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/LOKIWAVEFormat.java @@ -0,0 +1,16 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** Native bindings to the {@code AL_LOKI_WAVE_format} extension. */ +public final class LOKIWAVEFormat { + + /** Buffer formats. */ + public static final int AL_FORMAT_WAVE_EXT = 0x10002; + + private LOKIWAVEFormat() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTBlockAlignment.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTBlockAlignment.java new file mode 100644 index 00000000..ebe29a9f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTBlockAlignment.java @@ -0,0 +1,23 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the SOFT_block_alignment extension. + * + *This extension provides a mechanism for specifying block alignment properties for sample data. This is useful for, though not strictly limited to, + * ADPCM compression where the block alignment is specified in the media file header instead of the data stream, and controls the decoding process.
+ */ +public final class SOFTBlockAlignment { + + /** Accepted by the {@code paramName} parameter of {@link AL11#alBufferi Bufferi}, {@link AL11#alBufferiv Bufferiv}, {@link AL10#alGetBufferi GetBufferi}, and {@link AL11#alGetBufferiv GetBufferiv}. */ + public static final int + AL_UNPACK_BLOCK_ALIGNMENT_SOFT = 0x200C, + AL_PACK_BLOCK_ALIGNMENT_SOFT = 0x200D; + + private SOFTBlockAlignment() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTDeferredUpdates.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTDeferredUpdates.java new file mode 100644 index 00000000..e1f67852 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTDeferredUpdates.java @@ -0,0 +1,72 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** + * Native bindings to the SOFT_deferred_updates extension. + * + *This extension allows applications to defer playback state updates. With unextended OpenAL, the playback state would respond to changes as soon as it + * could handle them, which makes it effectively impossible to ensure multiple changes occur at the same time without the potential of a "partial" update + * (where one change is heard without the other). This extension provides a way to prevent state updates from occuring until they've all been done, where + * they will all apply at once.
+ */ +public class SOFTDeferredUpdates { + + /** Accepted by the {@code paramName} parameter of {@link AL10#alGetBoolean GetBoolean}, {@link AL10#alGetBooleanv GetBooleanv} (as well as the Integer, Float, and Double variants). */ + public static final int AL_DEFERRED_UPDATES_SOFT = 0xC002; + + protected SOFTDeferredUpdates() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(ALCapabilities caps) { + return checkFunctions( + caps.alDeferUpdatesSOFT, caps.alProcessUpdatesSOFT + ); + } + + // --- [ alDeferUpdatesSOFT ] --- + + /** + * Sometimes it is desirable to ensure multiple state changes take effect at the same time. Normally this isn't possible due to the AL processing updates + * asychronously, so the playback state can be updated with only part of the changes having been specified. An application can prevent these updates by + * calling this function. + * + *When called, samples will continue to render and be sent to the output device, but the effects of changing playback properties, such as the source or + * listener gain, or auxiliary slot gain or effect if EFX is supported, among others, will be deferred. Multiple changes can be batched so that they all + * apply at once at a later time.
+ */ + @NativeType("ALvoid") + public static void alDeferUpdatesSOFT() { + long __functionAddress = AL.getICD().alDeferUpdatesSOFT; + if (CHECKS) { + check(__functionAddress); + } + invokeV(__functionAddress); + } + + // --- [ alProcessUpdatesSOFT ] --- + + /** + * Resumes updates. + * + *Once called, all pending deferred updates will be processed. Any following state changes will also apply as normal.
+ */ + @NativeType("ALvoid") + public static void alProcessUpdatesSOFT() { + long __functionAddress = AL.getICD().alProcessUpdatesSOFT; + if (CHECKS) { + check(__functionAddress); + } + invokeV(__functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTDeviceClock.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTDeviceClock.java new file mode 100644 index 00000000..09b89271 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTDeviceClock.java @@ -0,0 +1,138 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the SOFT_device_clock extension. + * + *This extension allows applications to query the timing clock from the audio device. This clock lets applications measure the passage of time as the + * audio device sees it, which may be slightly different than the system clock's tick rate (the infamous timer drift).
+ * + *If the {@link SOFTPauseDevice SOFT_pause_device} extension is available, the device clock does not increment while the device playback is paused. It is + * implementation-defined whether or not the device clock increments while no contexts are allocated. The initial clock time value of an opened device is + * also implementation-defined, except that it must not be negative and should be low enough to avoid wrapping during program execution.
+ * + *Requires {@link SOFTSourceLatency SOFT_source_latency}
+ */ +public class SOFTDeviceClock { + + /** Accepted as the {@code pname} parameter of {@link #alcGetInteger64vSOFT GetInteger64vSOFT}. */ + public static final int + ALC_DEVICE_CLOCK_SOFT = 0x1600, + ALC_DEVICE_LATENCY_SOFT = 0x1601, + ALC_DEVICE_CLOCK_LATENCY_SOFT = 0x1602; + + /** + * Accepted as the {@code param} parameter of {@link SOFTSourceLatency#alGetSourcei64vSOFT GetSourcei64vSOFT}. + * + *Returns the playback position, expressed in fixed-point samples, along with the device clock, expressed in nanoseconds. This attribute is read-only.
+ * + *The first value in the returned vector is the sample offset, which is a 32.32 fixed-point value. The whole number is stored in the upper 32 bits and + * the fractional component is in the lower 32 bits. The value is similar to that returned by {@link AL11#AL_SAMPLE_OFFSET SAMPLE_OFFSET}, just with more precision.
+ * + *The second value is the device clock, in nanoseconds. This updates at the same rate as the offset, and both are measured atomically with respect to one + * another.
+ */ + public static final int AL_SAMPLE_OFFSET_CLOCK_SOFT = 0x1202; + + /** + * Accepted as the {@code param} parameter of {@link SOFTSourceLatency#alGetSourcedvSOFT GetSourcedvSOFT}. + * + *Returns the playback position, along with the device clock, both expressed in seconds. This attribute is read-only.
+ * + *The first value in the returned vector is the offset in seconds. The value is similar to that returned by {@link AL11#AL_SEC_OFFSET SEC_OFFSET}, just with more precision.
+ * + *The second value is the device clock, in seconds. This updates at the same rate as the offset, and both are measured atomically with respect to one + * another. Be aware that this value may be subtly different from the other device clock queries due to the variable precision of floating-point values.
+ */ + public static final int AL_SEC_OFFSET_CLOCK_SOFT = 0x1203; + + protected SOFTDeviceClock() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(ALCCapabilities caps) { + return checkFunctions( + caps.alcGetInteger64vSOFT + ); + } + + // --- [ alcGetInteger64vSOFT ] --- + + /** Unsafe version of: {@link #alcGetInteger64vSOFT GetInteger64vSOFT} */ + public static void nalcGetInteger64vSOFT(long device, int pname, int size, long values) { + long __functionAddress = ALC.getICD().alcGetInteger64vSOFT; + if (CHECKS) { + check(__functionAddress); + } + invokePPV(device, pname, size, values, __functionAddress); + } + + /** + * Accepts all the same {@link AL10#alGetIntegerv GetIntegerv} queries, in addition to some new ones. + * + *Note that the size parameter is the number of {@code ALCint64SOFT} elements in the buffer provided, not the number of bytes.
+ * + * @param pname| {@link #ALC_DEVICE_CLOCK_SOFT DEVICE_CLOCK_SOFT} | The audio device clock time, expressed in nanoseconds. {@code NULL} is an invalid device. |
| {@link #ALC_DEVICE_LATENCY_SOFT DEVICE_LATENCY_SOFT} | The current audio device latency, in nanoseconds. This is effectively the delay for the samples rendered at the the device's current + * clock time fromreaching the physical output. {@code NULL} is an invalid device. |
| {@link #ALC_DEVICE_CLOCK_LATENCY_SOFT DEVICE_CLOCK_LATENCY_SOFT} | Expects a destination size of 2, and provides both the audio device clock time and latency, both in nanoseconds. The two values are + * measured atomically with respect to one another (i.e. the latency value was measured at the same time the device clock value was + * retrieved). {@code NULL} is an invalid device. |
Note that the size parameter is the number of {@code ALCint64SOFT} elements in the buffer provided, not the number of bytes.
+ * + * @param pname| {@link #ALC_DEVICE_CLOCK_SOFT DEVICE_CLOCK_SOFT} | The audio device clock time, expressed in nanoseconds. {@code NULL} is an invalid device. |
| {@link #ALC_DEVICE_LATENCY_SOFT DEVICE_LATENCY_SOFT} | The current audio device latency, in nanoseconds. This is effectively the delay for the samples rendered at the the device's current + * clock time fromreaching the physical output. {@code NULL} is an invalid device. |
| {@link #ALC_DEVICE_CLOCK_LATENCY_SOFT DEVICE_CLOCK_LATENCY_SOFT} | Expects a destination size of 2, and provides both the audio device clock time and latency, both in nanoseconds. The two values are + * measured atomically with respect to one another (i.e. the latency value was measured at the same time the device clock value was + * retrieved). {@code NULL} is an invalid device. |
This extension allows a multi-channel source to play without virtualized output speakers. By default, OpenAL requires buffer channels to be down-mixed + * to the output channel configuration, possibly using HRTF or other virtualization techniques to give a sense of speakers that may not be physically + * present. Sometimes audio tracks are authored with their own spatialization effects, where the AL's virtualization methods can cause a notable decrease + * in audio quality.
+ * + *This extension provides a mechanism for applications to specify whether audio should be filtered according to the AL's channel virtualization rules for + * multi-channel buffers.
+ */ +public final class SOFTDirectChannels { + + /** Accepted by the {@code paramName} parameter of {@link AL10#alSourcei Sourcei}, {@link AL11#alSourceiv Sourceiv}, {@link AL10#alGetSourcei GetSourcei}, and {@link AL10#alGetSourceiv GetSourceiv}. */ + public static final int AL_DIRECT_CHANNELS_SOFT = 0x1033; + + private SOFTDirectChannels() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTGainClampEx.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTGainClampEx.java new file mode 100644 index 00000000..bd25f794 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTGainClampEx.java @@ -0,0 +1,32 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the SOFT_gain_clamp_ex extension. + * + *This extension extends the gain clamping mechanism in standard AL. By default, OpenAL allows the source's and listener's {@link AL10#AL_GAIN GAIN} property to be set to + * any value that's greater-than or equal-to 0. The calculated source gain is clamped between its {@link AL10#AL_MIN_GAIN MIN_GAIN} and {@link AL10#AL_MAX_GAIN MAX_GAIN} properties after distance + * attenuation and the directional cone is applied, and before the listener gain is applied, however these two clamping properties are themselves + * restricted to being between 0 and 1 (inclusive).
+ * + *That behavior effectively nullifies any purpose of setting a source's gain being above 1, as the source's distance- and cone-related properties can be + * modified for the same effect. Oddly, the listener gain is applied to the source gain *after* the clamping, so it is still possible for the final + * calculated gain to exceed 1. On top of this, the spec allows an implementation the option to implicitly clamp the final calculated gain for the source + * as needed, but provides no means for applications to detect such behavior.
+ * + *This extension aims to fix those problems by removing the maximum limit for {@link AL10#AL_MIN_GAIN MIN_GAIN} and {@link AL10#AL_MAX_GAIN MAX_GAIN}, allowing applications to increase the effective + * source gain above 1. Additionally, it provides a query for the application to retrieve the implicit clamp level an implementation may put on the final + * calculated gain.
+ */ +public final class SOFTGainClampEx { + + /** An implementation-defined maximum per-source gain limit (guaranteed to be at least 1). */ + public static final int AL_GAIN_LIMIT_SOFT = 0x200E; + + private SOFTGainClampEx() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTHRTF.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTHRTF.java new file mode 100644 index 00000000..d7dfb257 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTHRTF.java @@ -0,0 +1,141 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the SOFT_HRTF extension. + * + *This extension allows an application to request and determine the status of HRTF mixing. HRTF, or Head-Related Transfer Function, is a method of mixing + * 3D audio for "true" 3D panning, typically using filters designed to simulate how sound is affected by a listener's head as the sound waves travel + * between the ears.
+ * + *As a 3D sound API, OpenAL's design allows implementations to transparently render audio using HRTF. However, the OpenAL API currently has no concept of + * HRTF so there's no way to query if it's being used, and no way for an application to request it on behalf of the user. This aims to fix that.
+ */ +public class SOFTHRTF { + + /** + * Accepted as part of the {@code attrList} parameter of {@link ALC10#alcCreateContext CreateContext} and {@link #alcResetDeviceSOFT ResetDeviceSOFT}, and as the {@code paramName} parameter of + * {@link ALC10#alcGetIntegerv GetIntegerv}. + */ + public static final int ALC_HRTF_SOFT = 0x1992; + + /** Accepted as part of the {@code attrList} parameter of {@link ALC10#alcCreateContext CreateContext} and {@link #alcResetDeviceSOFT ResetDeviceSOFT}. */ + public static final int ALC_HRTF_ID_SOFT = 0x1996; + + /** Accepted as part of the {@code attrList} parameter of {@link ALC10#alcCreateContext CreateContext} and {@link #alcResetDeviceSOFT ResetDeviceSOFT}, for the {@link #ALC_HRTF_SOFT HRTF_SOFT} attribute. */ + public static final int ALC_DONT_CARE_SOFT = 0x2; + + /** Accepted as the {@code paramName} parameter of {@link ALC10#alcGetIntegerv GetIntegerv}. */ + public static final int + ALC_HRTF_STATUS_SOFT = 0x1993, + ALC_NUM_HRTF_SPECIFIERS_SOFT = 0x1994; + + /** Accepted as the {@code paramName} parameter of {@link ALC10#alcGetString GetString} and {@link #alcGetStringiSOFT GetStringiSOFT}. */ + public static final int ALC_HRTF_SPECIFIER_SOFT = 0x1995; + + /** Possible results from a {@link #ALC_HRTF_STATUS_SOFT HRTF_STATUS_SOFT} query. */ + public static final int + ALC_HRTF_DISABLED_SOFT = 0x0, + ALC_HRTF_ENABLED_SOFT = 0x1, + ALC_HRTF_DENIED_SOFT = 0x2, + ALC_HRTF_REQUIRED_SOFT = 0x3, + ALC_HRTF_HEADPHONES_DETECTED_SOFT = 0x4, + ALC_HRTF_UNSUPPORTED_FORMAT_SOFT = 0x5; + + protected SOFTHRTF() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(ALCCapabilities caps) { + return checkFunctions( + caps.alcGetStringiSOFT, caps.alcResetDeviceSOFT + ); + } + + // --- [ alcGetStringiSOFT ] --- + + /** Unsafe version of: {@link #alcGetStringiSOFT GetStringiSOFT} */ + public static long nalcGetStringiSOFT(long device, int paramName, int index) { + long __functionAddress = ALC.getICD().alcGetStringiSOFT; + if (CHECKS) { + check(__functionAddress); + check(device); + } + return invokePP(device, paramName, index, __functionAddress); + } + + /** + * Returns a human-readable string for an HRTF. + * + *The returned string will be an implementation-defined UTF-8 encoded specifier for the given HRTF index, designed for display to the user. The returned + * strings are valid until the next enumeration point or the device is closed.
+ * + * @param device he same one that previously queried the number of HRTF specifiers + * @param paramName the parameter to query. Must be:| {@link #ALC_HRTF_SPECIFIER_SOFT HRTF_SPECIFIER_SOFT} |
This extension allows an application to specify the offsets at which a buffer loops. Unextended OpenAL only allows for a source to loop a whole buffer, + * or all buffers of a queue, which is not desirable for sounds that may want a lead-in or lead-out along with the looping portion.
+ */ +public final class SOFTLoopPoints { + + /** Accepted by the {@code paramName} parameter of {@link AL11#alBufferiv Bufferiv} and {@link AL11#alGetBufferiv GetBufferiv}. */ + public static final int AL_LOOP_POINTS_SOFT = 0x2015; + + private SOFTLoopPoints() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTLoopback.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTLoopback.java new file mode 100644 index 00000000..6e6062f5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTLoopback.java @@ -0,0 +1,244 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the SOFT_loopback extension. + * + *This extension allows an application to read back OpenAL's rendered audio instead of having it output to an audio device on the system. Unextended + * OpenAL will output audio to an audio device, with no mechanism to allow an application to divert the audio somewhere else.
+ */ +public class SOFTLoopback { + + /** Accepted by the {@code type} parameter of {@link #alcIsRenderFormatSupportedSOFT IsRenderFormatSupportedSOFT}. */ + public static final int + ALC_BYTE_SOFT = 0x1400, + ALC_UNSIGNED_BYTE_SOFT = 0x1401, + ALC_SHORT_SOFT = 0x1402, + ALC_UNSIGNED_SHORT_SOFT = 0x1403, + ALC_INT_SOFT = 0x1404, + ALC_UNSIGNED_INT_SOFT = 0x1405, + ALC_FLOAT_SOFT = 0x1406; + + /** Accepted by the {@code channels} parameter of {@link #alcIsRenderFormatSupportedSOFT IsRenderFormatSupportedSOFT}. */ + public static final int + ALC_MONO_SOFT = 0x1500, + ALC_STEREO_SOFT = 0x1501, + ALC_QUAD_SOFT = 0x1503, + ALC_5POINT1_SOFT = 0x1504, + ALC_6POINT1_SOFT = 0x1505, + ALC_7POINT1_SOFT = 0x1506; + + /** Accepted as part of the {@code attrList} parameter of {@link ALC10#alcCreateContext CreateContext}. */ + public static final int + ALC_FORMAT_CHANNELS_SOFT = 0x1990, + ALC_FORMAT_TYPE_SOFT = 0x1991; + + protected SOFTLoopback() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(ALCCapabilities caps) { + return checkFunctions( + caps.alcLoopbackOpenDeviceSOFT, caps.alcIsRenderFormatSupportedSOFT, caps.alcRenderSamplesSOFT + ); + } + + // --- [ alcLoopbackOpenDeviceSOFT ] --- + + /** Unsafe version of: {@link #alcLoopbackOpenDeviceSOFT LoopbackOpenDeviceSOFT} */ + public static long nalcLoopbackOpenDeviceSOFT(long deviceName) { + long __functionAddress = ALC.getICD().alcLoopbackOpenDeviceSOFT; + if (CHECKS) { + check(__functionAddress); + } + return invokePP(deviceName, __functionAddress); + } + + /** + * Loopback devices provide a way for applications to "read back" rendered audio without it being sent to an actual audio device. It allows applications to + * render audio as fast or slow as it needs, making it suitable for non-real-time rendering, and so it can be passed to an audio codec or something for + * further processing. + * + *To open a loopback device, use this function.
+ * + *A loopback device behaves largely the same as a playback device. You may query playback state and error codes, and create contexts, which can then be + * set as current to generate sources and buffers like normal.
+ * + *Note that loopback devices do not have either the {@link ALC10#ALC_SYNC SYNC} or {@link ALC10#ALC_REFRESH REFRESH} attributes. Attempting to query them will result in an {@link ALC10#ALC_INVALID_ENUM INVALID_ENUM} + * error.
+ * + * @param deviceName which device or device driver to use for subsequent rendering. This may be {@code NULL} for an implementation-defined default, otherwise it must be a + * valid name returned by enumeration (and further must be a device capable of loopback rendering). + */ + @NativeType("ALCdevice *") + public static long alcLoopbackOpenDeviceSOFT(@Nullable @NativeType("ALCchar const *") ByteBuffer deviceName) { + if (CHECKS) { + checkNT1Safe(deviceName); + } + return nalcLoopbackOpenDeviceSOFT(memAddressSafe(deviceName)); + } + + /** + * Loopback devices provide a way for applications to "read back" rendered audio without it being sent to an actual audio device. It allows applications to + * render audio as fast or slow as it needs, making it suitable for non-real-time rendering, and so it can be passed to an audio codec or something for + * further processing. + * + *To open a loopback device, use this function.
+ * + *A loopback device behaves largely the same as a playback device. You may query playback state and error codes, and create contexts, which can then be + * set as current to generate sources and buffers like normal.
+ * + *Note that loopback devices do not have either the {@link ALC10#ALC_SYNC SYNC} or {@link ALC10#ALC_REFRESH REFRESH} attributes. Attempting to query them will result in an {@link ALC10#ALC_INVALID_ENUM INVALID_ENUM} + * error.
+ * + * @param deviceName which device or device driver to use for subsequent rendering. This may be {@code NULL} for an implementation-defined default, otherwise it must be a + * valid name returned by enumeration (and further must be a device capable of loopback rendering). + */ + @NativeType("ALCdevice *") + public static long alcLoopbackOpenDeviceSOFT(@Nullable @NativeType("ALCchar const *") CharSequence deviceName) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8Safe(deviceName, true); + long deviceNameEncoded = deviceName == null ? NULL : stack.getPointerAddress(); + return nalcLoopbackOpenDeviceSOFT(deviceNameEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alcIsRenderFormatSupportedSOFT ] --- + + /** + * When creating contexts, the attribute list must specify the format used for rendering. This is done with the {@link #ALC_FORMAT_CHANNELS_SOFT FORMAT_CHANNELS_SOFT}, {@link #ALC_FORMAT_TYPE_SOFT FORMAT_TYPE_SOFT}, + * and {@link ALC10#ALC_FREQUENCY FREQUENCY} attributes. This controls the format of the audio subsequently rendered by the device. + * + *To check if a particular rendering format is available, use this function.
+ * + * @param device the loopback device to query + * @param frequency the sample rate of the rendered audio + * @param channels the channel configuration used for rendering. One of:| {@link #ALC_MONO_SOFT MONO_SOFT} | {@link #ALC_STEREO_SOFT STEREO_SOFT} | {@link #ALC_QUAD_SOFT QUAD_SOFT} | {@link #ALC_5POINT1_SOFT 5POINT1_SOFT} | {@link #ALC_6POINT1_SOFT 6POINT1_SOFT} | {@link #ALC_7POINT1_SOFT 7POINT1_SOFT} |
| {@link #ALC_BYTE_SOFT BYTE_SOFT} | {@link #ALC_UNSIGNED_BYTE_SOFT UNSIGNED_BYTE_SOFT} | {@link #ALC_SHORT_SOFT SHORT_SOFT} | {@link #ALC_UNSIGNED_SHORT_SOFT UNSIGNED_SHORT_SOFT} | {@link #ALC_INT_SOFT INT_SOFT} | {@link #ALC_UNSIGNED_INT_SOFT UNSIGNED_INT_SOFT} |
| {@link #ALC_FLOAT_SOFT FLOAT_SOFT} |
This extension adds support for MSADPCM compressed sample formats.
+ */ +public final class SOFTMSADPCM { + + /** Accepted by the {@code format} parameter of {@link AL10#alBufferData BufferData}. */ + public static final int + AL_FORMAT_MONO_MSADPCM_SOFT = 0x1302, + AL_FORMAT_STEREO_MSADPCM_SOFT = 0x1303; + + private SOFTMSADPCM() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTOutputLimiter.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTOutputLimiter.java new file mode 100644 index 00000000..7bf78b70 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTOutputLimiter.java @@ -0,0 +1,21 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the SOFT_output_limiter extension. + * + *This extension allows an application to control OpenAL Soft's output limiter. OpenAL Soft 1.18 adds an output limiter to prevent excessive clipping on + * the output, and this extension allows applications to turn it off or on.
+ */ +public final class SOFTOutputLimiter { + + /** Accepted as part of the {@code attrList} parameter of {@link ALC10#alcCreateContext CreateContext} and {@link SOFTHRTF#alcResetDeviceSOFT ResetDeviceSOFT}, and as the {@code paramName} parameter of {@link AL10#alGetIntegerv GetIntegerv}. */ + public static final int ALC_OUTPUT_LIMITER_SOFT = 0x199A; + + private SOFTOutputLimiter() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTPauseDevice.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTPauseDevice.java new file mode 100644 index 00000000..1eee97f5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTPauseDevice.java @@ -0,0 +1,75 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** + * Native bindings to the SOFT_pause_device extension. + * + *This extension allows applications to pause a playback device. The main purpose of this is to silence output, stop processing, and allow the audio + * hardware to go into a low-power mode. On a mobile device, for instance, apps may want to silence output and not waste battery life with unneeded + * processing when in the background.
+ */ +public class SOFTPauseDevice { + + protected SOFTPauseDevice() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(ALCCapabilities caps) { + return checkFunctions( + caps.alcDevicePauseSOFT, caps.alcDeviceResumeSOFT + ); + } + + // --- [ alcDevicePauseSOFT ] --- + + /** + * Pauses a playback device. + * + *When paused, no contexts associated with the device will be processed or updated. Playing sources will not produce sound, have their offsets + * incremented, or process any more buffers, until the device is resumed. Pausing a device that is already paused is a legal no-op.
+ * + * @param device the device to pause + */ + @NativeType("ALCvoid") + public static void alcDevicePauseSOFT(@NativeType("ALCdevice *") long device) { + long __functionAddress = ALC.getICD().alcDevicePauseSOFT; + if (CHECKS) { + check(__functionAddress); + check(device); + } + invokePV(device, __functionAddress); + } + + // --- [ alcDeviceResumeSOFT ] --- + + /** + * Resumes playback of a paused device. + * + *This will restart processing on the device -- sources will resume playing sound as normal. Resuming playback on a device that is not paused is a legal + * no-op.
+ * + *These functions are not reference counted. alcDeviceResumeSOFT only needs to be called once to resume playback, regardless of how many times + * {@link #alcDevicePauseSOFT DevicePauseSOFT} was called.
+ * + * @param device the device to resume + */ + @NativeType("ALCvoid") + public static void alcDeviceResumeSOFT(@NativeType("ALCdevice *") long device) { + long __functionAddress = ALC.getICD().alcDeviceResumeSOFT; + if (CHECKS) { + check(__functionAddress); + check(device); + } + invokePV(device, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTSourceLatency.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTSourceLatency.java new file mode 100644 index 00000000..73fbc5e5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTSourceLatency.java @@ -0,0 +1,497 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the SOFT_source_latency extension. + * + *This extension provides a method for applications to more accurately measure the playback latency of sources. Unextended OpenAL allows apps to retrieve + * a source's playback offset in bytes, samples, or seconds, but this is (typically) where the AL is processing the audio data.
+ * + *Often, more processing is done outside of the AL. Audio servers are common and they can introduce a bit of latency, increasing the time between when the + * AL is done with a piece of audio data until it gets heard by the user. If the OpenAL implementation uses its own mixer, that can also add to the + * latency. This can ultimately cause a not-insignificant delay between where the AL is processing and what is actually being heard.
+ * + *Although this delay may not be very noticeable for general gaming, if the app is trying to keep a video or animation syncronized with the playback of an + * OpenAL source this extra delay can cause the audio and video to appear of out sync.
+ * + *Luckily, most audio systems have a way of measuring the latency it takes for sound to actually get to the physical output device (the DAC or speakers). + * By providing this information through the AL, an application can more accurately tell what a user is hearing and thus synchronize better with the audio + * output.
+ */ +public class SOFTSourceLatency { + + /** + * The playback position, expressed in fixed-point samples, along with the playback latency, expressed in nanoseconds (1/1000000000ths of a second). This + * attribute is read-only. + * + *The first value in the returned vector is the sample offset, which is a 32.32 fixed-point value. The whole number is stored in the upper 32 bits and + * the fractional component is in the lower 32 bits. The value is similar to that returned by {@link AL11#AL_SAMPLE_OFFSET SAMPLE_OFFSET}, just with more precision.
+ * + *The second value is the latency, in nanoseconds. It represents the length of time it will take for the audio at the current offset to actually reach + * the speakers or DAC. This value should be considered volatile, as it may change very often during playback (it can depend on a number of factors, + * including how full the mixing buffer OpenAL may be using is timer jitter, or other changes deeper in the audio pipeline).
+ * + *The retrieved offset and latency should be considered atomic, with respect to one another. This means the returned latency was measured exactly when + * the source was at the returned offset.
+ */ + public static final int AL_SAMPLE_OFFSET_LATENCY_SOFT = 0x1200; + + /** + * The playback position, along with the playback latency, both expressed in seconds. This attribute is read-only. + * + *The first value in the returned vector is the offset in seconds. The value is similar to that returned by {@link AL11#AL_SEC_OFFSET SEC_OFFSET}, just with more precision.
+ * + *The second value is the latency, in seconds. It represents the length of time it will take for the audio at the current offset to actually reach the + * speakers or DAC. This value should be considered volatile, as it may change very often during playback (it can depend on a number of factors, including + * how full the mixing buffer OpenAL may be using is, timer jitter, or other changes deeper in the audio pipeline).
+ * + *The retrieved offset and latency should be considered atomic with respect to one another. This means the returned latency was measured exactly when the + * source was at the returned offset.
+ */ + public static final int AL_SEC_OFFSET_LATENCY_SOFT = 0x1201; + + protected SOFTSourceLatency() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(ALCapabilities caps) { + return checkFunctions( + caps.alSourcedSOFT, caps.alSource3dSOFT, caps.alSourcedvSOFT, caps.alGetSourcedSOFT, caps.alGetSource3dSOFT, caps.alGetSourcedvSOFT, + caps.alSourcei64SOFT, caps.alSource3i64SOFT, caps.alSourcei64vSOFT, caps.alGetSourcei64SOFT, caps.alGetSource3i64SOFT, caps.alGetSourcei64vSOFT + ); + } + + // --- [ alSourcedSOFT ] --- + + /** + * Sets the double value of a source parameter. + * + * @param source the source to modify + * @param param the parameter to modify + * @param value the parameter value + */ + @NativeType("ALvoid") + public static void alSourcedSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALdouble") double value) { + long __functionAddress = AL.getICD().alSourcedSOFT; + if (CHECKS) { + check(__functionAddress); + } + invokeV(source, param, value, __functionAddress); + } + + // --- [ alSource3dSOFT ] --- + + /** + * Sets the 3 dimensional double values of a source parameter. + * + * @param source the source to modify + * @param param the parameter to modify + * @param value1 the first value + * @param value2 the second value + * @param value3 the third value + */ + @NativeType("ALvoid") + public static void alSource3dSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALdouble") double value1, @NativeType("ALdouble") double value2, @NativeType("ALdouble") double value3) { + long __functionAddress = AL.getICD().alSource3dSOFT; + if (CHECKS) { + check(__functionAddress); + } + invokeV(source, param, value1, value2, value3, __functionAddress); + } + + // --- [ alSourcedvSOFT ] --- + + /** Unsafe version of: {@link #alSourcedvSOFT SourcedvSOFT} */ + public static void nalSourcedvSOFT(int source, int param, long value) { + long __functionAddress = AL.getICD().alSourcedvSOFT; + if (CHECKS) { + check(__functionAddress); + } + invokePV(source, param, value, __functionAddress); + } + + /** + * pointer version of {@link #alSourcedSOFT SourcedSOFT} + * + * @param source the source to modify + * @param param the parameter to modify + * @param value the parameter values + */ + @NativeType("ALvoid") + public static void alSourcedvSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALdouble const *") DoubleBuffer value) { + if (CHECKS) { + check(value, 1); + } + nalSourcedvSOFT(source, param, memAddress(value)); + } + + // --- [ alGetSourcedSOFT ] --- + + /** Unsafe version of: {@link #alGetSourcedSOFT GetSourcedSOFT} */ + public static void nalGetSourcedSOFT(int source, int param, long value) { + long __functionAddress = AL.getICD().alGetSourcedSOFT; + if (CHECKS) { + check(__functionAddress); + } + invokePV(source, param, value, __functionAddress); + } + + /** + * Gets the double value of a source parameter. + * + * @param source the source to query + * @param param the parameter to query + * @param value the parameter values + */ + @NativeType("ALvoid") + public static void alGetSourcedSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALdouble *") DoubleBuffer value) { + if (CHECKS) { + check(value, 1); + } + nalGetSourcedSOFT(source, param, memAddress(value)); + } + + /** + * Gets the double value of a source parameter. + * + * @param source the source to query + * @param param the parameter to query + */ + @NativeType("ALvoid") + public static double alGetSourcedSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + DoubleBuffer value = stack.callocDouble(1); + nalGetSourcedSOFT(source, param, memAddress(value)); + return value.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alGetSource3dSOFT ] --- + + /** Unsafe version of: {@link #alGetSource3dSOFT GetSource3dSOFT} */ + public static void nalGetSource3dSOFT(int source, int param, long value1, long value2, long value3) { + long __functionAddress = AL.getICD().alGetSource3dSOFT; + if (CHECKS) { + check(__functionAddress); + } + invokePPPV(source, param, value1, value2, value3, __functionAddress); + } + + /** + * Gets the 3 dimensional double values of a source parameter. + * + * @param source the source to query + * @param param the parameter to query + * @param value1 the first value + * @param value2 the second value + * @param value3 the third value + */ + @NativeType("ALvoid") + public static void alGetSource3dSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALdouble *") DoubleBuffer value1, @NativeType("ALdouble *") DoubleBuffer value2, @NativeType("ALdouble *") DoubleBuffer value3) { + if (CHECKS) { + check(value1, 1); + check(value2, 1); + check(value3, 1); + } + nalGetSource3dSOFT(source, param, memAddress(value1), memAddress(value2), memAddress(value3)); + } + + // --- [ alGetSourcedvSOFT ] --- + + /** Unsafe version of: {@link #alGetSourcedvSOFT GetSourcedvSOFT} */ + public static void nalGetSourcedvSOFT(int source, int param, long values) { + long __functionAddress = AL.getICD().alGetSourcedvSOFT; + if (CHECKS) { + check(__functionAddress); + } + invokePV(source, param, values, __functionAddress); + } + + /** + * Array version of {@link #alGetSourcedSOFT GetSourcedSOFT} + * + * @param source the source to query + * @param param the parameter to query + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alGetSourcedvSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALdouble *") DoubleBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalGetSourcedvSOFT(source, param, memAddress(values)); + } + + // --- [ alSourcei64SOFT ] --- + + /** + * Sets the 64 bit integer value of a source parameter. + * + * @param source the source to modify + * @param param the parameter to modify + * @param value the parameter values + */ + @NativeType("ALvoid") + public static void alSourcei64SOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALint64SOFT") long value) { + long __functionAddress = AL.getICD().alSourcei64SOFT; + if (CHECKS) { + check(__functionAddress); + } + invokeJV(source, param, value, __functionAddress); + } + + // --- [ alSource3i64SOFT ] --- + + /** + * Sets the 3 dimensional 64 bit integer values of a source parameter. + * + * @param source the source to modify + * @param param the parameter to modify + * @param value1 the first value + * @param value2 the second value + * @param value3 the third value + */ + @NativeType("ALvoid") + public static void alSource3i64SOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALint64SOFT") long value1, @NativeType("ALint64SOFT") long value2, @NativeType("ALint64SOFT") long value3) { + long __functionAddress = AL.getICD().alSource3i64SOFT; + if (CHECKS) { + check(__functionAddress); + } + invokeJJJV(source, param, value1, value2, value3, __functionAddress); + } + + // --- [ alSourcei64vSOFT ] --- + + /** Unsafe version of: {@link #alSourcei64vSOFT Sourcei64vSOFT} */ + public static void nalSourcei64vSOFT(int source, int param, long values) { + long __functionAddress = AL.getICD().alSourcei64vSOFT; + if (CHECKS) { + check(__functionAddress); + } + invokePV(source, param, values, __functionAddress); + } + + /** + * Array version of {@link #alSourcei64SOFT Sourcei64SOFT} + * + * @param source the source to modify + * @param param the parameter to modify + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alSourcei64vSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALint64SOFT const *") LongBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalSourcei64vSOFT(source, param, memAddress(values)); + } + + // --- [ alGetSourcei64SOFT ] --- + + /** Unsafe version of: {@link #alGetSourcei64SOFT GetSourcei64SOFT} */ + public static void nalGetSourcei64SOFT(int source, int param, long value) { + long __functionAddress = AL.getICD().alGetSourcei64SOFT; + if (CHECKS) { + check(__functionAddress); + } + invokePV(source, param, value, __functionAddress); + } + + /** + * Gets the 64 bit integer value of a source parameter. + * + * @param source the source to query + * @param param the parameter to query + * @param value the parameter values + */ + @NativeType("ALvoid") + public static void alGetSourcei64SOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALint64SOFT *") LongBuffer value) { + if (CHECKS) { + check(value, 1); + } + nalGetSourcei64SOFT(source, param, memAddress(value)); + } + + /** + * Gets the 64 bit integer value of a source parameter. + * + * @param source the source to query + * @param param the parameter to query + */ + @NativeType("ALvoid") + public static long alGetSourcei64SOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer value = stack.callocLong(1); + nalGetSourcei64SOFT(source, param, memAddress(value)); + return value.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ alGetSource3i64SOFT ] --- + + /** Unsafe version of: {@link #alGetSource3i64SOFT GetSource3i64SOFT} */ + public static void nalGetSource3i64SOFT(int source, int param, long value1, long value2, long value3) { + long __functionAddress = AL.getICD().alGetSource3i64SOFT; + if (CHECKS) { + check(__functionAddress); + } + invokePPPV(source, param, value1, value2, value3, __functionAddress); + } + + /** + * Gets the 3 dimensional 64 bit integer values of a source parameter. + * + * @param source the source to query + * @param param the parameter to query + * @param value1 the first value + * @param value2 the second value + * @param value3 the third value + */ + @NativeType("ALvoid") + public static void alGetSource3i64SOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALint64SOFT *") LongBuffer value1, @NativeType("ALint64SOFT *") LongBuffer value2, @NativeType("ALint64SOFT *") LongBuffer value3) { + if (CHECKS) { + check(value1, 1); + check(value2, 1); + check(value3, 1); + } + nalGetSource3i64SOFT(source, param, memAddress(value1), memAddress(value2), memAddress(value3)); + } + + // --- [ alGetSourcei64vSOFT ] --- + + /** Unsafe version of: {@link #alGetSourcei64vSOFT GetSourcei64vSOFT} */ + public static void nalGetSourcei64vSOFT(int source, int param, long values) { + long __functionAddress = AL.getICD().alGetSourcei64vSOFT; + if (CHECKS) { + check(__functionAddress); + } + invokePV(source, param, values, __functionAddress); + } + + /** + * Array version of {@link #alGetSourcei64SOFT GetSourcei64SOFT} + * + * @param source the source to query + * @param param the parameter to query + * @param values the parameter values + */ + @NativeType("ALvoid") + public static void alGetSourcei64vSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALint64SOFT *") LongBuffer values) { + if (CHECKS) { + check(values, 1); + } + nalGetSourcei64vSOFT(source, param, memAddress(values)); + } + + /** Array version of: {@link #alSourcedvSOFT SourcedvSOFT} */ + @NativeType("ALvoid") + public static void alSourcedvSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALdouble const *") double[] value) { + long __functionAddress = AL.getICD().alSourcedvSOFT; + if (CHECKS) { + check(__functionAddress); + check(value, 1); + } + invokePV(source, param, value, __functionAddress); + } + + /** Array version of: {@link #alGetSourcedSOFT GetSourcedSOFT} */ + @NativeType("ALvoid") + public static void alGetSourcedSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALdouble *") double[] value) { + long __functionAddress = AL.getICD().alGetSourcedSOFT; + if (CHECKS) { + check(__functionAddress); + check(value, 1); + } + invokePV(source, param, value, __functionAddress); + } + + /** Array version of: {@link #alGetSource3dSOFT GetSource3dSOFT} */ + @NativeType("ALvoid") + public static void alGetSource3dSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALdouble *") double[] value1, @NativeType("ALdouble *") double[] value2, @NativeType("ALdouble *") double[] value3) { + long __functionAddress = AL.getICD().alGetSource3dSOFT; + if (CHECKS) { + check(__functionAddress); + check(value1, 1); + check(value2, 1); + check(value3, 1); + } + invokePPPV(source, param, value1, value2, value3, __functionAddress); + } + + /** Array version of: {@link #alGetSourcedvSOFT GetSourcedvSOFT} */ + @NativeType("ALvoid") + public static void alGetSourcedvSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALdouble *") double[] values) { + long __functionAddress = AL.getICD().alGetSourcedvSOFT; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(source, param, values, __functionAddress); + } + + /** Array version of: {@link #alSourcei64vSOFT Sourcei64vSOFT} */ + @NativeType("ALvoid") + public static void alSourcei64vSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALint64SOFT const *") long[] values) { + long __functionAddress = AL.getICD().alSourcei64vSOFT; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(source, param, values, __functionAddress); + } + + /** Array version of: {@link #alGetSourcei64SOFT GetSourcei64SOFT} */ + @NativeType("ALvoid") + public static void alGetSourcei64SOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALint64SOFT *") long[] value) { + long __functionAddress = AL.getICD().alGetSourcei64SOFT; + if (CHECKS) { + check(__functionAddress); + check(value, 1); + } + invokePV(source, param, value, __functionAddress); + } + + /** Array version of: {@link #alGetSource3i64SOFT GetSource3i64SOFT} */ + @NativeType("ALvoid") + public static void alGetSource3i64SOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALint64SOFT *") long[] value1, @NativeType("ALint64SOFT *") long[] value2, @NativeType("ALint64SOFT *") long[] value3) { + long __functionAddress = AL.getICD().alGetSource3i64SOFT; + if (CHECKS) { + check(__functionAddress); + check(value1, 1); + check(value2, 1); + check(value3, 1); + } + invokePPPV(source, param, value1, value2, value3, __functionAddress); + } + + /** Array version of: {@link #alGetSourcei64vSOFT GetSourcei64vSOFT} */ + @NativeType("ALvoid") + public static void alGetSourcei64vSOFT(@NativeType("ALuint") int source, @NativeType("ALenum") int param, @NativeType("ALint64SOFT *") long[] values) { + long __functionAddress = AL.getICD().alGetSourcei64vSOFT; + if (CHECKS) { + check(__functionAddress); + check(values, 1); + } + invokePV(source, param, values, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTSourceLength.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTSourceLength.java new file mode 100644 index 00000000..652b176d --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTSourceLength.java @@ -0,0 +1,30 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the SOFT_source_length extension. + * + *This extension adds a method to retrieve the total length of a source's buffer data in bytes, samples, and seconds, which correspond to the byte, + * sample, and seconds offset extents. By default, OpenAL only provides a way to retrieve a buffer's storage size in bytes, which does not necessarily + * represent the data size given to alBufferData nor the byte offset extent for the source's {@link AL11#AL_BYTE_OFFSET BYTE_OFFSET} property. The + * {@code AL_SOFT_buffer_samples} extension allows an application to query a buffer for its length in bytes, samples, and seconds, but this is only for a + * single buffer; a buffer queue on a source still requires additional bookkeeping by the application to keep track of the length of each buffer being + * queued and unqueued on a given source. This extension aims to ease that and provide a simple query.
+ */ +public final class SOFTSourceLength { + + /** Accepted by the {@code paramName} parameter of {@link AL10#alGetSourcei GetSourcei} and {@link AL10#alGetSourceiv GetSourceiv} (these are the same as in AL_SOFT_buffer_samples). */ + public static final int + AL_BYTE_LENGTH_SOFT = 0x2009, + AL_SAMPLE_LENGTH_SOFT = 0x200A; + + /** Accepted by the {@code paramName} parameter of {@link AL10#alGetSourcef GetSourcef} and {@link AL10#alGetSourcefv GetSourcefv} (these are the same as in AL_SOFT_buffer_samples). */ + public static final int AL_SEC_LENGTH_SOFT = 0x200B; + + private SOFTSourceLength() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTSourceResampler.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTSourceResampler.java new file mode 100644 index 00000000..2a639e93 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTSourceResampler.java @@ -0,0 +1,64 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +import javax.annotation.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the SOFT_source_resampler extension. + * + *This extension provides a method for applications to use different resamplers for sources. OpenAL automatically resamples when playing a source at a + * sample rate that don't match the device's sample rate, but the resampling method is left unspecified. One could assume it would use the "best" resample + * method available, but this gives no clear information about what's used nor any way to choose between quality or performance. Further, some + * applications may prefer lower quality resamplers for its spectral properties.
+ */ +public class SOFTSourceResampler { + + /** Accepted as the {@code pname} parameter of {@link AL10#alGetInteger GetInteger} and {@link AL10#alGetIntegerv GetIntegerv}. */ + public static final int + AL_NUM_RESAMPLERS_SOFT = 0x1210, + AL_DEFAULT_RESAMPLER_SOFT = 0x1211; + + /** Accepted as the {@code param} parameter of {@link AL10#alSourcei Sourcei}, {@link AL11#alSourceiv Sourceiv}, {@link AL10#alGetSourcei GetSourcei}, and {@link AL10#alGetSourceiv GetSourceiv}. */ + public static final int AL_SOURCE_RESAMPLER_SOFT = 0x1212; + + /** Accepted as the {@code pname} parameter of {@link #alGetStringiSOFT GetStringiSOFT}. */ + public static final int AL_RESAMPLER_NAME_SOFT = 0x1213; + + protected SOFTSourceResampler() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(ALCapabilities caps) { + return checkFunctions( + caps.alGetStringiSOFT + ); + } + + // --- [ alGetStringiSOFT ] --- + + public static long nalGetStringiSOFT(int pname, int index) { + long __functionAddress = AL.getICD().alGetStringiSOFT; + if (CHECKS) { + check(__functionAddress); + } + return invokeP(pname, index, __functionAddress); + } + + @Nullable + @NativeType("ALchar const *") + public static String alGetStringiSOFT(@NativeType("ALenum") int pname, @NativeType("ALsizei") int index) { + long __result = nalGetStringiSOFT(pname, index); + return memUTF8Safe(__result); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTSourceSpatialize.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTSourceSpatialize.java new file mode 100644 index 00000000..3af39304 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/SOFTSourceSpatialize.java @@ -0,0 +1,25 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.openal; + +/** + * Native bindings to the SOFT_source_spatialize extension. + * + *This extension provides more control over the spatialization behavior of sources. By default, OpenAL will spatialize sources playing a mono buffer and + * not spatialize sources playing a multi-channel buffer. Spatialization features include positional panning, distance attenuation, cone-related + * attenuation, and doppler effects. This extension allows such features to be enabled and disabled per-source independently of the buffer format.
+ */ +public final class SOFTSourceSpatialize { + + /** Accepted as the {@code param} parameter of {@link AL10#alSourcei Sourcei}, {@link AL11#alSourceiv Sourceiv}, {@link AL10#alGetSourcei GetSourcei}, and {@link AL10#alGetSourceiv GetSourceiv}. */ + public static final int AL_SOURCE_SPATIALIZE_SOFT = 0x1214; + + /** Accepted as the {@code value} of the {@link #AL_SOURCE_SPATIALIZE_SOFT SOURCE_SPATIALIZE_SOFT} property. */ + public static final int AL_AUTO_SOFT = 0x2; + + private SOFTSourceSpatialize() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/openal/package-info.java b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/package-info.java new file mode 100644 index 00000000..f7481c36 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/openal/package-info.java @@ -0,0 +1,21 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ + +/** + * Contains bindings to the OpenAL cross-platform 3D audio API. + * + *LWJGL comes with a software OpenAL implementation, OpenAL Soft.
+ * + *OpenAL Soft can be dynamically configured with environment variables. A + * very useful option for debugging is {@code ALSOFT_LOGLEVEL}; it can be set to values 0 through 4, with higher values producing more information.
+ * + *In addition to standard OpenAL features, OpenAL Soft supports HRTF, + * Ambisonics and 3D7.1. + * Documentation for these features is available in the OpenAL Soft repository.
+ */ +@org.lwjgl.system.NonnullDefault +package org.lwjgl.openal; + diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDBlendMinmaxFactor.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDBlendMinmaxFactor.java new file mode 100644 index 00000000..795be0d7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDBlendMinmaxFactor.java @@ -0,0 +1,31 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the AMD_blend_minmax_factor extension. + * + *The {@link EXTBlendMinmax EXT_blend_minmax} extension extended the GL's blending functionality to allow the blending equation to be specified by the application. That + * extension introduced the {@link EXTBlendMinmax#GL_MIN_EXT MIN_EXT} and {@link EXTBlendMinmax#GL_MAX_EXT MAX_EXT} blend equations, which caused the result of the blend equation to become the minimum or maximum of the + * source color and destination color, respectively.
+ * + *The {@link EXTBlendMinmax#GL_MIN_EXT MIN_EXT} and {@link EXTBlendMinmax#GL_MAX_EXT MAX_EXT} blend equations, however, do not include the source or destination blend factors in the arguments to the min and max + * functions. This extension provides two new blend equations that produce the minimum or maximum of the products of the source color and source factor, + * and the destination color and destination factor.
+ */ +public final class AMDBlendMinmaxFactor { + + /** + * Accepted by the {@code mode} parameter of BlendEquation and BlendEquationi, and by the {@code modeRGB} and {@code modeAlpha} parameters of + * BlendEquationSeparate and BlendEquationSeparatei. + */ + public static final int + GL_FACTOR_MIN_AMD = 0x901C, + GL_FACTOR_MAX_AMD = 0x901D; + + private AMDBlendMinmaxFactor() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDDebugOutput.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDDebugOutput.java new file mode 100644 index 00000000..e24e6083 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDDebugOutput.java @@ -0,0 +1,338 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the AMD_debug_output extension. + * + *This extension allows the GL to notify applications when various debug events occur in contexts that have been created with the debug flag, as provided + * by {@link WGLARBCreateContext WGL_ARB_create_context} and {@link GLXARBCreateContext GLX_ARB_create_context}.
+ * + *These events are represented in the form of enumerable messages with an included human-readable translation. Examples of debug events include incorrect + * use of the GL, warnings of undefined behavior, and performance warnings.
+ * + *A message is uniquely identified by a category and an implementation-dependent ID within that category. Message categories are general and are used to + * organize large groups of similar messages together. Examples of categories include GL errors, performance warnings, and deprecated functionality + * warnings. Each message is also assigned a severity level that denotes roughly how "important" that message is in comparison to other messages across all + * categories. For example, notification of a GL error would have a higher severity than a performance warning due to redundant state changes.
+ * + *Messages are communicated to the application through an application-defined callback function that is called by the GL implementation on each debug + * message. The motivation for the callback routine is to free application developers from actively having to query whether any GL error or other + * debuggable event has happened after each call to a GL function. With a callback, developers can keep their code free of debug checks, and only have to + * react to messages as they occur. In order to support indirect rendering, a message log is also provided that stores copies of recent messages until they + * are actively queried.
+ * + *To control the volume of debug output, messages can be disabled either individually by ID, or entire groups of messages can be turned off based on + * category or severity.
+ * + *The only requirement on the minimum quantity and type of messages that implementations of this extension must support is that a message must be sent + * notifying the application whenever any GL error occurs. Any further messages are left to the implementation. Implementations do not have to output + * messages from all categories listed by this extension in order to support this extension, and new categories can be added by other extensions.
+ * + *This extension places no restrictions or requirements on any additional functionality provided by the debug context flag through other extensions.
+ * + *Requires {@link WGLARBCreateContext WGL_ARB_create_context} or {@link GLXARBCreateContext GLX_ARB_create_context}.
+ */ +public class AMDDebugOutput { + + /** Tokens accepted by GetIntegerv. */ + public static final int + GL_MAX_DEBUG_MESSAGE_LENGTH_AMD = 0x9143, + GL_MAX_DEBUG_LOGGED_MESSAGES_AMD = 0x9144, + GL_DEBUG_LOGGED_MESSAGES_AMD = 0x9145; + + /** Tokens accepted by DebugMessageEnableAMD, GetDebugMessageLogAMD, DebugMessageInsertAMD, and DEBUGPROCAMD callback function for {@code severity}. */ + public static final int + GL_DEBUG_SEVERITY_HIGH_AMD = 0x9146, + GL_DEBUG_SEVERITY_MEDIUM_AMD = 0x9147, + GL_DEBUG_SEVERITY_LOW_AMD = 0x9148; + + /** Tokens accepted by DebugMessageEnableAMD, GetDebugMessageLogAMD, and DEBUGPROCAMD callback function for {@code category}. */ + public static final int + GL_DEBUG_CATEGORY_API_ERROR_AMD = 0x9149, + GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD = 0x914A, + GL_DEBUG_CATEGORY_DEPRECATION_AMD = 0x914B, + GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD = 0x914C, + GL_DEBUG_CATEGORY_PERFORMANCE_AMD = 0x914D, + GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD = 0x914E, + GL_DEBUG_CATEGORY_APPLICATION_AMD = 0x914F, + GL_DEBUG_CATEGORY_OTHER_AMD = 0x9150; + + static { GL.initialize(); } + + protected AMDDebugOutput() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDebugMessageEnableAMD, caps.glDebugMessageInsertAMD, caps.glDebugMessageCallbackAMD, caps.glGetDebugMessageLogAMD + ); + } + + // --- [ glDebugMessageEnableAMD ] --- + + /** + * Unsafe version of: {@link #glDebugMessageEnableAMD DebugMessageEnableAMD} + * + * @param count the number of values in the {@code ids} array + */ + public static native void nglDebugMessageEnableAMD(int category, int severity, int count, long ids, boolean enabled); + + /** + * Allows disabling or enabling generation of subsets of messages. If {@code enabled} is {@link GL11#GL_TRUE TRUE}, the referenced subset of messages is enabled. If + * {@link GL11#GL_FALSE FALSE}, then those messages are disabled. This command can reference different subsets of messages by varying its parameter values in the following + * ways: + * + *In all of the above cases, if {@code category} is non-zero and specifies an invalid category, the error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} is generated. Similarly if + * {@code severity} is non-zero and is an invalid severity level, the error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} is generated. If {@code count} is less than zero, the error + * {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated. If the parameters do not fall into one of the cases defined above, the error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated. The error + * {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if this command is called in a non-debug context.
+ * + *Although messages are grouped into categories and severities, and entire groups of messages can be turned off with a single call, there is no explicit + * per-category or per-severity enabled state. Instead the enabled state is stored individually for each message. There is no difference between disabling + * a category of messages with a single call, and enumerating all messages of that category and individually disabling each of them by their ID.
+ * + *All messages of severity level {@link #GL_DEBUG_SEVERITY_MEDIUM_AMD DEBUG_SEVERITY_MEDIUM_AMD} and {@link #GL_DEBUG_SEVERITY_HIGH_AMD DEBUG_SEVERITY_HIGH_AMD} in all categories are initially enabled, and all messages at + * {@link #GL_DEBUG_SEVERITY_LOW_AMD DEBUG_SEVERITY_LOW_AMD} are initially disabled.
+ * + * @param category the message category. One of:| {@link #GL_DEBUG_CATEGORY_API_ERROR_AMD DEBUG_CATEGORY_API_ERROR_AMD} | {@link #GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD DEBUG_CATEGORY_WINDOW_SYSTEM_AMD} |
| {@link #GL_DEBUG_CATEGORY_DEPRECATION_AMD DEBUG_CATEGORY_DEPRECATION_AMD} | {@link #GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD} |
| {@link #GL_DEBUG_CATEGORY_PERFORMANCE_AMD DEBUG_CATEGORY_PERFORMANCE_AMD} | {@link #GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD DEBUG_CATEGORY_SHADER_COMPILER_AMD} |
| {@link #GL_DEBUG_CATEGORY_APPLICATION_AMD DEBUG_CATEGORY_APPLICATION_AMD} | {@link #GL_DEBUG_CATEGORY_OTHER_AMD DEBUG_CATEGORY_OTHER_AMD} |
| {@link #GL_DEBUG_SEVERITY_HIGH_AMD DEBUG_SEVERITY_HIGH_AMD} | {@link #GL_DEBUG_SEVERITY_MEDIUM_AMD DEBUG_SEVERITY_MEDIUM_AMD} | {@link #GL_DEBUG_SEVERITY_LOW_AMD DEBUG_SEVERITY_LOW_AMD} |
In all of the above cases, if {@code category} is non-zero and specifies an invalid category, the error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} is generated. Similarly if + * {@code severity} is non-zero and is an invalid severity level, the error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} is generated. If {@code count} is less than zero, the error + * {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated. If the parameters do not fall into one of the cases defined above, the error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated. The error + * {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if this command is called in a non-debug context.
+ * + *Although messages are grouped into categories and severities, and entire groups of messages can be turned off with a single call, there is no explicit + * per-category or per-severity enabled state. Instead the enabled state is stored individually for each message. There is no difference between disabling + * a category of messages with a single call, and enumerating all messages of that category and individually disabling each of them by their ID.
+ * + *All messages of severity level {@link #GL_DEBUG_SEVERITY_MEDIUM_AMD DEBUG_SEVERITY_MEDIUM_AMD} and {@link #GL_DEBUG_SEVERITY_HIGH_AMD DEBUG_SEVERITY_HIGH_AMD} in all categories are initially enabled, and all messages at + * {@link #GL_DEBUG_SEVERITY_LOW_AMD DEBUG_SEVERITY_LOW_AMD} are initially disabled.
+ * + * @param category the message category. One of:| {@link #GL_DEBUG_CATEGORY_API_ERROR_AMD DEBUG_CATEGORY_API_ERROR_AMD} | {@link #GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD DEBUG_CATEGORY_WINDOW_SYSTEM_AMD} |
| {@link #GL_DEBUG_CATEGORY_DEPRECATION_AMD DEBUG_CATEGORY_DEPRECATION_AMD} | {@link #GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD} |
| {@link #GL_DEBUG_CATEGORY_PERFORMANCE_AMD DEBUG_CATEGORY_PERFORMANCE_AMD} | {@link #GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD DEBUG_CATEGORY_SHADER_COMPILER_AMD} |
| {@link #GL_DEBUG_CATEGORY_APPLICATION_AMD DEBUG_CATEGORY_APPLICATION_AMD} | {@link #GL_DEBUG_CATEGORY_OTHER_AMD DEBUG_CATEGORY_OTHER_AMD} |
| {@link #GL_DEBUG_SEVERITY_HIGH_AMD DEBUG_SEVERITY_HIGH_AMD} | {@link #GL_DEBUG_SEVERITY_MEDIUM_AMD DEBUG_SEVERITY_MEDIUM_AMD} | {@link #GL_DEBUG_SEVERITY_LOW_AMD DEBUG_SEVERITY_LOW_AMD} |
The value of {@code id} specifies the ID for the message and {@code severity} indicates its severity level as defined by the application. If + * {@code severity} is not a valid severity level, the error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} will be generated. The value of {@code category} must be + * {@link #GL_DEBUG_CATEGORY_APPLICATION_AMD DEBUG_CATEGORY_APPLICATION_AMD}, or the error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} will be generated. The string {@code buf} contains the string representation of the + * message. The parameter {@code length} contains the size of the message's string representation, excluding the null-terminator. If {@code length} is + * zero, then its value is derived from the string-length of {@code buf} and {@code buf} must contain a null-terminated string. The error + * {@link GL11#GL_INVALID_VALUE INVALID_VALUE} will be generated if {@code length} is less than zero or its derived value is larger than or equal to {@link #GL_MAX_DEBUG_MESSAGE_LENGTH_AMD MAX_DEBUG_MESSAGE_LENGTH_AMD}. + * The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} will be generated if this function is called in a non-debug context.
+ * + * @param category the message category. Must be:| {@link #GL_DEBUG_CATEGORY_APPLICATION_AMD DEBUG_CATEGORY_APPLICATION_AMD} |
| {@link #GL_DEBUG_SEVERITY_HIGH_AMD DEBUG_SEVERITY_HIGH_AMD} | {@link #GL_DEBUG_SEVERITY_MEDIUM_AMD DEBUG_SEVERITY_MEDIUM_AMD} | {@link #GL_DEBUG_SEVERITY_LOW_AMD DEBUG_SEVERITY_LOW_AMD} |
The value of {@code id} specifies the ID for the message and {@code severity} indicates its severity level as defined by the application. If + * {@code severity} is not a valid severity level, the error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} will be generated. The value of {@code category} must be + * {@link #GL_DEBUG_CATEGORY_APPLICATION_AMD DEBUG_CATEGORY_APPLICATION_AMD}, or the error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} will be generated. The string {@code buf} contains the string representation of the + * message. The parameter {@code length} contains the size of the message's string representation, excluding the null-terminator. If {@code length} is + * zero, then its value is derived from the string-length of {@code buf} and {@code buf} must contain a null-terminated string. The error + * {@link GL11#GL_INVALID_VALUE INVALID_VALUE} will be generated if {@code length} is less than zero or its derived value is larger than or equal to {@link #GL_MAX_DEBUG_MESSAGE_LENGTH_AMD MAX_DEBUG_MESSAGE_LENGTH_AMD}. + * The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} will be generated if this function is called in a non-debug context.
+ * + * @param category the message category. Must be:| {@link #GL_DEBUG_CATEGORY_APPLICATION_AMD DEBUG_CATEGORY_APPLICATION_AMD} |
| {@link #GL_DEBUG_SEVERITY_HIGH_AMD DEBUG_SEVERITY_HIGH_AMD} | {@link #GL_DEBUG_SEVERITY_MEDIUM_AMD DEBUG_SEVERITY_MEDIUM_AMD} | {@link #GL_DEBUG_SEVERITY_LOW_AMD DEBUG_SEVERITY_LOW_AMD} |
With {@code callback} storing the address of the callback function. This function's signature must follow the type definition of DEBUGPROCAMD, and its + * calling convention must be the same as the calling convention of GL functions. Anything else will result in undefined behavior. Only one debug callback + * can be specified for the current context, and further calls overwrite the previous callback. Specifying zero as the value of {@code callback} clears the + * current callback and disables message output through callbacks. Applications can specify user-specified data through the pointer {@code userParam}. The + * context will store this pointer and will include it as one of the parameters of each call to the callback function. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} + * will be generated if this function is called for contexts created without the debug flag.
+ * + *If the application has specified a callback function in a debug context, the implementation will call that function whenever any unfiltered message is + * generated. The ID, category, and severity of the message are specified by the callback parameters {@code id}, {@code category} and {@code severity}, + * respectively. The string representation of the message is stored in {@code message} and its length (excluding the null-terminator) is stored in + * {@code length}. The parameter {@code userParam} is the user-specified value that was passed when calling DebugMessageCallbackAMD. The memory for + * {@code message} is allocated, owned and released by the implementation, and should only be considered valid for the duration of the callback function + * call. While it is allowed to concurrently use multiple debug contexts with the same debug callback function, note that it is the application's + * responsibility to ensure that any work that occurs inside the debug callback function is thread-safe. Furthermore, calling any GL or window layer + * function from within the callback function results in undefined behavior.
+ * + *If no callback is set, then messages are instead stored in an internal message log up to some maximum number of strings as defined by the + * implementation-dependent constant {@link #GL_MAX_DEBUG_LOGGED_MESSAGES_AMD MAX_DEBUG_LOGGED_MESSAGES_AMD}. Each context stores its own message log and will only store messages generated by + * commands operating in that context. If the message log is full, then the oldest messages will be removed from the log to make room for newer ones. The + * application can query the number of messages currently in the log by obtaining the value of {@link #GL_DEBUG_LOGGED_MESSAGES_AMD DEBUG_LOGGED_MESSAGES_AMD}.
+ * + * @param callback a callback function that will be called when a debug message is generated + * @param userParam a user supplied pointer that will be passed on each invocation of {@code callback} + */ + public static void glDebugMessageCallbackAMD(@Nullable @NativeType("GLDEBUGPROCAMD") GLDebugMessageAMDCallbackI callback, @NativeType("void *") long userParam) { + nglDebugMessageCallbackAMD(memAddressSafe(callback), userParam); + } + + // --- [ glGetDebugMessageLogAMD ] --- + + /** + * Unsafe version of: {@link #glGetDebugMessageLogAMD GetDebugMessageLogAMD} + * + * @param bufsize the maximum number of characters that can be written in the {@code message} array + */ + public static native int nglGetDebugMessageLogAMD(int count, int bufsize, long categories, long severities, long ids, long lengths, long messageLog); + + /** + * Retrieves messages from the debug message log. + * + *This function will fetch as many messages as possible from the message log up to {@code count} in order from oldest to newest, and will return the + * number of messages fetched. Those messages that were fetched will be removed from the log. The value of {@code count} must be greater than zero and less + * than {@link #GL_MAX_DEBUG_LOGGED_MESSAGES_AMD MAX_DEBUG_LOGGED_MESSAGES_AMD} or otherwise the error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} will be generated. The value of {@code count} can be larger than the + * actual number of messages currently in the log. If {@code messageLog} is not a null pointer, then the string representations of all fetched messages + * will be stored in the buffer {@code messageLog} and will be separated by null-terminators. The maximum size of the buffer (including all + * null-terminators) is denoted by {@code bufSize}, and strings of messages within {@code count} that do not fit in the buffer will not be fetched. If + * {@code bufSize} is less than zero, the error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} will be generated. If {@code messageLog} is a null pointer, then the value of + * {@code bufSize} is ignored. The categories, severity levels, IDs, and string representation lengths of all (up to {@code count}) removed messages will + * be stored in the arrays {@code categories}, {@code severities}, {@code ids}, and {@code lengths}, respectively. The counts stored in the array + * {@code lengths} include the null-terminator of each string. Any and all of the output arrays, including {@code messageLog}, are optional, and no data is + * returned for those arrays that are specified with a null pointer. To simply delete up to {@code count} messages from the message log and ignoring, the + * application can call the function with null pointers for all output arrays. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} will be generated by GetDebugMessageLogAMD + * if it is called in a non-debug context.
+ * + * @param count the number of debug messages to retrieve from the log + * @param categories an array of variables to receive the categories of the retrieved messages + * @param severities an array of variables to receive the severities of the retrieved messages + * @param ids an array of variables to receive the ids of the retrieved messages + * @param lengths an array of variables to receive the lengths of the retrieved messages + * @param messageLog an array of characters that will receive the messages + */ + @NativeType("GLuint") + public static int glGetDebugMessageLogAMD(@NativeType("GLuint") int count, @Nullable @NativeType("GLenum *") IntBuffer categories, @Nullable @NativeType("GLuint *") IntBuffer severities, @Nullable @NativeType("GLuint *") IntBuffer ids, @Nullable @NativeType("GLsizei *") IntBuffer lengths, @Nullable @NativeType("GLchar *") ByteBuffer messageLog) { + if (CHECKS) { + checkSafe(categories, count); + checkSafe(severities, count); + checkSafe(ids, count); + checkSafe(lengths, count); + } + return nglGetDebugMessageLogAMD(count, remainingSafe(messageLog), memAddressSafe(categories), memAddressSafe(severities), memAddressSafe(ids), memAddressSafe(lengths), memAddressSafe(messageLog)); + } + + /** Array version of: {@link #glDebugMessageEnableAMD DebugMessageEnableAMD} */ + public static void glDebugMessageEnableAMD(@NativeType("GLenum") int category, @NativeType("GLenum") int severity, @Nullable @NativeType("GLuint const *") int[] ids, @NativeType("GLboolean") boolean enabled) { + long __functionAddress = GL.getICD().glDebugMessageEnableAMD; + if (CHECKS) { + check(__functionAddress); + } + callPV(category, severity, lengthSafe(ids), ids, enabled, __functionAddress); + } + + /** Array version of: {@link #glGetDebugMessageLogAMD GetDebugMessageLogAMD} */ + @NativeType("GLuint") + public static int glGetDebugMessageLogAMD(@NativeType("GLuint") int count, @Nullable @NativeType("GLenum *") int[] categories, @Nullable @NativeType("GLuint *") int[] severities, @Nullable @NativeType("GLuint *") int[] ids, @Nullable @NativeType("GLsizei *") int[] lengths, @Nullable @NativeType("GLchar *") ByteBuffer messageLog) { + long __functionAddress = GL.getICD().glGetDebugMessageLogAMD; + if (CHECKS) { + check(__functionAddress); + checkSafe(categories, count); + checkSafe(severities, count); + checkSafe(ids, count); + checkSafe(lengths, count); + } + return callPPPPPI(count, remainingSafe(messageLog), categories, severities, ids, lengths, memAddressSafe(messageLog), __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDDepthClampSeparate.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDDepthClampSeparate.java new file mode 100644 index 00000000..f4829b0a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDDepthClampSeparate.java @@ -0,0 +1,29 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the AMD_depth_clamp_separate extension. + * + *The extension {@link ARBDepthClamp ARB_depth_clamp} introduced the ability to control the clamping of the depth value for both the near and far plane. One limitation + * is that the control was for both planes at the same time; some applications can benefit from having clamping enabled for only one of the two planes, in + * order to save fillrate for the other plane by clipping the geometry.
+ * + *This extension provides exactly such functionality.
+ */ +public final class AMDDepthClampSeparate { + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int + GL_DEPTH_CLAMP_NEAR_AMD = 0x901E, + GL_DEPTH_CLAMP_FAR_AMD = 0x901F; + + private AMDDepthClampSeparate() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDDrawBuffersBlend.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDDrawBuffersBlend.java new file mode 100644 index 00000000..afc86f0d --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDDrawBuffersBlend.java @@ -0,0 +1,53 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the AMD_draw_buffers_blend extension. + * + *This extension builds upon the ARB_draw_buffers and EXT_draw_buffers2 extensions. In ARB_draw_buffers (part of OpenGL 2.0), separate values could be + * written to each color buffer. This was further enhanced by EXT_draw_buffers2 by adding in the ability to enable blending and to set color write masks + * independently per color output.
+ * + *This extension provides the ability to set individual blend equations and blend functions for each color output.
+ * + *Requires {@link GL20 OpenGL 2.0} and {@link EXTDrawBuffers2 EXT_draw_buffers2}.
+ */ +public class AMDDrawBuffersBlend { + + static { GL.initialize(); } + + protected AMDDrawBuffersBlend() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBlendFuncIndexedAMD, caps.glBlendFuncSeparateIndexedAMD, caps.glBlendEquationIndexedAMD, caps.glBlendEquationSeparateIndexedAMD + ); + } + + // --- [ glBlendFuncIndexedAMD ] --- + + public static native void glBlendFuncIndexedAMD(@NativeType("GLuint") int buf, @NativeType("GLenum") int src, @NativeType("GLenum") int dst); + + // --- [ glBlendFuncSeparateIndexedAMD ] --- + + public static native void glBlendFuncSeparateIndexedAMD(@NativeType("GLuint") int buf, @NativeType("GLenum") int srcRGB, @NativeType("GLenum") int dstRGB, @NativeType("GLenum") int srcAlpha, @NativeType("GLenum") int dstAlpha); + + // --- [ glBlendEquationIndexedAMD ] --- + + public static native void glBlendEquationIndexedAMD(@NativeType("GLuint") int buf, @NativeType("GLenum") int mode); + + // --- [ glBlendEquationSeparateIndexedAMD ] --- + + public static native void glBlendEquationSeparateIndexedAMD(@NativeType("GLuint") int buf, @NativeType("GLenum") int modeRGB, @NativeType("GLenum") int modeAlpha); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDFramebufferMultisampleAdvanced.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDFramebufferMultisampleAdvanced.java new file mode 100644 index 00000000..019775bb --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDFramebufferMultisampleAdvanced.java @@ -0,0 +1,62 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the AMD_framebuffer_multisample_advanced extension. + * + *This extension extends {@link ARBFramebufferObject ARB_framebuffer_object} by allowing compromises between image quality and memory footprint of multisample antialiasing.
+ * + *{@code ARB_framebuffer_object} introduced {@link GL30C#glRenderbufferStorageMultisample RenderbufferStorageMultisample} as a method of defining the parameters for a multisample render buffer. + * This function takes a {@code samples} parameter that has strict requirements on behavior such that no compromises in the final image quality are + * allowed. Additionally, {@code ARB_framebuffer_object} requires that all framebuffer attachments have the same number of samples.
+ * + *This extension extends {@code ARB_framebuffer_object} by providing a new function, {@link #glRenderbufferStorageMultisampleAdvancedAMD RenderbufferStorageMultisampleAdvancedAMD}, that distinguishes + * between samples and storage samples for color renderbuffers where the number of storage samples can be less than the number of samples. This extension + * also allows non-matching sample counts between color and depth/stencil renderbuffers.
+ * + *This extension does not require any specific combination of sample counts to be supported.
+ * + *Requires {@link ARBFramebufferObject ARB_framebuffer_object}.
+ */ +public class AMDFramebufferMultisampleAdvanced { + + /** Accepted by the {@code pname} parameter of {@link GL30C#glGetRenderbufferParameteriv GetRenderbufferParameteriv}. */ + public static final int GL_RENDERBUFFER_STORAGE_SAMPLES_AMD = 0x91B2; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, GetDoublev. */ + public static final int + GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD = 0x91B3, + GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD = 0x91B4, + GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD = 0x91B5, + GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD = 0x91B6, + GL_SUPPORTED_MULTISAMPLE_MODES_AMD = 0x91B7; + + static { GL.initialize(); } + + protected AMDFramebufferMultisampleAdvanced() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glRenderbufferStorageMultisampleAdvancedAMD, caps.glNamedRenderbufferStorageMultisampleAdvancedAMD + ); + } + + // --- [ glRenderbufferStorageMultisampleAdvancedAMD ] --- + + public static native void glRenderbufferStorageMultisampleAdvancedAMD(@NativeType("GLenum") int target, @NativeType("GLsizei") int samples, @NativeType("GLsizei") int storageSamples, @NativeType("GLenum") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height); + + // --- [ glNamedRenderbufferStorageMultisampleAdvancedAMD ] --- + + public static native void glNamedRenderbufferStorageMultisampleAdvancedAMD(@NativeType("GLuint") int renderbuffer, @NativeType("GLsizei") int samples, @NativeType("GLsizei") int storageSamples, @NativeType("GLenum") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDGPUShaderHalfFloat.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDGPUShaderHalfFloat.java new file mode 100644 index 00000000..f9dc9632 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDGPUShaderHalfFloat.java @@ -0,0 +1,44 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the AMD_gpu_shader_half_float extension. + * + *This extension was developed based on the {@link NVGPUShader5 NV_gpu_shader5} extension to allow implementations supporting half float in shader and expose the + * feature without the additional requirements that are present in {@code NV_gpu_shader5}.
+ * + *The extension introduces the following features for all shader types:
+ * + *This extension is designed to be a functional superset of the half-precision floating-point support from NV_gpu_shader5 and to keep source code + * compatible with that, thus the new procedures, functions, and tokens are identical to those found in that extension.
+ * + *Requires {@link GL40 OpenGL 4.0} and GLSL 4.00.
+ */ +public final class AMDGPUShaderHalfFloat { + + /** Returned by the {@code type} parameter of GetActiveAttrib, GetActiveUniform, and GetTransformFeedbackVarying. */ + public static final int + GL_FLOAT16_MAT2_AMD = 0x91C5, + GL_FLOAT16_MAT3_AMD = 0x91C6, + GL_FLOAT16_MAT4_AMD = 0x91C7, + GL_FLOAT16_MAT2x3_AMD = 0x91C8, + GL_FLOAT16_MAT2x4_AMD = 0x91C9, + GL_FLOAT16_MAT3x2_AMD = 0x91CA, + GL_FLOAT16_MAT3x4_AMD = 0x91CB, + GL_FLOAT16_MAT4x2_AMD = 0x91CC, + GL_FLOAT16_MAT4x3_AMD = 0x91CD; + + private AMDGPUShaderHalfFloat() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDGPUShaderHalfFloatFetch.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDGPUShaderHalfFloatFetch.java new file mode 100644 index 00000000..6664da7c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDGPUShaderHalfFloatFetch.java @@ -0,0 +1,52 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the AMD_gpu_shader_half_float_fetch extension. + * + *This extension was developed based on the {@code AMD_gpu_shader_half_float} extension to allow implementations supporting half-precision floating-point + * both in shader texture functions and in shader image memory functions.
+ * + *Requires {@link GL40 OpenGL 4.0}, GLSL 4.00 and {@link AMDGPUShaderHalfFloat AMD_gpu_shader_half_float}.
+ */ +public final class AMDGPUShaderHalfFloatFetch { + + /** Returned by the {@code type} parameter of {@link GL20C#glGetActiveUniform GetActiveUniform} and {@link GL43C#glGetProgramResourceiv GetProgramResourceiv}. */ + public static final int + GL_FLOAT16_SAMPLER_1D_AMD = 0x91CE, + GL_FLOAT16_SAMPLER_2D_AMD = 0x91CF, + GL_FLOAT16_SAMPLER_3D_AMD = 0x91D0, + GL_FLOAT16_SAMPLER_CUBE_AMD = 0x91D1, + GL_FLOAT16_SAMPLER_2D_RECT_AMD = 0x91D2, + GL_FLOAT16_SAMPLER_1D_ARRAY_AMD = 0x91D3, + GL_FLOAT16_SAMPLER_2D_ARRAY_AMD = 0x91D4, + GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_AMD = 0x91D5, + GL_FLOAT16_SAMPLER_BUFFER_AMD = 0x91D6, + GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_AMD = 0x91D7, + GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_ARRAY_AMD = 0x91D8, + GL_FLOAT16_SAMPLER_1D_SHADOW_AMD = 0x91D9, + GL_FLOAT16_SAMPLER_2D_SHADOW_AMD = 0x91DA, + GL_FLOAT16_SAMPLER_2D_RECT_SHADOW_AMD = 0x91DB, + GL_FLOAT16_SAMPLER_1D_ARRAY_SHADOW_AMD = 0x91DC, + GL_FLOAT16_SAMPLER_2D_ARRAY_SHADOW_AMD = 0x91DD, + GL_FLOAT16_SAMPLER_CUBE_SHADOW_AMD = 0x91DE, + GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_SHADOW_AMD = 0x91DF, + GL_FLOAT16_IMAGE_1D_AMD = 0x91E0, + GL_FLOAT16_IMAGE_2D_AMD = 0x91E1, + GL_FLOAT16_IMAGE_3D_AMD = 0x91E2, + GL_FLOAT16_IMAGE_2D_RECT_AMD = 0x91E3, + GL_FLOAT16_IMAGE_CUBE_AMD = 0x91E4, + GL_FLOAT16_IMAGE_1D_ARRAY_AMD = 0x91E5, + GL_FLOAT16_IMAGE_2D_ARRAY_AMD = 0x91E6, + GL_FLOAT16_IMAGE_CUBE_MAP_ARRAY_AMD = 0x91E7, + GL_FLOAT16_IMAGE_BUFFER_AMD = 0x91E8, + GL_FLOAT16_IMAGE_2D_MULTISAMPLE_AMD = 0x91E9, + GL_FLOAT16_IMAGE_2D_MULTISAMPLE_ARRAY_AMD = 0x91EA; + + private AMDGPUShaderHalfFloatFetch() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDGPUShaderInt64.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDGPUShaderInt64.java new file mode 100644 index 00000000..e3842210 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDGPUShaderInt64.java @@ -0,0 +1,475 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the AMD_gpu_shader_int64 extension. + * + *This extension was developed based on the NV_gpu_shader5 extension to allow implementations supporting 64-bit integers to expose the feature without + * the additional requirements that are present in NV_gpu_shader5.
+ * + *The extension introduces the following features for all shader types:
+ * + *This extension is designed to be a functional superset of the 64-bit integer support introduced by NV_gpu_shader5 and to be source code compatible with + * that, thus the new procedures, functions, and tokens are identical to those found in that extension.
+ * + *Requires {@link GL40 OpenGL 4.0} and GLSL 4.00.
+ */ +public class AMDGPUShaderInt64 { + + /** Returned by the {@code type} parameter of GetActiveAttrib, GetActiveUniform, and GetTransformFeedbackVarying. */ + public static final int + GL_INT64_NV = 0x140E, + GL_UNSIGNED_INT64_NV = 0x140F, + GL_INT8_NV = 0x8FE0, + GL_INT8_VEC2_NV = 0x8FE1, + GL_INT8_VEC3_NV = 0x8FE2, + GL_INT8_VEC4_NV = 0x8FE3, + GL_INT16_NV = 0x8FE4, + GL_INT16_VEC2_NV = 0x8FE5, + GL_INT16_VEC3_NV = 0x8FE6, + GL_INT16_VEC4_NV = 0x8FE7, + GL_INT64_VEC2_NV = 0x8FE9, + GL_INT64_VEC3_NV = 0x8FEA, + GL_INT64_VEC4_NV = 0x8FEB, + GL_UNSIGNED_INT8_NV = 0x8FEC, + GL_UNSIGNED_INT8_VEC2_NV = 0x8FED, + GL_UNSIGNED_INT8_VEC3_NV = 0x8FEE, + GL_UNSIGNED_INT8_VEC4_NV = 0x8FEF, + GL_UNSIGNED_INT16_NV = 0x8FF0, + GL_UNSIGNED_INT16_VEC2_NV = 0x8FF1, + GL_UNSIGNED_INT16_VEC3_NV = 0x8FF2, + GL_UNSIGNED_INT16_VEC4_NV = 0x8FF3, + GL_UNSIGNED_INT64_VEC2_NV = 0x8FF5, + GL_UNSIGNED_INT64_VEC3_NV = 0x8FF6, + GL_UNSIGNED_INT64_VEC4_NV = 0x8FF7, + GL_FLOAT16_NV = 0x8FF8, + GL_FLOAT16_VEC2_NV = 0x8FF9, + GL_FLOAT16_VEC3_NV = 0x8FFA, + GL_FLOAT16_VEC4_NV = 0x8FFB; + + static { GL.initialize(); } + + protected AMDGPUShaderInt64() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetThe glDrawElements function and its variants (instanced and indirect, for example) allow OpenGL to draw indexed arrays of vertices. Since its + * inception, OpenGL has supported unsigned bytes, unsigned shorts and unsigned integers as index types. However, all enabled vertex arrays may be + * represented by at most one shared index.
+ * + *A common scenario in graphics rendering is that several faces share a vertex where, for each face some properties of a vertex (position and texture + * coordinates, for example) should be common but others must be unique (colors, normals, and so on). Consider a mesh of a cube with per-face normals, for + * example. There are 8 vertices and 6 normals, and 12 triangles (where each face of the cube is represented as two triangles). To render this cube, we + * must compute the 24 unique permutations of position and normal and build a new element list to index into it. In fact, any advantage of indexed draw is + * lost here as the number of required permutations is equal to the final vertex count required to draw the object.
+ * + *This extension allows OpenGL to process multi-component packed element data. The maximum size of a vertex's index data is not increased, but the + * facility to store 2 16-bit or 2 or 4 8-bit indices per vertex is introduced. Each vertex attribute is given a swizzle property to allow its index to be + * sourced from one of up to 4 channels of index data. This effectively allows an application to supply multiple interleaved streams of index data to + * OpenGL. Each vertex attribute is given a 'channel selector' to select one of the up to 4 channels of vertex index information presented to OpenGL. This + * enables the use-case described above and many more. The swizzle parameter is also applied to vertex indices passed to shaders, and updates to the + * definition of base vertex parameters and primitive restart are applied.
+ */ +public class AMDInterleavedElements { + + /** Accepted by the {@code pname} parameter of VertexAttribParameteriAMD and GetVertexAttrib{iv|dv|fv|Iiv|Iuiv|Ldv}. */ + public static final int GL_VERTEX_ELEMENT_SWIZZLE_AMD = 0x91A4; + + /** Selected by the {@code pname} parameter of ProgramParameteri and GetProgramiv. */ + public static final int GL_VERTEX_ID_SWIZZLE_AMD = 0x91A5; + + static { GL.initialize(); } + + protected AMDInterleavedElements() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glVertexAttribParameteriAMD + ); + } + + // --- [ glVertexAttribParameteriAMD ] --- + + public static native void glVertexAttribParameteriAMD(@NativeType("GLuint") int index, @NativeType("GLenum") int pname, @NativeType("GLint") int param); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDOcclusionQueryEvent.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDOcclusionQueryEvent.java new file mode 100644 index 00000000..4bd4a3c2 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDOcclusionQueryEvent.java @@ -0,0 +1,61 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the AMD_occlusion_query_event extension. + * + *This extension introduces the concept of occlusion query events and changes the concept of an occlusion query from counting passed fragments to counting + * fragments that generate any of a user-selectable set of events. Provided events include passing the depth test, and passing or failing the stencil test. + * For a given occlusion query object, counting of these events may be enabled or disabled, allowing any combination to be counted.
+ * + *Requires {@link GL15 OpenGL 1.5}.
+ */ +public class AMDOcclusionQueryEvent { + + /** + * Accepted by the {@code pname} argument to {@link #glQueryObjectParameteruiAMD QueryObjectParameteruiAMD}, {@link GL15C#glGetQueryObjectiv GetQueryObjectiv}, {@link GL15C#glGetQueryObjectuiv GetQueryObjectuiv}, + * {@link GL33C#glGetQueryObjecti64v GetQueryObjecti64v}, and {@link GL33C#glGetQueryObjectui64v GetQueryObjectui64v}. + */ + public static final int GL_OCCLUSION_QUERY_EVENT_MASK_AMD = 0x874F; + + /** Accepted by the {@code param} argument to {@link #glQueryObjectParameteruiAMD QueryObjectParameteruiAMD}. */ + public static final int + GL_QUERY_DEPTH_PASS_EVENT_BIT_AMD = 0x1, + GL_QUERY_DEPTH_FAIL_EVENT_BIT_AMD = 0x2, + GL_QUERY_STENCIL_FAIL_EVENT_BIT_AMD = 0x4, + GL_QUERY_DEPTH_BOUNDS_FAIL_EVENT_BIT_AMD = 0x8, + GL_QUERY_ALL_EVENT_BITS_AMD = 0xFFFFFFFF; + + static { GL.initialize(); } + + protected AMDOcclusionQueryEvent() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glQueryObjectParameteruiAMD + ); + } + + // --- [ glQueryObjectParameteruiAMD ] --- + + /** + * Changes the value of a query object parameter. + * + * @param target a valid query target. One of:| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link #GL_OCCLUSION_QUERY_EVENT_MASK_AMD OCCLUSION_QUERY_EVENT_MASK_AMD} |
| {@link #GL_QUERY_DEPTH_PASS_EVENT_BIT_AMD QUERY_DEPTH_PASS_EVENT_BIT_AMD} | {@link #GL_QUERY_DEPTH_FAIL_EVENT_BIT_AMD QUERY_DEPTH_FAIL_EVENT_BIT_AMD} |
| {@link #GL_QUERY_STENCIL_FAIL_EVENT_BIT_AMD QUERY_STENCIL_FAIL_EVENT_BIT_AMD} | {@link #GL_QUERY_DEPTH_BOUNDS_FAIL_EVENT_BIT_AMD QUERY_DEPTH_BOUNDS_FAIL_EVENT_BIT_AMD} |
| {@link #GL_QUERY_ALL_EVENT_BITS_AMD QUERY_ALL_EVENT_BITS_AMD} |
This extension enables the capture and reporting of performance monitors. Performance monitors contain groups of counters which hold arbitrary counted + * data. Typically, the counters hold information on performance-related counters in the underlying hardware. The extension is general enough to allow the + * implementation to choose which counters to expose and pick the data type and range of the counters. The extension also allows counting to start and end + * on arbitrary boundaries during rendering.
+ */ +public class AMDPerformanceMonitor { + + /** Accepted by the {@code pame} parameter of GetPerfMonitorCounterInfoAMD. */ + public static final int + GL_COUNTER_TYPE_AMD = 0x8BC0, + GL_COUNTER_RANGE_AMD = 0x8BC1; + + /** Returned as a valid value in {@code data} parameter of GetPerfMonitorCounterInfoAMD if {@code pname} = COUNTER_TYPE_AMD. */ + public static final int + GL_UNSIGNED_INT64_AMD = 0x8BC2, + GL_PERCENTAGE_AMD = 0x8BC3; + + /** Accepted by the {@code pname} parameter of GetPerfMonitorCounterDataAMD. */ + public static final int + GL_PERFMON_RESULT_AVAILABLE_AMD = 0x8BC4, + GL_PERFMON_RESULT_SIZE_AMD = 0x8BC5, + GL_PERFMON_RESULT_AMD = 0x8BC6; + + static { GL.initialize(); } + + protected AMDPerformanceMonitor() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetPerfMonitorGroupsAMD, caps.glGetPerfMonitorCountersAMD, caps.glGetPerfMonitorGroupStringAMD, caps.glGetPerfMonitorCounterStringAMD, + caps.glGetPerfMonitorCounterInfoAMD, caps.glGenPerfMonitorsAMD, caps.glDeletePerfMonitorsAMD, caps.glSelectPerfMonitorCountersAMD, + caps.glBeginPerfMonitorAMD, caps.glEndPerfMonitorAMD, caps.glGetPerfMonitorCounterDataAMD + ); + } + + // --- [ glGetPerfMonitorGroupsAMD ] --- + + public static native void nglGetPerfMonitorGroupsAMD(long numGroups, int groupsSize, long groups); + + public static void glGetPerfMonitorGroupsAMD(@Nullable @NativeType("GLint *") IntBuffer numGroups, @Nullable @NativeType("GLuint *") IntBuffer groups) { + if (CHECKS) { + checkSafe(numGroups, 1); + } + nglGetPerfMonitorGroupsAMD(memAddressSafe(numGroups), remainingSafe(groups), memAddressSafe(groups)); + } + + // --- [ glGetPerfMonitorCountersAMD ] --- + + public static native void nglGetPerfMonitorCountersAMD(int group, long numCounters, long maxActiveCounters, int counterSize, long counters); + + public static void glGetPerfMonitorCountersAMD(@NativeType("GLuint") int group, @NativeType("GLint *") IntBuffer numCounters, @NativeType("GLint *") IntBuffer maxActiveCounters, @NativeType("GLuint *") IntBuffer counters) { + if (CHECKS) { + check(numCounters, 1); + check(maxActiveCounters, 1); + } + nglGetPerfMonitorCountersAMD(group, memAddress(numCounters), memAddress(maxActiveCounters), counters.remaining(), memAddress(counters)); + } + + // --- [ glGetPerfMonitorGroupStringAMD ] --- + + public static native void nglGetPerfMonitorGroupStringAMD(int group, int bufSize, long length, long groupString); + + public static void glGetPerfMonitorGroupStringAMD(@NativeType("GLuint") int group, @NativeType("GLsizei *") IntBuffer length, @NativeType("GLchar *") ByteBuffer groupString) { + if (CHECKS) { + check(length, 1); + } + nglGetPerfMonitorGroupStringAMD(group, groupString.remaining(), memAddress(length), memAddress(groupString)); + } + + // --- [ glGetPerfMonitorCounterStringAMD ] --- + + public static native void nglGetPerfMonitorCounterStringAMD(int group, int counter, int bufSize, long length, long counterString); + + public static void glGetPerfMonitorCounterStringAMD(@NativeType("GLuint") int group, @NativeType("GLuint") int counter, @Nullable @NativeType("GLsizei *") IntBuffer length, @Nullable @NativeType("GLchar *") ByteBuffer counterString) { + if (CHECKS) { + checkSafe(length, 1); + } + nglGetPerfMonitorCounterStringAMD(group, counter, remainingSafe(counterString), memAddressSafe(length), memAddressSafe(counterString)); + } + + // --- [ glGetPerfMonitorCounterInfoAMD ] --- + + public static native void nglGetPerfMonitorCounterInfoAMD(int group, int counter, int pname, long data); + + public static void glGetPerfMonitorCounterInfoAMD(@NativeType("GLuint") int group, @NativeType("GLuint") int counter, @NativeType("GLenum") int pname, @NativeType("void *") ByteBuffer data) { + if (CHECKS) { + check(data, 4); + } + nglGetPerfMonitorCounterInfoAMD(group, counter, pname, memAddress(data)); + } + + public static void glGetPerfMonitorCounterInfoAMD(@NativeType("GLuint") int group, @NativeType("GLuint") int counter, @NativeType("GLenum") int pname, @NativeType("void *") IntBuffer data) { + if (CHECKS) { + check(data, 4 >> 2); + } + nglGetPerfMonitorCounterInfoAMD(group, counter, pname, memAddress(data)); + } + + public static void glGetPerfMonitorCounterInfoAMD(@NativeType("GLuint") int group, @NativeType("GLuint") int counter, @NativeType("GLenum") int pname, @NativeType("void *") FloatBuffer data) { + if (CHECKS) { + check(data, 4 >> 2); + } + nglGetPerfMonitorCounterInfoAMD(group, counter, pname, memAddress(data)); + } + + // --- [ glGenPerfMonitorsAMD ] --- + + public static native void nglGenPerfMonitorsAMD(int n, long monitors); + + public static void glGenPerfMonitorsAMD(@NativeType("GLuint *") IntBuffer monitors) { + nglGenPerfMonitorsAMD(monitors.remaining(), memAddress(monitors)); + } + + @NativeType("void") + public static int glGenPerfMonitorsAMD() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer monitors = stack.callocInt(1); + nglGenPerfMonitorsAMD(1, memAddress(monitors)); + return monitors.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glDeletePerfMonitorsAMD ] --- + + public static native void nglDeletePerfMonitorsAMD(int n, long monitors); + + public static void glDeletePerfMonitorsAMD(@NativeType("GLuint *") IntBuffer monitors) { + nglDeletePerfMonitorsAMD(monitors.remaining(), memAddress(monitors)); + } + + public static void glDeletePerfMonitorsAMD(@NativeType("GLuint *") int monitor) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer monitors = stack.ints(monitor); + nglDeletePerfMonitorsAMD(1, memAddress(monitors)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glSelectPerfMonitorCountersAMD ] --- + + public static native void nglSelectPerfMonitorCountersAMD(int monitor, boolean enable, int group, int numCounters, long counterList); + + public static void glSelectPerfMonitorCountersAMD(@NativeType("GLuint") int monitor, @NativeType("GLboolean") boolean enable, @NativeType("GLuint") int group, @NativeType("GLuint *") IntBuffer counterList) { + nglSelectPerfMonitorCountersAMD(monitor, enable, group, counterList.remaining(), memAddress(counterList)); + } + + // --- [ glBeginPerfMonitorAMD ] --- + + public static native void glBeginPerfMonitorAMD(@NativeType("GLuint") int monitor); + + // --- [ glEndPerfMonitorAMD ] --- + + public static native void glEndPerfMonitorAMD(@NativeType("GLuint") int monitor); + + // --- [ glGetPerfMonitorCounterDataAMD ] --- + + public static native void nglGetPerfMonitorCounterDataAMD(int monitor, int pname, int dataSize, long data, long bytesWritten); + + public static void glGetPerfMonitorCounterDataAMD(@NativeType("GLuint") int monitor, @NativeType("GLenum") int pname, @NativeType("GLuint *") IntBuffer data, @Nullable @NativeType("GLint *") IntBuffer bytesWritten) { + if (CHECKS) { + checkSafe(bytesWritten, 1); + } + nglGetPerfMonitorCounterDataAMD(monitor, pname, data.remaining(), memAddress(data), memAddressSafe(bytesWritten)); + } + + /** Array version of: {@link #glGetPerfMonitorGroupsAMD GetPerfMonitorGroupsAMD} */ + public static void glGetPerfMonitorGroupsAMD(@Nullable @NativeType("GLint *") int[] numGroups, @Nullable @NativeType("GLuint *") int[] groups) { + long __functionAddress = GL.getICD().glGetPerfMonitorGroupsAMD; + if (CHECKS) { + check(__functionAddress); + checkSafe(numGroups, 1); + } + callPPV(numGroups, lengthSafe(groups), groups, __functionAddress); + } + + /** Array version of: {@link #glGetPerfMonitorCountersAMD GetPerfMonitorCountersAMD} */ + public static void glGetPerfMonitorCountersAMD(@NativeType("GLuint") int group, @NativeType("GLint *") int[] numCounters, @NativeType("GLint *") int[] maxActiveCounters, @NativeType("GLuint *") int[] counters) { + long __functionAddress = GL.getICD().glGetPerfMonitorCountersAMD; + if (CHECKS) { + check(__functionAddress); + check(numCounters, 1); + check(maxActiveCounters, 1); + } + callPPPV(group, numCounters, maxActiveCounters, counters.length, counters, __functionAddress); + } + + /** Array version of: {@link #glGetPerfMonitorGroupStringAMD GetPerfMonitorGroupStringAMD} */ + public static void glGetPerfMonitorGroupStringAMD(@NativeType("GLuint") int group, @NativeType("GLsizei *") int[] length, @NativeType("GLchar *") ByteBuffer groupString) { + long __functionAddress = GL.getICD().glGetPerfMonitorGroupStringAMD; + if (CHECKS) { + check(__functionAddress); + check(length, 1); + } + callPPV(group, groupString.remaining(), length, memAddress(groupString), __functionAddress); + } + + /** Array version of: {@link #glGetPerfMonitorCounterStringAMD GetPerfMonitorCounterStringAMD} */ + public static void glGetPerfMonitorCounterStringAMD(@NativeType("GLuint") int group, @NativeType("GLuint") int counter, @Nullable @NativeType("GLsizei *") int[] length, @Nullable @NativeType("GLchar *") ByteBuffer counterString) { + long __functionAddress = GL.getICD().glGetPerfMonitorCounterStringAMD; + if (CHECKS) { + check(__functionAddress); + checkSafe(length, 1); + } + callPPV(group, counter, remainingSafe(counterString), length, memAddressSafe(counterString), __functionAddress); + } + + /** Array version of: {@link #glGetPerfMonitorCounterInfoAMD GetPerfMonitorCounterInfoAMD} */ + public static void glGetPerfMonitorCounterInfoAMD(@NativeType("GLuint") int group, @NativeType("GLuint") int counter, @NativeType("GLenum") int pname, @NativeType("void *") int[] data) { + long __functionAddress = GL.getICD().glGetPerfMonitorCounterInfoAMD; + if (CHECKS) { + check(__functionAddress); + check(data, 4 >> 2); + } + callPV(group, counter, pname, data, __functionAddress); + } + + /** Array version of: {@link #glGetPerfMonitorCounterInfoAMD GetPerfMonitorCounterInfoAMD} */ + public static void glGetPerfMonitorCounterInfoAMD(@NativeType("GLuint") int group, @NativeType("GLuint") int counter, @NativeType("GLenum") int pname, @NativeType("void *") float[] data) { + long __functionAddress = GL.getICD().glGetPerfMonitorCounterInfoAMD; + if (CHECKS) { + check(__functionAddress); + check(data, 4 >> 2); + } + callPV(group, counter, pname, data, __functionAddress); + } + + /** Array version of: {@link #glGenPerfMonitorsAMD GenPerfMonitorsAMD} */ + public static void glGenPerfMonitorsAMD(@NativeType("GLuint *") int[] monitors) { + long __functionAddress = GL.getICD().glGenPerfMonitorsAMD; + if (CHECKS) { + check(__functionAddress); + } + callPV(monitors.length, monitors, __functionAddress); + } + + /** Array version of: {@link #glDeletePerfMonitorsAMD DeletePerfMonitorsAMD} */ + public static void glDeletePerfMonitorsAMD(@NativeType("GLuint *") int[] monitors) { + long __functionAddress = GL.getICD().glDeletePerfMonitorsAMD; + if (CHECKS) { + check(__functionAddress); + } + callPV(monitors.length, monitors, __functionAddress); + } + + /** Array version of: {@link #glSelectPerfMonitorCountersAMD SelectPerfMonitorCountersAMD} */ + public static void glSelectPerfMonitorCountersAMD(@NativeType("GLuint") int monitor, @NativeType("GLboolean") boolean enable, @NativeType("GLuint") int group, @NativeType("GLuint *") int[] counterList) { + long __functionAddress = GL.getICD().glSelectPerfMonitorCountersAMD; + if (CHECKS) { + check(__functionAddress); + } + callPV(monitor, enable, group, counterList.length, counterList, __functionAddress); + } + + /** Array version of: {@link #glGetPerfMonitorCounterDataAMD GetPerfMonitorCounterDataAMD} */ + public static void glGetPerfMonitorCounterDataAMD(@NativeType("GLuint") int monitor, @NativeType("GLenum") int pname, @NativeType("GLuint *") int[] data, @Nullable @NativeType("GLint *") int[] bytesWritten) { + long __functionAddress = GL.getICD().glGetPerfMonitorCounterDataAMD; + if (CHECKS) { + check(__functionAddress); + checkSafe(bytesWritten, 1); + } + callPPV(monitor, pname, data.length, data, bytesWritten, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDPinnedMemory.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDPinnedMemory.java new file mode 100644 index 00000000..f68951d9 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDPinnedMemory.java @@ -0,0 +1,23 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the AMD_pinned_memory extension. + * + *This extension defines an interface that allows improved control of the physical memory used by the graphics device.
+ * + *It allows an existing page of system memory allocated by the application to be used as memory directly accessible to the graphics processor. One + * example application of this functionality would be to be able to avoid an explicit synchronous copy with sub-system of the application; for instance it + * is possible to directly draw from a system memory copy of a video image.
+ */ +public final class AMDPinnedMemory { + + public static final int GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD = 0x9160; + + private AMDPinnedMemory() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDQueryBufferObject.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDQueryBufferObject.java new file mode 100644 index 00000000..d8cc46b6 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDQueryBufferObject.java @@ -0,0 +1,43 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the AMD_query_buffer_object extension. + * + *Statistics about the operation of the OpenGL pipeline, such as the number of samples that passed the depth test, the elapsed time between two events or + * the number of vertices written to a transform feedback buffer may be retrieved from the GL through query objects. The current value of a query object + * may be retrieved by the application through the OpenGL API. Should the result returned by the API be required for use in a shader, it must be passed + * back to the GL via a program uniform or some other mechanism. This requires a round-trip from the GPU to the CPU and back.
+ * + *This extension introduces a mechanism whereby the current value of a query result may be retrieved into a buffer object instead of client memory. This + * allows the query result to be made available to a shader without a round-trip to the CPU for example by subsequently using the buffer object as a + * uniform buffer, texture buffer or other data store visible to the shader. This functionality may also be used to place the results of many query + * objects into a single, large buffer and then map or otherwise read back the entire buffer at a later point in time, avoiding a per-query CPU-GPU + * synchronization event.
+ * + *The result of any query object type supported by the GL implementation may be retrieved into a buffer object. The implementation will determine the + * most efficient method of copying the query result to the buffer.
+ * + *Requires {@link GL15 OpenGL 1.5}.
+ */ +public final class AMDQueryBufferObject { + + /** Accepted by the {@code pname} parameter of GetQueryObjectiv, GetQueryObjectuiv, GetQueryObjecti64v and GetQueryObjectui64v. */ + public static final int GL_QUERY_RESULT_NO_WAIT_AMD = 0x9194; + + /** + * Accepted by the {@code target} parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, MapBufferRange, GetBufferSubData, + * GetBufferParameteriv and GetBufferPointerv. + */ + public static final int GL_QUERY_BUFFER_AMD = 0x9192; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_QUERY_BUFFER_BINDING_AMD = 0x9193; + + private AMDQueryBufferObject() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDSamplePositions.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDSamplePositions.java new file mode 100644 index 00000000..d3a3b033 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDSamplePositions.java @@ -0,0 +1,64 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the AMD_sample_positions extension. + * + *This extension provides a mechanism to explicitly set sample positions for a FBO with multi-sampled attachments. The FBO will use identical sample + * locations for all pixels in each attachment. This forces TEXTURE_FIXED_SAMPLE_LOCATIONS to TRUE if a multi-sampled texture is specified using + * TexImage2DMultisample or TexImage3DMultisample. That is, using GetTexLevelParameter to query TEXTURE_FIXED_SAMPLE_LOCATIONS will always return TRUE if + * the mechanism is explicitly used to set the sample positions.
+ * + *Requires {@link GL32 OpenGL 3.2} or {@link EXTFramebufferMultisample EXT_framebuffer_multisample}.
+ */ +public class AMDSamplePositions { + + /** Accepted by the {@code pname} parameter of GetFloatv. */ + public static final int GL_SUBSAMPLE_DISTANCE_AMD = 0x883F; + + static { GL.initialize(); } + + protected AMDSamplePositions() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glSetMultisamplefvAMD + ); + } + + // --- [ glSetMultisamplefvAMD ] --- + + public static native void nglSetMultisamplefvAMD(int pname, int index, long val); + + public static void glSetMultisamplefvAMD(@NativeType("GLenum") int pname, @NativeType("GLuint") int index, @NativeType("GLfloat const *") FloatBuffer val) { + if (CHECKS) { + check(val, 2); + } + nglSetMultisamplefvAMD(pname, index, memAddress(val)); + } + + /** Array version of: {@link #glSetMultisamplefvAMD SetMultisamplefvAMD} */ + public static void glSetMultisamplefvAMD(@NativeType("GLenum") int pname, @NativeType("GLuint") int index, @NativeType("GLfloat const *") float[] val) { + long __functionAddress = GL.getICD().glSetMultisamplefvAMD; + if (CHECKS) { + check(__functionAddress); + check(val, 2); + } + callPV(pname, index, val, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDSeamlessCubemapPerTexture.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDSeamlessCubemapPerTexture.java new file mode 100644 index 00000000..95f7d4b7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDSeamlessCubemapPerTexture.java @@ -0,0 +1,34 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the AMD_seamless_cubemap_per_texture extension. + * + *In unextended OpenGL, cube maps are treated as sets of six, independent texture images. Once a face is selected from the set, it is treated exactly as + * any other two-dimensional texture would be. When sampling linearly from the texture, all of the individual texels that would be used to to create the + * final, bilinear sample values are taken from the same cube face. The normal, two-dimensional texture coordinate wrapping modes are honored. This + * sometimes causes seams to appear in cube maps.
+ * + *ARB_seamless_cube_map addresses this issue by providing a mechanism whereby an implementation could take each of the taps of a bilinear sample from a + * different face, spanning face boundaries and providing seamless filtering from cube map textures. However, in ARB_seamless_cube_map, this feature was + * exposed as a global state, affecting all bound cube map textures. It was not possible to mix seamless and per-face cube map sampling modes during + * multisampling. Furthermore, if an application included cube maps that were meant to be sampled seamlessly and non-seamlessly, it would have to track + * this state and enable or disable seamless cube map sampling as needed.
+ * + *This extension addresses this issue and provides an orthogonal method for allowing an implementation to provide a per-texture setting for enabling + * seamless sampling from cube maps.
+ * + *Requires {@link ARBTextureCubeMap ARB_texture_cube_map}.
+ */ +public final class AMDSeamlessCubemapPerTexture { + + /** Accepted by the {@code pname} parameter of TexParameterf, TexParameteri, TexParameterfv, TexParameteriv, GetTexParameterfv, and GetTexParameteriv. */ + public static final int GL_TEXTURE_CUBE_MAP_SEAMLESS = 0x884F; + + private AMDSeamlessCubemapPerTexture() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDSparseTexture.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDSparseTexture.java new file mode 100644 index 00000000..0f220e0a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDSparseTexture.java @@ -0,0 +1,70 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the AMD_sparse_texture extension. + * + *Recent advances in application complexity and a desire for higher resolutions have pushed texture sizes up considerably. Often, the amount of physical + * memory available to a graphics processor is a limiting factor in the performance of texture-heavy applications. Once the available physical memory is + * exhausted, paging may occur bringing performance down considerably - or worse, the application may fail. Nevertheless, the amount of address space + * available to the graphics processor has increased to the point where many gigabytes - or even terabytes of address space may be usable even though that + * amount of physical memory is not present.
+ * + *This extension allows the separation of the graphics processor's address space (reservation) from the requirement that all textures must be physically + * backed (commitment). This exposes a limited form of virtualization for textures. Use cases include sparse (or partially resident) textures, texture + * paging, on-demand and delayed loading of texture assets and application controlled level of detail.
+ * + *Requires {@link GL20 OpenGL 2.0} or {@link ARBFragmentShader ARB_fragment_shader}.
+ */ +public class AMDSparseTexture { + + /** Accepted by the {@code flags} parameter to TexStorageSparseAMD and TextureStorageSparseAMD. */ + public static final int GL_TEXTURE_STORAGE_SPARSE_BIT_AMD = 0x1; + + /** Accepted by the {@code pname} parameter to GetInternalformativ. */ + public static final int + GL_VIRTUAL_PAGE_SIZE_X_AMD = 0x9195, + GL_VIRTUAL_PAGE_SIZE_Y_AMD = 0x9196, + GL_VIRTUAL_PAGE_SIZE_Z_AMD = 0x9197; + + /** Accepted by the {@code pname} parameter to GetIntegerv, GetFloatv, GetDoublev, GetInteger64v, and GetBooleanv. */ + public static final int + GL_MAX_SPARSE_TEXTURE_SIZE_AMD = 0x9198, + GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD = 0x9199, + GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS = 0x919A; + + /** Accepted by the {@code pname} parameter of GetTexParameter{if}v. */ + public static final int GL_MIN_SPARSE_LEVEL_AMD = 0x919B; + + /** Accepted by the {@code pname} parameter of TexParameter{if}{v} and GetTexParameter{if}v. */ + public static final int GL_MIN_LOD_WARNING_AMD = 0x919C; + + static { GL.initialize(); } + + protected AMDSparseTexture() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glTexStorageSparseAMD, caps.glTextureStorageSparseAMD + ); + } + + // --- [ glTexStorageSparseAMD ] --- + + public static native void glTexStorageSparseAMD(@NativeType("GLenum") int target, @NativeType("GLenum") int internalFormat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth, @NativeType("GLsizei") int layers, @NativeType("GLbitfield") int flags); + + // --- [ glTextureStorageSparseAMD ] --- + + public static native void glTextureStorageSparseAMD(@NativeType("GLuint") int texture, @NativeType("GLenum") int target, @NativeType("GLenum") int internalFormat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth, @NativeType("GLsizei") int layers, @NativeType("GLbitfield") int flags); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDStencilOperationExtended.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDStencilOperationExtended.java new file mode 100644 index 00000000..201605cb --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDStencilOperationExtended.java @@ -0,0 +1,52 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the AMD_stencil_operation_extended extension. + * + *Stencil buffers are special buffers that allow tests to be made against an incoming value and action taken based on that value. The stencil buffer is + * updated during rasterization, and the operation used to update the stencil buffer is chosen based on whether the fragment passes the stencil test, and + * if it does, whether it passes the depth test. Traditional OpenGL includes support for several primitive operations, such as incrementing, or clearing + * the content of the stencil buffer, or replacing it with a specified reference value.
+ * + *This extension adds support for an additional set of operations that may be performed on the stencil buffer under each circumstance. Additionally, this + * extension separates the value used as the source for stencil operations from the reference value, allowing different values to be used in the stencil + * test, and in the update of the stencil buffer.
+ */ +public class AMDStencilOperationExtended { + + /** Accepted by the {@code sfail}, {@code dpfail} and {@code dppass} parameters of StencilOp and StencilOpSeparate. */ + public static final int + GL_SET_AMD = 0x874A, + GL_REPLACE_VALUE_AMD = 0x874B; + + /** Accepted by the {@code param} parameter of GetIntegerv, GetFloatv, GetBooleanv GetDoublev and GetInteger64v. */ + public static final int + GL_STENCIL_OP_VALUE_AMD = 0x874C, + GL_STENCIL_BACK_OP_VALUE_AMD = 0x874D; + + static { GL.initialize(); } + + protected AMDStencilOperationExtended() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glStencilOpValueAMD + ); + } + + // --- [ glStencilOpValueAMD ] --- + + public static native void glStencilOpValueAMD(@NativeType("GLenum") int face, @NativeType("GLuint") int value); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDTransformFeedback4.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDTransformFeedback4.java new file mode 100644 index 00000000..a73175a5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDTransformFeedback4.java @@ -0,0 +1,23 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the AMD_transform_feedback4 extension. + * + *This extension enhances transform feedback in two significant ways. First, it allows multiple transform feedback streams to be captured, each with its + * own, independent primitve type. Second, it allows any combination of streams to be rasterized.
+ * + *Requires {@link GL40 OpenGL 4.0} or {@link ARBTransformFeedback3 ARB_transform_feedback3}.
+ */ +public final class AMDTransformFeedback4 { + + /** Accepted by the {@code pname} argument to Enablei. Disablei and IsEnabledi. */ + public static final int GL_STREAM_RASTERIZATION_AMD = 0x91A0; + + private AMDTransformFeedback4() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDVertexShaderTessellator.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDVertexShaderTessellator.java new file mode 100644 index 00000000..34fa9e55 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/AMDVertexShaderTessellator.java @@ -0,0 +1,108 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the AMD_vertex_shader_tessellator extension. + * + *The vertex shader tessellator gives new flexibility to the shader author to shade at a tessellated vertex, rather than just at a provided vertex.
+ * + *In unextended vertex shading, the built-in attributes such as gl_Vertex, gl_Normal, and gl_MultiTexcoord0, together with the user defined attributes, + * are system provided values which are initialized prior to vertex shader invocation.
+ * + *With vertex shading tessellation, additional vertex shader special values are available:
+ * + *
+ * ivec3 gl_VertexTriangleIndex; // indices of the three control
+ * // points for the vertex
+ * vec3 gl_BarycentricCoord; // barycentric coordinates
+ * // of the vertex
+ *
+ * i o
+ * |\
+ * | \
+ * *--*
+ * |\ |\
+ * | \| \
+ * *--*--*
+ * |\ |\ |\
+ * | \| \| \
+ * j o--*--*--o k
+ *
+ * Figure 1 A Tessellated Triangle
+ * o = control point (and tessellated vertex)
+ * * = tessellated vertex
+ *
+ * ivec4 gl_VertexQuadIndex; // indices for the four control
+ * // points for the vertex
+ * vec2 gl_UVCoord; // UV coordinates of the vertex
+ *
+ * i o--*--*--o k
+ * |\ |\ |\ |
+ * | \| \| \|
+ * *--*--*--*
+ * |\ |\ |\ |
+ * | \| \| \|
+ * *--*--*--*
+ * |\ |\ |\ |
+ * | \| \| \|
+ * j o--*--*--o l
+ *
+ * Figure 2 A Tessellated Quad
+ * o = control point (and tessellated vertex)
+ * * = tessellated vertexWhen this extension is enabled, conventional built-in attributes and user defined attributes are uninitialized. The shader writer is responsible for + * explicitly fetching all other vertex data either from textures, uniform buffers, or vertex buffers.
+ * + *The shader writer is further responsible for interpolating the vertex data at the given barycentric coordinates or uv coordinates of the vertex.
+ * + *Requires {@link GL20 OpenGL 2.0}.
+ */ +public class AMDVertexShaderTessellator { + + /** Returned by the {@code type} parameter of GetActiveUniform. */ + public static final int + GL_SAMPLER_BUFFER_AMD = 0x9001, + GL_INT_SAMPLER_BUFFER_AMD = 0x9002, + GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD = 0x9003; + + /** Accepted by TessellationModeAMD. */ + public static final int + GL_DISCRETE_AMD = 0x9006, + GL_CONTINUOUS_AMD = 0x9007; + + /** Accepted by GetIntegerv. */ + public static final int GL_TESSELLATION_MODE_AMD = 0x9004; + + /** Accepted by GetFloatv. */ + public static final int GL_TESSELLATION_FACTOR_AMD = 0x9005; + + static { GL.initialize(); } + + protected AMDVertexShaderTessellator() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glTessellationFactorAMD, caps.glTessellationModeAMD + ); + } + + // --- [ glTessellationFactorAMD ] --- + + public static native void glTessellationFactorAMD(@NativeType("GLfloat") float factor); + + // --- [ glTessellationModeAMD ] --- + + public static native void glTessellationModeAMD(@NativeType("GLenum") int mode); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBBaseInstance.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBBaseInstance.java new file mode 100644 index 00000000..567e1157 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBBaseInstance.java @@ -0,0 +1,213 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_base_instance extension. + * + *This extension allows the offset within buffer objects used for instanced rendering to be specified. This is congruent with the {@code first} parameter
+ * in {@link GL11C#glDrawArrays DrawArrays} and the {@code basevertex} parameter in {@link GL11C#glDrawElements DrawElements}. When instanced rendering is performed (for example, through
+ * {@link GL31C#glDrawArraysInstanced DrawArraysInstanced}), instanced vertex attributes whose vertex attribute divisors are non-zero are fetched from enabled vertex arrays
+ * per-instance rather than per-vertex. However, in unextended OpenGL, there is no way to define the offset into those arrays from which the attributes are
+ * fetched. This extension adds that offset in the form of a {@code
The {@code baseinstance} parameter is added to the index of the array element, after division by the vertex attribute divisor. This allows several sets
+ * of instanced vertex attribute data to be stored in a single vertex array, and the base offset of that data to be specified for each draw. Further, this
+ * extension exposes the {@code
Requires {@link GL31 OpenGL 3.1} or {@link ARBDrawInstanced ARB_draw_instanced}. Promoted to core in {@link GL42 OpenGL 4.2}.
+ */ +public class ARBBaseInstance { + + static { GL.initialize(); } + + protected ARBBaseInstance() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDrawArraysInstancedBaseInstance, caps.glDrawElementsInstancedBaseInstance, caps.glDrawElementsInstancedBaseVertexBaseInstance + ); + } + + // --- [ glDrawArraysInstancedBaseInstance ] --- + + /** + * Draws multiple instances of a range of elements with an offset applied to instanced attributes. + * + * @param mode what kind of primitives to render. One of:| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
This extension allows OpenGL applications to access texture objects in shaders without first binding each texture to one of a limited number of texture + * image units. Using this extension, an application can query a 64-bit unsigned integer texture handle for each texture that it wants to access and then + * use that handle directly in GLSL or assembly-based shaders. The ability to access textures without having to bind and/or re-bind them is similar to the + * capability provided by the {@link NVShaderBufferLoad NV_shader_buffer_load} extension that allows shaders to access buffer objects without binding them. In both cases, + * these extensions significantly reduce the amount of API and internal GL driver overhead needed to manage resource bindings.
+ * + *This extension also provides similar capability for the image load, store, and atomic functionality provided by OpenGL 4.2 and the + * {@link ARBShaderImageLoadStore ARB_shader_image_load_store} and {@link EXTShaderImageLoadStore EXT_shader_image_load_store} extensions, where a texture can be accessed without first binding it to an + * image unit. An image handle can be extracted from a texture object using an API with a set of parameters similar to those for + * {@link EXTShaderImageLoadStore#glBindImageTextureEXT BindImageTextureEXT}.
+ * + *This extension adds no new data types to GLSL. Instead, it uses existing sampler and image data types and allows them to be populated with texture and + * image handles. This extension does permit sampler and image data types to be used in more contexts than in unextended GLSL 4.00. In particular, sampler + * and image types may be used as shader inputs/outputs, temporary variables, and uniform block members, and may be assigned to by shader code. + * Constructors are provided to convert unsigned integer values to and from sampler and image data types. Additionally, new APIs are provided to load + * values for sampler and image uniforms with 64-bit handle inputs. The use of existing integer-based Uniform* APIs is still permitted, in which case the + * integer specified will identify a texture image or image unit. For samplers and images with values specified as texture image or image units, the GL + * implemenation will translate the unit number to an internal handle as required.
+ * + *To access texture or image resources using handles, the handles must first be made resident. Accessing a texture or image by handle without first + * making it resident can result in undefined results, including program termination. Since the amount of texture memory required by an application may + * exceed the amount of memory available to the system, this extension provides API calls allowing applications to manage overall texture memory + * consumption by making a texture resident and non-resident as required.
+ * + *Requires {@link GL40 OpenGL 4.0}.
+ */ +public class ARBBindlessTexture { + + /** Accepted by the {@code type} parameter of VertexAttribLPointer. */ + public static final int GL_UNSIGNED_INT64_ARB = 0x140F; + + static { GL.initialize(); } + + protected ARBBindlessTexture() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetTextureHandleARB, caps.glGetTextureSamplerHandleARB, caps.glMakeTextureHandleResidentARB, caps.glMakeTextureHandleNonResidentARB, + caps.glGetImageHandleARB, caps.glMakeImageHandleResidentARB, caps.glMakeImageHandleNonResidentARB, caps.glUniformHandleui64ARB, + caps.glUniformHandleui64vARB, caps.glProgramUniformHandleui64ARB, caps.glProgramUniformHandleui64vARB, caps.glIsTextureHandleResidentARB, + caps.glIsImageHandleResidentARB, caps.glVertexAttribL1ui64ARB, caps.glVertexAttribL1ui64vARB, caps.glGetVertexAttribLui64vARB + ); + } + + // --- [ glGetTextureHandleARB ] --- + + /** + * Creates a texture handle using the current state of the texture named {@code texture}, including any embedded sampler state. See + * {@link #glGetTextureSamplerHandleARB GetTextureSamplerHandleARB} for details. + * + * @param texture the texture object + */ + @NativeType("GLuint64") + public static native long glGetTextureHandleARB(@NativeType("GLuint") int texture); + + // --- [ glGetTextureSamplerHandleARB ] --- + + /** + * Creates a texture handle using the current non-sampler state from the texture named {@code texture} and the sampler state from the sampler object + * {@code sampler}. In both cases, a 64-bit unsigned integer handle is returned. The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated if {@code texture} is zero or is + * not the name of an existing texture object or if {@code sampler} is zero or is not the name of an existing sampler object. The error + * {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if the texture object {@code texture} is not complete. If an error occurs, a handle of zero is returned. + * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if the border color (taken from the embedded sampler for GetTextureHandleARB or from the {@code sampler} + * for GetTextureSamplerHandleARB) is not one of the following allowed values. If the texture's base internal format is signed or unsigned integer, allowed + * values are (0,0,0,0), (0,0,0,1), (1,1,1,0), and (1,1,1,1). If the base internal format is not integer, allowed values are (0.0,0.0,0.0,0.0), + * (0.0,0.0,0.0,1.0), (1.0,1.0,1.0,0.0), and (1.0,1.0,1.0,1.0).
+ * + *The handle for each texture or texture/sampler pair is unique; the same handle will be returned if GetTextureHandleARB is called multiple times for the + * same texture or if GetTextureSamplerHandleARB is called multiple times for the same texture/sampler pair.
+ * + *When a texture object is referenced by one or more texture handles, the texture parameters of the object may not be changed, and the size and format of + * the images in the texture object may not be re-specified. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if the functions TexImage*, CopyTexImage*, + * CompressedTexImage*, TexBuffer*, or TexParameter* are called to modify a texture object referenced by one or more texture handles. The contents of the + * images in a texture object may still be updated via commands such as TexSubImage*, CopyTexSubImage*, and CompressedTexSubImage*, and by rendering to a + * framebuffer object, even if the texture object is referenced by one or more texture handles.
+ * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated by {@link GL15C#glBufferData BufferData} if it is called to modify a buffer object bound to a buffer texture while that + * texture object is referenced by one or more texture handles. The contents of the buffer object may still be updated via buffer update commands such as + * {@link GL15C#glBufferSubData BufferSubData} and MapBuffer*, or via the texture update commands, even if the buffer is bound to a texture while that buffer texture object is + * referenced by one or more texture handles.
+ * + *When a sampler object is referenced by one or more texture handles, the sampler parameters of the object may not be changed. The error + * {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated when calling SamplerParameter* functions to modify a sampler object referenced by one or more texture handles.
+ * + * @param texture the texture object + * @param sampler the sampler object + */ + @NativeType("GLuint64") + public static native long glGetTextureSamplerHandleARB(@NativeType("GLuint") int texture, @NativeType("GLuint") int sampler); + + // --- [ glMakeTextureHandleResidentARB ] --- + + /** + * Make a texture handle resident, so that it is accessible to shaders for texture mapping operations. + * + *While the texture handle is resident, it may be used in texture mapping operations. If a shader attempts to perform a texture mapping operation using a + * handle that is not resident, the results of that operation are undefined and may lead to application termination. When a texture handle is resident, the + * texture it references is also considered resident for the purposes of the {@link GL11#glAreTexturesResident AreTexturesResident} command. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is + * generated if {@code handle} is not a valid texture handle, or if {@code handle} is already resident in the current GL context.
+ * + * @param handle the texture handle + */ + public static native void glMakeTextureHandleResidentARB(@NativeType("GLuint64") long handle); + + // --- [ glMakeTextureHandleNonResidentARB ] --- + + /** + * Makes a texture handle inaccessible to shaders. + * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if {@code handle} is not a valid texture handle, or if {@code handle} is not resident in the current GL + * context.
+ * + * @param handle the texture handle + */ + public static native void glMakeTextureHandleNonResidentARB(@NativeType("GLuint64") long handle); + + // --- [ glGetImageHandleARB ] --- + + /** + * Creates and returns an image handle for level {@code level} of the texture named {@code texture}. If {@code layered} is {@link GL11#GL_TRUE TRUE}, a handle is created + * for the entire texture level. If {@code layered} is {@link GL11#GL_FALSE FALSE}, a handle is created for only the layer {@code layer} of the texture level. + * {@code format} specifies a format used to interpret the texels of the image when used for image loads, stores, and atomics, and has the same meaning as + * the {@code format} parameter of {@link EXTShaderImageLoadStore#glBindImageTextureEXT BindImageTextureEXT}. A 64-bit unsigned integer handle is returned if the command succeeds; otherwise, zero is + * returned. + * + *The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated by GetImageHandleARB if:
+ * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated by GetImageHandleARB if:
+ * + *When a texture object is referenced by one or more image handles, the texture parameters of the object may not be changed, and the size and format of + * the images in the texture object may not be re-specified. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated when calling TexImage*, CopyTexImage*, + * CompressedTexImage*, TexBuffer*, or TexParameter* functions while a texture object is referenced by one or more image handles. The contents of the + * images in a texture object may still be updated via commands such as TexSubImage*, CopyTexSubImage*, and CompressedTexSubImage*, and by rendering to a + * framebuffer object, even if the texture object is referenced by one or more image handles.
+ * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated by {@link GL15C#glBufferData BufferData} if it is called to modify a buffer object bound to a buffer texture while that texture + * object is referenced by one or more image handles. The contents of the buffer object may still be updated via buffer update commands such as + * {@link GL15C#glBufferSubData BufferSubData} and MapBuffer*, or via the texture update commands, even if the buffer is bound to a texture while that buffer texture object is + * referenced by one or more image handles.
+ * + *The handle returned for each combination of {@code texture}, {@code level}, {@code layered}, {@code layer}, and {@code format} is unique; the same + * handle will be returned if GetImageHandleARB is called multiple times with the same parameters.
+ * + * @param texture the texture object + * @param level the texture level + * @param layered the layered flag + * @param layer the texture layer + * @param format the texture format + */ + @NativeType("GLuint64") + public static native long glGetImageHandleARB(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLboolean") boolean layered, @NativeType("GLint") int layer, @NativeType("GLenum") int format); + + // --- [ glMakeImageHandleResidentARB ] --- + + /** + * Makes an image handle resident, so that it is accessible to shaders for image loads, stores, and atomic operations. + * + *{@code access} specifies whether the texture bound to the image handle will be treated as {@link GL15#GL_READ_ONLY READ_ONLY}, {@link GL15#GL_WRITE_ONLY WRITE_ONLY}, or {@link GL15#GL_READ_WRITE READ_WRITE}. If a + * shader reads from an image handle made resident as {@link GL15#GL_WRITE_ONLY WRITE_ONLY}, or writes to an image handle made resident as {@link GL15#GL_READ_ONLY READ_ONLY}, the results of that + * shader operation are undefined and may lead to application termination. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if {@code handle} is not a valid + * image handle, or if {@code handle} is already resident in the current GL context.
+ * + *While the image handle is resident, it may be used in image load, store, and atomic operations. If a shader attempts to perform an image operation using + * a handle that is not resident, the results of that operation are undefined and may lead to application termination. When an image handle is resident, + * the texture it references is not necessarily considered resident for the purposes of the {@link GL11#glAreTexturesResident AreTexturesResident} command.
+ * + * @param handle the image handle + * @param access the access type. One of:| {@link GL15#GL_READ_ONLY READ_ONLY} | {@link GL15#GL_WRITE_ONLY WRITE_ONLY} | {@link GL15#GL_READ_WRITE READ_WRITE} |
Traditional OpenGL includes fixed-function blending that combines source colors with the existing content of a render buffer in a variety of ways. A + * number of extensions have enhanced this functionality by adding further sources of blending weights and methods to combine them. However, the inputs to + * the fixed-function blending units are constrained to a source color (as output from fragment shading), destination color (as the current content of the + * frame buffer) or constants that may be used in their place.
+ * + *This extension adds new blending functions whereby a fragment shader may output two colors, one of which is treated as the source color, and the other + * used as a blending factor for either source or destination colors. Furthermore, this extension increases orthogonality by allowing the + * {@link GL11#GL_SRC_ALPHA_SATURATE SRC_ALPHA_SATURATE} function to be used as the destination weight.
+ * + *Requires {@link ARBFragmentShader ARB_fragment_shader} and {@link EXTGPUShader4 EXT_gpu_shader4}. Promoted to core in {@link GL33 OpenGL 3.3}.
+ */ +public class ARBBlendFuncExtended { + + /** + * Accepted by the {@code src} and {@code dst} parameters of BlendFunc and BlendFunci, and by the {@code srcRGB}, {@code dstRGB}, {@code srcAlpha} and + * {@code dstAlpha} parameters of BlendFuncSeparate and BlendFuncSeparatei. + */ + public static final int + GL_SRC1_COLOR = 0x88F9, + GL_ONE_MINUS_SRC1_COLOR = 0x88FA, + GL_ONE_MINUS_SRC1_ALPHA = 0x88FB; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv and GetDoublev. */ + public static final int GL_MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC; + + static { GL.initialize(); } + + protected ARBBlendFuncExtended() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBindFragDataLocationIndexed, caps.glGetFragDataIndex + ); + } + + // --- [ glBindFragDataLocationIndexed ] --- + + /** Unsafe version of: {@link #glBindFragDataLocationIndexed BindFragDataLocationIndexed} */ + public static void nglBindFragDataLocationIndexed(int program, int colorNumber, int index, long name) { + GL33C.nglBindFragDataLocationIndexed(program, colorNumber, index, name); + } + + /** + * Binds a user-defined varying out variable to a fragment shader color number and index. + * + * @param program the name of the program containing varying out variable whose binding to modify + * @param colorNumber the color number to bind the user-defined varying out variable to + * @param index the index of the color input to bind the user-defined varying out variable to + * @param name the name of the user-defined varying out variable whose binding to modify + */ + public static void glBindFragDataLocationIndexed(@NativeType("GLuint") int program, @NativeType("GLuint") int colorNumber, @NativeType("GLuint") int index, @NativeType("GLchar const *") ByteBuffer name) { + GL33C.glBindFragDataLocationIndexed(program, colorNumber, index, name); + } + + /** + * Binds a user-defined varying out variable to a fragment shader color number and index. + * + * @param program the name of the program containing varying out variable whose binding to modify + * @param colorNumber the color number to bind the user-defined varying out variable to + * @param index the index of the color input to bind the user-defined varying out variable to + * @param name the name of the user-defined varying out variable whose binding to modify + */ + public static void glBindFragDataLocationIndexed(@NativeType("GLuint") int program, @NativeType("GLuint") int colorNumber, @NativeType("GLuint") int index, @NativeType("GLchar const *") CharSequence name) { + GL33C.glBindFragDataLocationIndexed(program, colorNumber, index, name); + } + + // --- [ glGetFragDataIndex ] --- + + /** Unsafe version of: {@link #glGetFragDataIndex GetFragDataIndex} */ + public static int nglGetFragDataIndex(int program, long name) { + return GL33C.nglGetFragDataIndex(program, name); + } + + /** + * Queries the bindings of color indices to user-defined varying out variables. + * + * @param program the name of the program containing varying out variable whose binding to query + * @param name the name of the user-defined varying out variable whose index to query + */ + @NativeType("GLint") + public static int glGetFragDataIndex(@NativeType("GLuint") int program, @NativeType("GLchar const *") ByteBuffer name) { + return GL33C.glGetFragDataIndex(program, name); + } + + /** + * Queries the bindings of color indices to user-defined varying out variables. + * + * @param program the name of the program containing varying out variable whose binding to query + * @param name the name of the user-defined varying out variable whose index to query + */ + @NativeType("GLint") + public static int glGetFragDataIndex(@NativeType("GLuint") int program, @NativeType("GLchar const *") CharSequence name) { + return GL33C.glGetFragDataIndex(program, name); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBBufferStorage.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBBufferStorage.java new file mode 100644 index 00000000..6965f99f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBBufferStorage.java @@ -0,0 +1,748 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the ARB_buffer_storage extension. + * + *OpenGL has long supported buffer objects as a means of storing data that may be used to source vertex attributes, pixel data for textures, uniforms and + * other elements. In un-extended GL, buffer data stores are mutable - that is, they may be de-allocated or resized while they are in use. The + * {@link ARBTextureStorage ARB_texture_storage} extension added immutable storage for texture object (and was subsequently incorporated into OpenGL 4.2). This extension + * further applies the concept of immutable storage to buffer objects. If an implementation is aware of a buffer's immutability, it may be able to make + * certain assumptions or apply particular optimizations in order to increase performance or reliability.
+ * + *Furthermore, this extension allows applications to pass additional information about a requested allocation to the implementation which it may use to + * select memory heaps, caching behavior or allocation strategies.
+ * + *Finally, this extension introduces the concept of persistent client mappings of buffer objects, which allow clients to retain pointers to a buffer's + * data store returned as the result of a mapping, and to issue drawing commands while those mappings are in place.
+ * + *Promoted to core in {@link GL44 OpenGL 4.4}.
+ */ +public class ARBBufferStorage { + + /** Accepted in the {@code flags} parameter of {@link #glBufferStorage BufferStorage} and {@link #glNamedBufferStorageEXT NamedBufferStorageEXT}. */ + public static final int + GL_MAP_PERSISTENT_BIT = 0x40, + GL_MAP_COHERENT_BIT = 0x80, + GL_DYNAMIC_STORAGE_BIT = 0x100, + GL_CLIENT_STORAGE_BIT = 0x200; + + /** Accepted by the {@code pname} parameter of {@code GetBufferParameter{i|i64}v}. */ + public static final int + GL_BUFFER_IMMUTABLE_STORAGE = 0x821F, + GL_BUFFER_STORAGE_FLAGS = 0x8220; + + /** Accepted by the {@code barriers} parameter of {@link GL42C#glMemoryBarrier MemoryBarrier}. */ + public static final int GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT = 0x4000; + + static { GL.initialize(); } + + protected ARBBufferStorage() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetThe data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44C#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("GLsizeiptr") long size, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, size, flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44C#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") ByteBuffer data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44C#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") ShortBuffer data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44C#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") IntBuffer data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44C#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") FloatBuffer data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44C#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") DoubleBuffer data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + // --- [ glNamedBufferStorageEXT ] --- + + /** + * Unsafe version of: {@link #glNamedBufferStorageEXT NamedBufferStorageEXT} + * + * @param size the size of the data store in basic machine units + */ + public static native void nglNamedBufferStorageEXT(int buffer, long size, long data, int flags); + + /** + * Behaves similarly to {@link #glBufferStorage BufferStorage}, except that the buffer whose storage is to be defined is specified by {@code buffer} rather than by the current + * binding to {@code target}. + * + * @param buffer the buffer object + * @param size the size of the data store in basic machine units + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link #GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glNamedBufferStorageEXT(@NativeType("GLuint") int buffer, @NativeType("GLsizeiptr") long size, @NativeType("GLbitfield") int flags) { + nglNamedBufferStorageEXT(buffer, size, NULL, flags); + } + + /** + * Behaves similarly to {@link #glBufferStorage BufferStorage}, except that the buffer whose storage is to be defined is specified by {@code buffer} rather than by the current + * binding to {@code target}. + * + * @param buffer the buffer object + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link #GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glNamedBufferStorageEXT(@NativeType("GLuint") int buffer, @NativeType("void const *") ByteBuffer data, @NativeType("GLbitfield") int flags) { + nglNamedBufferStorageEXT(buffer, data.remaining(), memAddress(data), flags); + } + + /** + * Behaves similarly to {@link #glBufferStorage BufferStorage}, except that the buffer whose storage is to be defined is specified by {@code buffer} rather than by the current + * binding to {@code target}. + * + * @param buffer the buffer object + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link #GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glNamedBufferStorageEXT(@NativeType("GLuint") int buffer, @NativeType("void const *") ShortBuffer data, @NativeType("GLbitfield") int flags) { + nglNamedBufferStorageEXT(buffer, Integer.toUnsignedLong(data.remaining()) << 1, memAddress(data), flags); + } + + /** + * Behaves similarly to {@link #glBufferStorage BufferStorage}, except that the buffer whose storage is to be defined is specified by {@code buffer} rather than by the current + * binding to {@code target}. + * + * @param buffer the buffer object + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link #GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glNamedBufferStorageEXT(@NativeType("GLuint") int buffer, @NativeType("void const *") IntBuffer data, @NativeType("GLbitfield") int flags) { + nglNamedBufferStorageEXT(buffer, Integer.toUnsignedLong(data.remaining()) << 2, memAddress(data), flags); + } + + /** + * Behaves similarly to {@link #glBufferStorage BufferStorage}, except that the buffer whose storage is to be defined is specified by {@code buffer} rather than by the current + * binding to {@code target}. + * + * @param buffer the buffer object + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link #GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glNamedBufferStorageEXT(@NativeType("GLuint") int buffer, @NativeType("void const *") FloatBuffer data, @NativeType("GLbitfield") int flags) { + nglNamedBufferStorageEXT(buffer, Integer.toUnsignedLong(data.remaining()) << 2, memAddress(data), flags); + } + + /** + * Behaves similarly to {@link #glBufferStorage BufferStorage}, except that the buffer whose storage is to be defined is specified by {@code buffer} rather than by the current + * binding to {@code target}. + * + * @param buffer the buffer object + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link #GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glNamedBufferStorageEXT(@NativeType("GLuint") int buffer, @NativeType("void const *") DoubleBuffer data, @NativeType("GLbitfield") int flags) { + nglNamedBufferStorageEXT(buffer, Integer.toUnsignedLong(data.remaining()) << 3, memAddress(data), flags); + } + + /** Array version of: {@link #glBufferStorage BufferStorage} */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") short[] data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** Array version of: {@link #glBufferStorage BufferStorage} */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") int[] data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** Array version of: {@link #glBufferStorage BufferStorage} */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") float[] data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** Array version of: {@link #glBufferStorage BufferStorage} */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") double[] data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** Array version of: {@link #glNamedBufferStorageEXT NamedBufferStorageEXT} */ + public static void glNamedBufferStorageEXT(@NativeType("GLuint") int buffer, @NativeType("void const *") short[] data, @NativeType("GLbitfield") int flags) { + long __functionAddress = GL.getICD().glNamedBufferStorageEXT; + if (CHECKS) { + check(__functionAddress); + } + callPPV(buffer, Integer.toUnsignedLong(data.length) << 1, data, flags, __functionAddress); + } + + /** Array version of: {@link #glNamedBufferStorageEXT NamedBufferStorageEXT} */ + public static void glNamedBufferStorageEXT(@NativeType("GLuint") int buffer, @NativeType("void const *") int[] data, @NativeType("GLbitfield") int flags) { + long __functionAddress = GL.getICD().glNamedBufferStorageEXT; + if (CHECKS) { + check(__functionAddress); + } + callPPV(buffer, Integer.toUnsignedLong(data.length) << 2, data, flags, __functionAddress); + } + + /** Array version of: {@link #glNamedBufferStorageEXT NamedBufferStorageEXT} */ + public static void glNamedBufferStorageEXT(@NativeType("GLuint") int buffer, @NativeType("void const *") float[] data, @NativeType("GLbitfield") int flags) { + long __functionAddress = GL.getICD().glNamedBufferStorageEXT; + if (CHECKS) { + check(__functionAddress); + } + callPPV(buffer, Integer.toUnsignedLong(data.length) << 2, data, flags, __functionAddress); + } + + /** Array version of: {@link #glNamedBufferStorageEXT NamedBufferStorageEXT} */ + public static void glNamedBufferStorageEXT(@NativeType("GLuint") int buffer, @NativeType("void const *") double[] data, @NativeType("GLbitfield") int flags) { + long __functionAddress = GL.getICD().glNamedBufferStorageEXT; + if (CHECKS) { + check(__functionAddress); + } + callPPV(buffer, Integer.toUnsignedLong(data.length) << 3, data, flags, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBClearBufferObject.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBClearBufferObject.java new file mode 100644 index 00000000..d7ed5b1c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBClearBufferObject.java @@ -0,0 +1,410 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the ARB_clear_buffer_object extension. + * + *Buffer objects are fundamental to the operation of OpenGL. Buffers are used as a source of data for vertices and indices, read through buffer textures + * in shaders, used to transfer texture and image data into and out of textures and framebuffers, and may be written to by operations such as transform + * feedback. OpenGL contains mechanisms to copy sections of buffers from one to another, but it has no mechanism to initialize the content of a buffer to a + * known value. In effect, it has {@code memcpy}, but not {@code memset}.
+ * + *This extension adds such a mechanism and has several use cases. Examples include clearing a pixel unpack buffer before transferring data to a texture or + * resetting buffer data to a known value before sparse updates through shader image stores or transform feedback.
+ * + *Requires {@link GL15 OpenGL 1.5}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public class ARBClearBufferObject { + + static { GL.initialize(); } + + protected ARBClearBufferObject() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.Set| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
Texture objects are fundamental to the operation of OpenGL. They are used as a source for texture sampling and destination for rendering as well as + * being accessed in shaders for image load/store operations. It is also possible to invalidate the contents of a texture. It is currently only possible to + * set texture image data to known values by uploading some or all of a image array from application memory or by attaching it to a framebuffer object and + * using {@link GL11C#glClear Clear} or the {@link GL30 OpenGL 3.0} ClearBuffer commands.
+ * + *Both uploading initial texture data and clearing by attaching to a framebuffer have potential disadvantages when one simply wants to initialize texture + * data to a known value. Uploading initial data requires the application to allocate a (potentially large) chunk of memory and transferring that to the + * GL. This can be a costly operation both in terms of memory bandwidth and power usage. Alternatively, attaching a texture level to a framebuffer to clear + * it may not be possible if the texture format isn't supported for rendering, or even if it is, attaching the image to a framebuffer object may cause the + * texture to be allocated in certain types of memory, which it may otherwise not need to be placed in.
+ * + *This extension solves these problems by providing a mechanism whereby the contents of a texture image array can be set to known values by using the + * {@link #glClearTexImage ClearTexImage} or {@link #glClearTexSubImage ClearTexSubImage} commands. These commands can also be useful for initializing an image that will be used for atomic shader + * operations.
+ * + *Requires {@link GL13 OpenGL 1.3}. Promoted to core in {@link GL44 OpenGL 4.4}.
+ */ +public class ARBClearTexture { + + /** Accepted by the {@code pname} parameter for {@link GL42C#glGetInternalformativ GetInternalformativ} and {@link GL43C#glGetInternalformati64v GetInternalformati64v}. */ + public static final int GL_CLEAR_TEXTURE = 0x9365; + + static { GL.initialize(); } + + protected ARBClearTexture() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glClearTexSubImage, caps.glClearTexImage + ); + } + + // --- [ glClearTexSubImage ] --- + + /** Unsafe version of: {@link #glClearTexSubImage ClearTexSubImage} */ + public static void nglClearTexSubImage(int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int format, int type, long data) { + GL44C.nglClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); + } + + /** + * Fills all or part of a texture image with a constant value. + * + *Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
This extension provides additional clip control modes to configure how clip space is mapped to window space. This extension's goal is to 1) allow + * OpenGL to effectively match Direct3D's coordinate system conventions, and 2) potentially improve the numerical precision of the Z coordinate mapping.
+ * + *Promoted to core in {@link GL45 OpenGL 4.5}.
+ */ +public class ARBClipControl { + + /** Accepted by the {@code origin} parameter of {@link #glClipControl ClipControl}. */ + public static final int + GL_LOWER_LEFT = 0x8CA1, + GL_UPPER_LEFT = 0x8CA2; + + /** Accepted by the {@code depth} parameter of {@link #glClipControl ClipControl}. */ + public static final int + GL_NEGATIVE_ONE_TO_ONE = 0x935E, + GL_ZERO_TO_ONE = 0x935F; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_CLIP_ORIGIN = 0x935C, + GL_CLIP_DEPTH_MODE = 0x935D; + + static { GL.initialize(); } + + protected ARBClipControl() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glClipControl + ); + } + + // --- [ glClipControl ] --- + + /** + * Controls the clipping volume behavior. + * + *These parameters update the clip control origin and depth mode respectively. The initial value of the clip control origin is {@link GL20#GL_LOWER_LEFT LOWER_LEFT} and the + * initial value of the depth mode is {@link GL45C#GL_NEGATIVE_ONE_TO_ONE NEGATIVE_ONE_TO_ONE}.
+ * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if ClipControl is executed between the execution of {@link GL11#glBegin Begin} and the corresponding + * execution of {@link GL11#glEnd End}.
+ * + * @param origin the clip origin. One of:| {@link GL20#GL_LOWER_LEFT LOWER_LEFT} | {@link GL20#GL_UPPER_LEFT UPPER_LEFT} |
| {@link GL45C#GL_NEGATIVE_ONE_TO_ONE NEGATIVE_ONE_TO_ONE} | {@link GL45C#GL_ZERO_TO_ONE ZERO_TO_ONE} |
The standard OpenGL pipeline is based on a fixed-point pipeline. While color components are nominally floating-point values in the pipeline, components + * are frequently clamped to the range [0,1] to accomodate the fixed-point color buffer representation and allow for fixed-point computational hardware.
+ * + *This extension adds pixel formats or visuals with floating-point RGBA color components and controls for clamping of color components within the pipeline.
+ * + *For a floating-point RGBA pixel format, the size of each float components is specified using the same attributes that are used for defining the size of + * fixed-point components. 32-bit floating-point components are in the standard IEEE float format. 16-bit floating-point components have 1 sign bit, 5 + * exponent bits, and 10 mantissa bits.
+ * + *Clamping control provides a way to disable certain color clamps and allow programs, and the fixed-function pipeline, to deal in unclamped colors. There + * are controls to modify clamping of vertex colors, clamping of fragment colors throughout the pipeline, and for pixel return data.
+ * + *The default state for fragment clamping is {@link #GL_FIXED_ONLY_ARB FIXED_ONLY_ARB}, which has the behavior of clamping colors for fixed-point color buffers and not clamping + * colors for floating-pont color buffers.
+ * + *Vertex colors are clamped by default.
+ * + *Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public class ARBColorBufferFloat { + + /** Accepted by the {@code pname} parameters of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_RGBA_FLOAT_MODE_ARB = 0x8820; + + /** Accepted by the {@code target} parameter of ClampColorARB and the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_CLAMP_VERTEX_COLOR_ARB = 0x891A, + GL_CLAMP_FRAGMENT_COLOR_ARB = 0x891B, + GL_CLAMP_READ_COLOR_ARB = 0x891C; + + /** Accepted by the {@code clamp} parameter of ClampColorARB. */ + public static final int GL_FIXED_ONLY_ARB = 0x891D; + + static { GL.initialize(); } + + protected ARBColorBufferFloat() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glClampColorARB + ); + } + + // --- [ glClampColorARB ] --- + + /** + * Controls color clamping. + * + * @param target the color target. One of:| {@link #GL_CLAMP_VERTEX_COLOR_ARB CLAMP_VERTEX_COLOR_ARB} | {@link #GL_CLAMP_FRAGMENT_COLOR_ARB CLAMP_FRAGMENT_COLOR_ARB} | {@link #GL_CLAMP_READ_COLOR_ARB CLAMP_READ_COLOR_ARB} |
| {@link GL11#GL_TRUE TRUE} | {@link GL11#GL_FALSE FALSE} | {@link #GL_FIXED_ONLY_ARB FIXED_ONLY_ARB} |
This extension expands the functionality of the {@link GL11C#glPixelStorei PixelStorei} modes to allow {@link GL11#GL_UNPACK_ROW_LENGTH UNPACK_ROW_LENGTH}, {@link GL11#GL_UNPACK_SKIP_ROWS UNPACK_SKIP_ROWS}, + * {@link GL11#GL_UNPACK_SKIP_PIXELS UNPACK_SKIP_PIXELS}, {@link GL12#GL_UNPACK_IMAGE_HEIGHT UNPACK_IMAGE_HEIGHT} and {@link GL12#GL_UNPACK_SKIP_IMAGES UNPACK_SKIP_IMAGES} to affect the operation of CompressedTexImage*D and + * CompressedTexSubImage*D. Similarly, it also allows {@link GL11#GL_PACK_ROW_LENGTH PACK_ROW_LENGTH}, {@link GL11#GL_PACK_SKIP_ROWS PACK_SKIP_ROWS}, {@link GL11#GL_PACK_SKIP_PIXELS PACK_SKIP_PIXELS}, {@link GL12#GL_PACK_IMAGE_HEIGHT PACK_IMAGE_HEIGHT} and + * {@link GL12#GL_PACK_SKIP_IMAGES PACK_SKIP_IMAGES} to affect the operation of GetCompressedTexImage*D. This allows data to be transferred to or from a specified sub-rectangle of a + * larger compressed image.
+ * + *This extension is designed primarily to support compressed image formats with fixed-size blocks. To use this new mechanism, an application should + * program new parameters UNPACK_COMPRESSED_BLOCK_{WIDTH,HEIGHT,DEPTH,SIZE} to indicate the number of texels in each dimension of the fixed-size block as + * well as the number of bytes consumed by each block. These parameters, in addition to the existing PixelStore parameters, are used to identify a + * collection of bytes in client memory or a buffer object's data store to use as compressed texture data. This operation is unlikely to have the desired + * results if the client programs a block size inconsistent with the underlying compressed image format, or if the compressed image format has + * variable-sized blocks.
+ * + *Requires {@link GL21 OpenGL 2.1}. Promoted to core in {@link GL42 OpenGL 4.2}.
+ */ +public final class ARBCompressedTexturePixelStorage { + + /** Accepted by the {@code pname} parameter of PixelStore[fi], GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int + GL_UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127, + GL_UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128, + GL_UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129, + GL_UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A, + GL_PACK_COMPRESSED_BLOCK_WIDTH = 0x912B, + GL_PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C, + GL_PACK_COMPRESSED_BLOCK_DEPTH = 0x912D, + GL_PACK_COMPRESSED_BLOCK_SIZE = 0x912E; + + private ARBCompressedTexturePixelStorage() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBComputeShader.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBComputeShader.java new file mode 100644 index 00000000..e45dd50c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBComputeShader.java @@ -0,0 +1,129 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_compute_shader extension. + * + *Recent graphics hardware has become extremely powerful and a strong desire to harness this power for work (both graphics and non-graphics) that does not + * fit the traditional graphics pipeline well has emerged. To address this, this extension adds a new single-stage program type known as a compute program. + * This program may contain one or more compute shaders which may be launched in a manner that is essentially stateless. This allows arbitrary workloads to + * be sent to the graphics hardware with minimal disturbance to the GL state machine.
+ * + *In most respects, a compute program is identical to a traditional OpenGL program object, with similar status, uniforms, and other such properties. It + * has access to many of the same resources as fragment and other shader types, such as textures, image variables, atomic counters, and so on. However, it + * has no predefined inputs nor any fixed-function outputs. It cannot be part of a pipeline and its visible side effects are through its actions on images + * and atomic counters.
+ * + *OpenCL is another solution for using graphics processors as generalized compute devices. This extension addresses a different need. For example, OpenCL + * is designed to be usable on a wide range of devices ranging from CPUs, GPUs, and DSPs through to FPGAs. While one could implement GL on these types of + * devices, the target here is clearly GPUs. Another difference is that OpenCL is more full featured and includes features such as multiple devices, + * asynchronous queues and strict IEEE semantics for floating point operations. This extension follows the semantics of OpenGL - implicitly synchronous, + * in-order operation with single-device, single queue logical architecture and somewhat more relaxed numerical precision requirements. Although not as + * feature rich, this extension offers several advantages for applications that can tolerate the omission of these features. Compute shaders are written in + * GLSL, for example and so code may be shared between compute and other shader types. Objects are created and owned by the same context as the rest of the + * GL, and therefore no interoperability API is required and objects may be freely used by both compute and graphics simultaneously without acquire-release + * semantics or object type translation.
+ * + *Requires {@link GL42 OpenGL 4.2}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public class ARBComputeShader { + + /** Accepted by the {@code type} parameter of CreateShader and returned in the {@code params} parameter by GetShaderiv. */ + public static final int GL_COMPUTE_SHADER = 0x91B9; + + /** Accepted by the {@code pname} parameter of GetIntegerv, GetBooleanv, GetFloatv, GetDoublev and GetInteger64v. */ + public static final int + GL_MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB, + GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC, + GL_MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD, + GL_MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262, + GL_MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263, + GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264, + GL_MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265, + GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266, + GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB; + + /** Accepted by the {@code pname} parameter of GetIntegeri_v, GetBooleani_v, GetFloati_v, GetDoublei_v and GetInteger64i_v. */ + public static final int + GL_MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE, + GL_MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF; + + /** Accepted by the {@code pname} parameter of GetProgramiv. */ + public static final int GL_COMPUTE_WORK_GROUP_SIZE = 0x8267; + + /** Accepted by the {@code pname} parameter of GetActiveUniformBlockiv. */ + public static final int GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC; + + /** Accepted by the {@code pname} parameter of GetActiveAtomicCounterBufferiv. */ + public static final int GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED; + + /** Accepted by the {@code target} parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, and GetBufferPointerv. */ + public static final int GL_DISPATCH_INDIRECT_BUFFER = 0x90EE; + + /** Accepted by the {@code value} parameter of GetIntegerv, GetBooleanv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int GL_DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF; + + /** Accepted by the {@code stages} parameter of UseProgramStages. */ + public static final int GL_COMPUTE_SHADER_BIT = 0x20; + + static { GL.initialize(); } + + protected ARBComputeShader() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDispatchCompute, caps.glDispatchComputeIndirect + ); + } + + // --- [ glDispatchCompute ] --- + + /** + * Launches one or more compute work groups. + * + * @param num_groups_x the number of work groups to be launched in the X dimension + * @param num_groups_y the number of work groups to be launched in the Y dimension + * @param num_groups_z the number of work groups to be launched in the Z dimension + */ + public static void glDispatchCompute(@NativeType("GLuint") int num_groups_x, @NativeType("GLuint") int num_groups_y, @NativeType("GLuint") int num_groups_z) { + GL43C.glDispatchCompute(num_groups_x, num_groups_y, num_groups_z); + } + + // --- [ glDispatchComputeIndirect ] --- + + /** + * Launches one or more compute work groups using parameters stored in a buffer. + * + *The parameters addressed by indirect are packed a structure, which takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint num_groups_x;
+ * uint num_groups_y;
+ * uint num_groups_z;
+ * } DispatchIndirectCommand;A call to {@code glDispatchComputeIndirect} is equivalent, assuming no errors are generated, to:
+ * + *
+ * cmd = (const DispatchIndirectCommand *)indirect;
+ * glDispatchCompute(cmd->num_groups_x, cmd->num_groups_y, cmd->num_groups_z);This extension allows applications to write generic compute shaders that operate on work groups with arbitrary dimensions. Instead of specifying a fixed + * work group size in the compute shader, an application can use a compute shader using the {@code local_size_variable} layout qualifer to indicate a + * variable work group size. When using such compute shaders, the new command DispatchComputeGroupSizeARB should be used to specify both a work group size + * and work group count.
+ * + *In this extension, compute shaders with fixed group sizes must be dispatched by {@link GL43C#glDispatchCompute DispatchCompute} and {@link GL43C#glDispatchComputeIndirect DispatchComputeIndirect}. Compute + * shaders with variable group sizes must be dispatched via {@link #glDispatchComputeGroupSizeARB DispatchComputeGroupSizeARB}. No support is provided in this extension for indirect dispatch + * of compute shaders with a variable group size.
+ * + *Requires {@link GL43 OpenGL 4.3} or {@link ARBComputeShader ARB_compute_shader}.
+ */ +public class ARBComputeVariableGroupSize { + + /** Accepted by the {@code pname} parameter of GetIntegerv, GetBooleanv, GetFloatv, GetDoublev and GetInteger64v. */ + public static final int + GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB = 0x9344, + GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB = 0x90EB; + + /** Accepted by the {@code pname} parameter of GetIntegeri_v, GetBooleani_v, GetFloati_v, GetDoublei_v and GetInteger64i_v. */ + public static final int + GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB = 0x9345, + GL_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB = 0x91BF; + + static { GL.initialize(); } + + protected ARBComputeVariableGroupSize() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDispatchComputeGroupSizeARB + ); + } + + // --- [ glDispatchComputeGroupSizeARB ] --- + + /** + * Launches one or more compute work groups, with arbitrary dimensions. + * + *An {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error is generated by DispatchComputeGroupSizeARB if the active program for the compute shader stage has a fixed work group + * size.
+ * + *An {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated by DispatchComputeGroupSizeARB if any of {@code group_size_x}, {@code group_size_y}, or {@code group_size_z} is + * less than or equal to zero or greater than the maximum local work group size for compute shaders with variable group size + * ({@link #GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB}) in the corresponding dimension.
+ * + *An {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated by DispatchComputeGroupSizeARB if the product of {@code group_size_x}, {@code group_size_y}, and + * {@code group_size_z} exceeds the implementation-dependent maximum local work group invocation count for compute shaders with variable group size + * ({@link #GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB}).
+ * + * @param num_groups_x the number of work groups to be launched in the X dimension + * @param num_groups_y the number of work groups to be launched in the Y dimension + * @param num_groups_z the number of work groups to be launched in the Z dimension + * @param group_size_x the group size in the X dimension + * @param group_size_y the group size in the Y dimension + * @param group_size_z the group size in the Z dimension + */ + public static native void glDispatchComputeGroupSizeARB(@NativeType("GLuint") int num_groups_x, @NativeType("GLuint") int num_groups_y, @NativeType("GLuint") int num_groups_z, @NativeType("GLuint") int group_size_x, @NativeType("GLuint") int group_size_y, @NativeType("GLuint") int group_size_z); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBConditionalRenderInverted.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBConditionalRenderInverted.java new file mode 100644 index 00000000..1a11ff9a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBConditionalRenderInverted.java @@ -0,0 +1,26 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_conditional_render_inverted extension. + * + *This extension adds new modes to {@link GL30C#glBeginConditionalRender BeginConditionalRender} which invert the condition used to determine whether to draw or not.
+ * + *Requires {@link GL30 OpenGL 3.0}. Promoted to core in {@link GL45 OpenGL 4.5}.
+ */ +public final class ARBConditionalRenderInverted { + + /** Accepted by the {@code mode} parameter of {@link GL30C#glBeginConditionalRender BeginConditionalRender}. */ + public static final int + GL_QUERY_WAIT_INVERTED = 0x8E17, + GL_QUERY_NO_WAIT_INVERTED = 0x8E18, + GL_QUERY_BY_REGION_WAIT_INVERTED = 0x8E19, + GL_QUERY_BY_REGION_NO_WAIT_INVERTED = 0x8E1A; + + private ARBConditionalRenderInverted() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBCopyBuffer.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBCopyBuffer.java new file mode 100644 index 00000000..1d38a69e --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBCopyBuffer.java @@ -0,0 +1,67 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_copy_buffer extension. + * + *This extension provides a mechanism to do an accelerated copy from one buffer object to another. This may be useful to load buffer objects in a "loading + * thread" while minimizing cost and synchronization effort in the "rendering thread."
+ * + *Promoted to core in {@link GL31 OpenGL 3.1}.
+ */ +public class ARBCopyBuffer { + + /** + * Accepted by the target parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, GetBufferPointerv, MapBufferRange, + * FlushMappedBufferRange, GetBufferParameteriv, BindBufferRange, BindBufferBase, and CopyBufferSubData. + */ + public static final int + GL_COPY_READ_BUFFER = 0x8F36, + GL_COPY_WRITE_BUFFER = 0x8F37; + + static { GL.initialize(); } + + protected ARBCopyBuffer() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glCopyBufferSubData + ); + } + + // --- [ glCopyBufferSubData ] --- + + /** + * Copies all or part of one buffer object's data store to the data store of another buffer object. + * + *An {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if any of readoffset, writeoffset, or size are negative, if readoffset+size exceeds the size of the buffer object + * bound to readtarget, or if writeoffset+size exceeds the size of the buffer object bound to writetarget.
+ * + *An {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if the same buffer object is bound to both readtarget and writetarget, and the ranges [readoffset, readoffset+size) + * and [writeoffset, writeoffset+size) overlap.
+ * + *An {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error is generated if zero is bound to readtarget or writetarget.
+ * + *An {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error is generated if the buffer objects bound to either readtarget or writetarget are mapped.
+ * + * @param readTarget the source buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL31C#GL_COPY_READ_BUFFER COPY_READ_BUFFER} | {@link GL31C#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} |
| {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} | {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31C#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL31C#GL_UNIFORM_BUFFER UNIFORM_BUFFER} |
This extension enables efficient image data transfer between image objects (i.e. textures and renderbuffers) without the need to bind the objects or + * otherwise configure the rendering pipeline.
+ * + *This is accomplised by adding a new entry-point {@link #glCopyImageSubData CopyImageSubData}, which takes a named source and destination.
+ * + *CopyImageSubData does not perform general-purpose conversions such as scaling, resizing, blending, color-space, or format conversions. It should be + * considered to operate in a manner similar to a CPU {@code memcpy}, but using the GPU for the copy.
+ * + *CopyImageSubData supports copies between images with different internal formats, if the formats are compatible for TextureViews.
+ * + *CopyImageSubData also supports copying between compressed and uncompressed images if the compressed block / uncompressed texel sizes are the same.
+ * + *Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public class ARBCopyImage { + + static { GL.initialize(); } + + protected ARBCopyImage() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glCopyImageSubData + ); + } + + // --- [ glCopyImageSubData ] --- + + /** + * Performs a raw data copy between two images. + * + * @param srcName the name of a texture or renderbuffer object from which to copy + * @param srcTarget the target representing the namespace of the source name {@code srcName} + * @param srcLevel the mipmap level to read from the source + * @param srcX the X coordinate of the left edge of the souce region to copy + * @param srcY the Y coordinate of the top edge of the souce region to copy + * @param srcZ the Z coordinate of the near edge of the souce region to copy + * @param dstName the name of a texture or renderbuffer object to which to copy + * @param dstTarget the target representing the namespace of the destination name {@code dstName} + * @param dstLevel the mipmap level to write to the source + * @param dstX the X coordinate of the left edge of the destination region + * @param dstY the Y coordinate of the top edge of the destination region + * @param dstZ the Z coordinate of the near edge of the destination region + * @param srcWidth the width of the region to be copied + * @param srcHeight the height of the region to be copied + * @param srcDepth the depth of the region to be copied + */ + public static void glCopyImageSubData(@NativeType("GLuint") int srcName, @NativeType("GLenum") int srcTarget, @NativeType("GLint") int srcLevel, @NativeType("GLint") int srcX, @NativeType("GLint") int srcY, @NativeType("GLint") int srcZ, @NativeType("GLuint") int dstName, @NativeType("GLenum") int dstTarget, @NativeType("GLint") int dstLevel, @NativeType("GLint") int dstX, @NativeType("GLint") int dstY, @NativeType("GLint") int dstZ, @NativeType("GLsizei") int srcWidth, @NativeType("GLsizei") int srcHeight, @NativeType("GLsizei") int srcDepth) { + GL43C.glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBCullDistance.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBCullDistance.java new file mode 100644 index 00000000..332a88fe --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBCullDistance.java @@ -0,0 +1,26 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_cull_distance extension. + * + *This extension adds a new GLSL {@code gl_CullDistance} shader output, similar to {@code gl_ClipDistance}, but used for whole primitive culling.
+ * + *This new stage in the pipeline is added as part of the primitive clipping stage.
+ * + *Requires {@link GL30 OpenGL 3.0}. Promoted to core in {@link GL45 OpenGL 4.5}.
+ */ +public final class ARBCullDistance { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetFloatv, GetIntegerv, and GetInteger64v. */ + public static final int + GL_MAX_CULL_DISTANCES = 0x82F9, + GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES = 0x82FA; + + private ARBCullDistance() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDebugOutput.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDebugOutput.java new file mode 100644 index 00000000..25eeb7a1 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDebugOutput.java @@ -0,0 +1,399 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the ARB_debug_output extension. + * + *This extension allows the GL to notify applications when various events occur that may be useful during application development and debugging.
+ * + *These events are represented in the form of enumerable messages with a human-readable string representation. Examples of debug events include incorrect + * use of the GL, warnings of undefined behavior, and performance warnings.
+ * + *A message is uniquely identified by a source, a type and an implementation-dependent ID within the source and type pair.
+ * + *A message's source identifies the origin of the message and can either describe components of the GL, the window system, third-party external sources + * such as external debuggers, or even the application itself.
+ * + *The type of the message roughly identifies the nature of the event that caused the message. Examples include errors, performance warnings, or warnings + * about undefined behavior.
+ * + *A message's ID for a given source and type further distinguishes messages within those groups. For example, an error caused by a negative parameter + * value or an invalid internal texture format are both errors generated by the API, but would likely have different message IDs.
+ * + *Each message is also assigned to a severity level that denotes roughly how "important" that message is in comparison to other messages across all + * sources and types. For example, notification of a GL error would likely have a higher severity than a performance warning due to redundant state + * changes.
+ * + *Finally, every message contains an implementation-dependent string representation that provides a useful description of the event.
+ * + *Messages are communicated to the application through an application-defined callback function that is called by the GL implementation on each debug + * message. The motivation for the callback routine is to free application developers from actively having to query whether a GL error, or any other + * debuggable event has happened after each call to a GL function. With a callback, developers can keep their code free of debug checks, and only have to + * react to messages as they occur. In situations where using a callback is not possible, a message log is also provided that stores copies of recent + * messages until they are actively queried.
+ * + *To control the volume of debug output, messages can be disabled either individually by ID, or entire groups of messages can be turned off based on + * combination of source and type.
+ * + *The only requirement on the minimum quantity and type of messages that implementations of this extension must support is that some sort of message must + * be sent notifying the application whenever any GL error occurs. Any further messages are left to the implementation. Implementations do not have to + * output messages from all sources nor do they have to use all types of messages listed by this extension, and both new sources and types can be added by + * other extensions.
+ * + *For performance reasons it is recommended, but not required, that implementations restrict supporting this extension only to contexts created using the + * debug flag as provided by {@link WGLARBCreateContext WGL_ARB_create_context} or {@link GLXARBCreateContext GLX_ARB_create_context}. This extension places no limits on any other functionality + * provided by debug contexts through other extensions.
+ */ +public class ARBDebugOutput { + + /** + * Tokens accepted by the {@code target} parameters of Enable, Disable, and IsEnabled. + * + *The behavior of how and when the GL driver is allowed to generate debug messages, and subsequently either call back to the application or place the + * message in the debug message log, is affected by the state DEBUG_OUTPUT_SYNCHRONOUS_ARB. This state can be modified by the {@link GL11#glEnable Enable} and + * {@link GL11#glDisable Disable} commands. Its initial value is {@link GL11#GL_FALSE FALSE}.
+ * + *When DEBUG_OUTPUT_SYNCHRONOUS_ARB is disabled, the driver is optionally allowed to concurrently call the debug callback routine from potentially + * multiple threads, including threads that the context that generated the message is not currently bound to. The implementation may also call the callback + * routine asynchronously after the GL command that generated the message has already returned. The application is fully responsible for ensuring thread + * safety due to debug callbacks under these circumstances. In this situation the {@code userParam} value may be helpful in identifying which application + * thread's command originally generated the debug callback.
+ * + *When DEBUG_OUTPUT_SYNCHRONOUS_ARB is enabled, the driver guarantees synchronous calls to the callback routine by the context. When synchronous callbacks + * are enabled, all calls to the callback routine will be made by the thread that owns the current context; all such calls will be made serially by the + * current context; and each call will be made before the GL command that generated the debug message is allowed to return.
+ * + *When no callback is specified and DEBUG_OUTPUT_SYNCHRONOUS_ARB is disabled, the driver can still asynchronously place messages in the debug message log, + * even after the context thread has returned from the GL function that generated those messages. When DEBUG_OUTPUT_SYNCHRONOUS_ARB is enabled, the driver + * guarantees that all messages are added to the log before the GL function returns.
+ * + *Enabling synchronous debug output greatly simplifies the responsibilities of the application for making its callback functions thread-safe, but may + * potentially result in drastically reduced driver performance.
+ * + *The DEBUG_OUTPUT_SYNCHRONOUS_ARB only guarantees intra-context synchronization for the callbacks of messages generated by that context, and does not + * guarantee synchronization across multiple contexts. If multiple contexts are concurrently used by the application, it is allowed for those contexts to + * also concurrently call their designated callbacks, and the application is responsible for handling thread safety in that situation even if + * DEBUG_OUTPUT_SYNCHRONOUS_ARB is enabled in all contexts.
+ */ + public static final int GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB = 0x8242; + + /** Tokens accepted by the {@code value} parameters of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_MAX_DEBUG_MESSAGE_LENGTH_ARB = 0x9143, + GL_MAX_DEBUG_LOGGED_MESSAGES_ARB = 0x9144, + GL_DEBUG_LOGGED_MESSAGES_ARB = 0x9145, + GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = 0x8243; + + /** Tokens accepted by the {@code pname} parameter of GetPointerv. */ + public static final int + GL_DEBUG_CALLBACK_FUNCTION_ARB = 0x8244, + GL_DEBUG_CALLBACK_USER_PARAM_ARB = 0x8245; + + /** + * Tokens accepted or provided by the {@code source} parameters of DebugMessageControlARB, DebugMessageInsertARB and DEBUGPROCARB, and the {@code sources} + * parameter of GetDebugMessageLogARB. + */ + public static final int + GL_DEBUG_SOURCE_API_ARB = 0x8246, + GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB = 0x8247, + GL_DEBUG_SOURCE_SHADER_COMPILER_ARB = 0x8248, + GL_DEBUG_SOURCE_THIRD_PARTY_ARB = 0x8249, + GL_DEBUG_SOURCE_APPLICATION_ARB = 0x824A, + GL_DEBUG_SOURCE_OTHER_ARB = 0x824B; + + /** + * Tokens accepted or provided by the {@code type} parameters of DebugMessageControlARB, DebugMessageInsertARB and DEBUGPROCARB, and the {@code types} + * parameter of GetDebugMessageLogARB. + */ + public static final int + GL_DEBUG_TYPE_ERROR_ARB = 0x824C, + GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = 0x824D, + GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = 0x824E, + GL_DEBUG_TYPE_PORTABILITY_ARB = 0x824F, + GL_DEBUG_TYPE_PERFORMANCE_ARB = 0x8250, + GL_DEBUG_TYPE_OTHER_ARB = 0x8251; + + /** + * Tokens accepted or provided by the {@code severity} parameters of DebugMessageControlARB, DebugMessageInsertARB and DEBUGPROCARB callback functions, and + * the {@code severities} parameter of GetDebugMessageLogARB. + */ + public static final int + GL_DEBUG_SEVERITY_HIGH_ARB = 0x9146, + GL_DEBUG_SEVERITY_MEDIUM_ARB = 0x9147, + GL_DEBUG_SEVERITY_LOW_ARB = 0x9148; + + static { GL.initialize(); } + + protected ARBDebugOutput() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDebugMessageControlARB, caps.glDebugMessageInsertARB, caps.glDebugMessageCallbackARB, caps.glGetDebugMessageLogARB + ); + } + + // --- [ glDebugMessageControlARB ] --- + + /** + * Unsafe version of: {@link #glDebugMessageControlARB DebugMessageControlARB} + * + * @param count the number of message IDs in {@code ids} + */ + public static native void nglDebugMessageControlARB(int source, int type, int severity, int count, long ids, boolean enabled); + + /** + * Controls the volume of debug output by disabling specific or groups of messages. + * + *If {@code enabled} is {@link GL11#GL_TRUE TRUE}, the referenced subset of messages will be enabled. If {@link GL11#GL_FALSE FALSE}, then those messages will be disabled.
+ * + *This command can reference different subsets of messages by first considering the set of all messages, and filtering out messages based on the following + * ways:
+ * + *Although messages are grouped into an implicit hierarchy by their sources and types, there is no explicit per-source, per-type or per-severity enabled + * state. Instead, the enabled state is stored individually for each message. There is no difference between disabling all messages from one source in a + * single call, and individually disabling all messages from that source using their types and IDs.
+ * + * @param source the message source. One of:| {@link #GL_DEBUG_SOURCE_API_ARB DEBUG_SOURCE_API_ARB} | {@link #GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB DEBUG_SOURCE_WINDOW_SYSTEM_ARB} |
| {@link #GL_DEBUG_SOURCE_SHADER_COMPILER_ARB DEBUG_SOURCE_SHADER_COMPILER_ARB} | {@link #GL_DEBUG_SOURCE_THIRD_PARTY_ARB DEBUG_SOURCE_THIRD_PARTY_ARB} |
| {@link #GL_DEBUG_SOURCE_APPLICATION_ARB DEBUG_SOURCE_APPLICATION_ARB} | {@link #GL_DEBUG_SOURCE_OTHER_ARB DEBUG_SOURCE_OTHER_ARB} |
| {@link #GL_DEBUG_TYPE_ERROR_ARB DEBUG_TYPE_ERROR_ARB} | {@link #GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB} |
| {@link #GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB} | {@link #GL_DEBUG_TYPE_PORTABILITY_ARB DEBUG_TYPE_PORTABILITY_ARB} |
| {@link #GL_DEBUG_TYPE_PERFORMANCE_ARB DEBUG_TYPE_PERFORMANCE_ARB} | {@link #GL_DEBUG_TYPE_OTHER_ARB DEBUG_TYPE_OTHER_ARB} |
| {@link #GL_DEBUG_SEVERITY_HIGH_ARB DEBUG_SEVERITY_HIGH_ARB} | {@link #GL_DEBUG_SEVERITY_MEDIUM_ARB DEBUG_SEVERITY_MEDIUM_ARB} | {@link #GL_DEBUG_SEVERITY_LOW_ARB DEBUG_SEVERITY_LOW_ARB} |
If {@code enabled} is {@link GL11#GL_TRUE TRUE}, the referenced subset of messages will be enabled. If {@link GL11#GL_FALSE FALSE}, then those messages will be disabled.
+ * + *This command can reference different subsets of messages by first considering the set of all messages, and filtering out messages based on the following + * ways:
+ * + *Although messages are grouped into an implicit hierarchy by their sources and types, there is no explicit per-source, per-type or per-severity enabled + * state. Instead, the enabled state is stored individually for each message. There is no difference between disabling all messages from one source in a + * single call, and individually disabling all messages from that source using their types and IDs.
+ * + * @param source the message source. One of:| {@link #GL_DEBUG_SOURCE_API_ARB DEBUG_SOURCE_API_ARB} | {@link #GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB DEBUG_SOURCE_WINDOW_SYSTEM_ARB} |
| {@link #GL_DEBUG_SOURCE_SHADER_COMPILER_ARB DEBUG_SOURCE_SHADER_COMPILER_ARB} | {@link #GL_DEBUG_SOURCE_THIRD_PARTY_ARB DEBUG_SOURCE_THIRD_PARTY_ARB} |
| {@link #GL_DEBUG_SOURCE_APPLICATION_ARB DEBUG_SOURCE_APPLICATION_ARB} | {@link #GL_DEBUG_SOURCE_OTHER_ARB DEBUG_SOURCE_OTHER_ARB} |
| {@link #GL_DEBUG_TYPE_ERROR_ARB DEBUG_TYPE_ERROR_ARB} | {@link #GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB} |
| {@link #GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB} | {@link #GL_DEBUG_TYPE_PORTABILITY_ARB DEBUG_TYPE_PORTABILITY_ARB} |
| {@link #GL_DEBUG_TYPE_PERFORMANCE_ARB DEBUG_TYPE_PERFORMANCE_ARB} | {@link #GL_DEBUG_TYPE_OTHER_ARB DEBUG_TYPE_OTHER_ARB} |
| {@link #GL_DEBUG_SEVERITY_HIGH_ARB DEBUG_SEVERITY_HIGH_ARB} | {@link #GL_DEBUG_SEVERITY_MEDIUM_ARB DEBUG_SEVERITY_MEDIUM_ARB} | {@link #GL_DEBUG_SEVERITY_LOW_ARB DEBUG_SEVERITY_LOW_ARB} |
The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} will be generated if the number of characters in {@code buf}, excluding the null terminator when {@code length} is + * negative, is not less than {@link #GL_MAX_DEBUG_MESSAGE_LENGTH_ARB MAX_DEBUG_MESSAGE_LENGTH_ARB}.
+ * + * @param source the message source. One of:| {@link #GL_DEBUG_SOURCE_THIRD_PARTY_ARB DEBUG_SOURCE_THIRD_PARTY_ARB} | {@link #GL_DEBUG_SOURCE_APPLICATION_ARB DEBUG_SOURCE_APPLICATION_ARB} |
| {@link #GL_DEBUG_TYPE_ERROR_ARB DEBUG_TYPE_ERROR_ARB} | {@link #GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB} |
| {@link #GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB} | {@link #GL_DEBUG_TYPE_PORTABILITY_ARB DEBUG_TYPE_PORTABILITY_ARB} |
| {@link #GL_DEBUG_TYPE_PERFORMANCE_ARB DEBUG_TYPE_PERFORMANCE_ARB} | {@link #GL_DEBUG_TYPE_OTHER_ARB DEBUG_TYPE_OTHER_ARB} |
| {@link #GL_DEBUG_SEVERITY_HIGH_ARB DEBUG_SEVERITY_HIGH_ARB} | {@link #GL_DEBUG_SEVERITY_MEDIUM_ARB DEBUG_SEVERITY_MEDIUM_ARB} | {@link #GL_DEBUG_SEVERITY_LOW_ARB DEBUG_SEVERITY_LOW_ARB} |
The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} will be generated if the number of characters in {@code buf}, excluding the null terminator when {@code length} is + * negative, is not less than {@link #GL_MAX_DEBUG_MESSAGE_LENGTH_ARB MAX_DEBUG_MESSAGE_LENGTH_ARB}.
+ * + * @param source the message source. One of:| {@link #GL_DEBUG_SOURCE_THIRD_PARTY_ARB DEBUG_SOURCE_THIRD_PARTY_ARB} | {@link #GL_DEBUG_SOURCE_APPLICATION_ARB DEBUG_SOURCE_APPLICATION_ARB} |
| {@link #GL_DEBUG_TYPE_ERROR_ARB DEBUG_TYPE_ERROR_ARB} | {@link #GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB} |
| {@link #GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB} | {@link #GL_DEBUG_TYPE_PORTABILITY_ARB DEBUG_TYPE_PORTABILITY_ARB} |
| {@link #GL_DEBUG_TYPE_PERFORMANCE_ARB DEBUG_TYPE_PERFORMANCE_ARB} | {@link #GL_DEBUG_TYPE_OTHER_ARB DEBUG_TYPE_OTHER_ARB} |
| {@link #GL_DEBUG_SEVERITY_HIGH_ARB DEBUG_SEVERITY_HIGH_ARB} | {@link #GL_DEBUG_SEVERITY_MEDIUM_ARB DEBUG_SEVERITY_MEDIUM_ARB} | {@link #GL_DEBUG_SEVERITY_LOW_ARB DEBUG_SEVERITY_LOW_ARB} |
This function's prototype must follow the type definition of DEBUGPROCARB including its platform-dependent calling convention. Anything else will result + * in undefined behavior. Only one debug callback can be specified for the current context, and further calls overwrite the previous callback. Specifying + * {@code NULL} as the value of {@code callback} clears the current callback and disables message output through callbacks. Applications can provide + * user-specified data through the pointer {@code userParam}. The context will store this pointer and will include it as one of the parameters in each call + * to the callback function.
+ * + *If the application has specified a callback function for receiving debug output, the implementation will call that function whenever any enabled message + * is generated. The source, type, ID, and severity of the message are specified by the DEBUGPROCARB parameters {@code source}, {@code type}, {@code id}, + * and {@code severity}, respectively. The string representation of the message is stored in {@code message} and its length (excluding the null-terminator) + * is stored in {@code length}. The parameter {@code userParam} is the user-specified parameter that was given when calling DebugMessageCallbackARB.
+ * + *Applications can query the current callback function and the current user-specified parameter by obtaining the values of {@link #GL_DEBUG_CALLBACK_FUNCTION_ARB DEBUG_CALLBACK_FUNCTION_ARB} + * and {@link #GL_DEBUG_CALLBACK_USER_PARAM_ARB DEBUG_CALLBACK_USER_PARAM_ARB}, respectively.
+ * + *Applications that specify a callback function must be aware of certain special conditions when executing code inside a callback when it is called by the + * GL, regardless of the debug source.
+ * + *The memory for {@code message} is owned and managed by the GL, and should only be considered valid for the duration of the function call.
+ * + *The behavior of calling any GL or window system function from within the callback function is undefined and may lead to program termination.
+ * + *Care must also be taken in securing debug callbacks for use with asynchronous debug output by multi-threaded GL implementations.
+ * + *If {@link #GL_DEBUG_CALLBACK_FUNCTION_ARB DEBUG_CALLBACK_FUNCTION_ARB} is {@code NULL}, then debug messages are instead stored in an internal message log up to some maximum number of messages as + * defined by the value of {@link #GL_MAX_DEBUG_LOGGED_MESSAGES_ARB MAX_DEBUG_LOGGED_MESSAGES_ARB}.
+ * + *Each context stores its own message log and will only store messages generated by commands operating in that context. If the message log fills up, then + * any subsequently generated messages will not be placed in the log until the message log is cleared, and will instead be discarded.
+ * + *Applications can query the number of messages currently in the log by obtaining the value of {@link #GL_DEBUG_LOGGED_MESSAGES_ARB DEBUG_LOGGED_MESSAGES_ARB}, and the string length + * (including its null terminator) of the oldest message in the log through the value of {@link #GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB}.
+ * + * @param callback a callback function that will be called when a debug message is generated + * @param userParam a user supplied pointer that will be passed on each invocation of {@code callback} + */ + public static void glDebugMessageCallbackARB(@Nullable @NativeType("GLDEBUGPROCARB") GLDebugMessageARBCallbackI callback, @NativeType("void const *") long userParam) { + nglDebugMessageCallbackARB(memAddressSafe(callback), userParam); + } + + // --- [ glGetDebugMessageLogARB ] --- + + /** + * Unsafe version of: {@link #glGetDebugMessageLogARB GetDebugMessageLogARB} + * + * @param bufSize the maximum number of characters that can be written in the {@code messageLog} array + */ + public static native int nglGetDebugMessageLogARB(int count, int bufSize, long sources, long types, long ids, long severities, long lengths, long messageLog); + + /** + * When no debug callback is set, debug messages are stored in a debug message log. Messages can be queried from the log by calling this function. + * + *This function fetches a maximum of {@code count} messages from the message log, and will return the number of messages successfully fetched.
+ * + *Messages will be fetched from the log in order of oldest to newest. Those messages that were fetched will be removed from the log.
+ * + *The sources, types, severities, IDs, and string lengths of fetched messages will be stored in the application-provided arrays {@code sources}, + * {@code types}, {@code severities}, {@code ids}, and {@code lengths}, respectively. The application is responsible for allocating enough space for each + * array to hold up to {@code count} elements. The string representations of all fetched messages are stored in the {@code messageLog} array. If multiple + * messages are fetched, their strings are concatenated into the same {@code messageLog} array and will be separated by single null terminators. The last + * string in the array will also be null-terminated. The maximum size of {@code messageLog}, including the space used by all null terminators, is given by + * {@code bufSize}. If {@code bufSize} is less than zero, the error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} will be generated. If a message's string, including its null + * terminator, can not fully fit within the {@code messageLog} array's remaining space, then that message and any subsequent messages will not be fetched + * and will remain in the log. The string lengths stored in the array {@code lengths} include the space for the null terminator of each string.
+ * + *Any or all of the arrays {@code sources}, {@code types}, {@code ids}, {@code severities}, {@code lengths} and {@code messageLog} can also be null + * pointers, which causes the attributes for such arrays to be discarded when messages are fetched, however those messages will still be removed from the + * log. Thus to simply delete up to {@code count} messages from the message log while ignoring their attributes, the application can call the function with + * null pointers for all attribute arrays. If {@code messageLog} is {@code NULL}, the value of {@code bufSize} is ignored.
+ * + * @param count the number of debug messages to retrieve from the log + * @param sources a buffer in which to place the returned message sources + * @param types a buffer in which to place the returned message typesd + * @param ids a buffer in which to place the returned message IDs + * @param severities a buffer in which to place the returned message severity levels + * @param lengths a buffer in which to place the returned message lengths + * @param messageLog a buffer in which to place the returned messages + */ + @NativeType("GLuint") + public static int glGetDebugMessageLogARB(@NativeType("GLuint") int count, @Nullable @NativeType("GLenum *") IntBuffer sources, @Nullable @NativeType("GLenum *") IntBuffer types, @Nullable @NativeType("GLuint *") IntBuffer ids, @Nullable @NativeType("GLenum *") IntBuffer severities, @Nullable @NativeType("GLsizei *") IntBuffer lengths, @Nullable @NativeType("GLchar *") ByteBuffer messageLog) { + if (CHECKS) { + checkSafe(sources, count); + checkSafe(types, count); + checkSafe(ids, count); + checkSafe(severities, count); + checkSafe(lengths, count); + } + return nglGetDebugMessageLogARB(count, remainingSafe(messageLog), memAddressSafe(sources), memAddressSafe(types), memAddressSafe(ids), memAddressSafe(severities), memAddressSafe(lengths), memAddressSafe(messageLog)); + } + + /** Array version of: {@link #glDebugMessageControlARB DebugMessageControlARB} */ + public static void glDebugMessageControlARB(@NativeType("GLenum") int source, @NativeType("GLenum") int type, @NativeType("GLenum") int severity, @Nullable @NativeType("GLuint const *") int[] ids, @NativeType("GLboolean") boolean enabled) { + long __functionAddress = GL.getICD().glDebugMessageControlARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(source, type, severity, lengthSafe(ids), ids, enabled, __functionAddress); + } + + /** Array version of: {@link #glGetDebugMessageLogARB GetDebugMessageLogARB} */ + @NativeType("GLuint") + public static int glGetDebugMessageLogARB(@NativeType("GLuint") int count, @Nullable @NativeType("GLenum *") int[] sources, @Nullable @NativeType("GLenum *") int[] types, @Nullable @NativeType("GLuint *") int[] ids, @Nullable @NativeType("GLenum *") int[] severities, @Nullable @NativeType("GLsizei *") int[] lengths, @Nullable @NativeType("GLchar *") ByteBuffer messageLog) { + long __functionAddress = GL.getICD().glGetDebugMessageLogARB; + if (CHECKS) { + check(__functionAddress); + checkSafe(sources, count); + checkSafe(types, count); + checkSafe(ids, count); + checkSafe(severities, count); + checkSafe(lengths, count); + } + return callPPPPPPI(count, remainingSafe(messageLog), sources, types, ids, severities, lengths, memAddressSafe(messageLog), __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDepthBufferFloat.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDepthBufferFloat.java new file mode 100644 index 00000000..ad79312d --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDepthBufferFloat.java @@ -0,0 +1,40 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_depth_buffer_float extension. + * + *This extension provides new texture internal formats whose depth components are stored as 32-bit floating-point values, rather than the normalized + * unsigned integers used in existing depth formats. Floating-point depth textures support all the functionality supported for fixed-point depth textures, + * including shadow mapping and rendering support via {@link EXTFramebufferObject EXT_framebuffer_object}. Floating-point depth textures can store values outside the range + * {@code [0,1]}.
+ * + *Additionally, this extension provides new packed depth/stencil pixel formats (see {@link EXTPackedDepthStencil EXT_packed_depth_stencil}) that have 64-bit pixels consisting + * of a 32-bit floating-point depth value, 8 bits of stencil, and 24 unused bites. A packed depth/stencil texture internal format is also provided.
+ * + *Requires {@link GL20 OpenGL 2.0}, {@link ARBColorBufferFloat ARB_color_buffer_float}, {@link EXTPackedDepthStencil EXT_packed_depth_stencil} and {@link ARBFramebufferObject ARB_framebuffer_object}. + * Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public final class ARBDepthBufferFloat { + + /** + * Accepted by the {@code internalformat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D, and RenderbufferStorageEXT, and + * returned in the {@code data} parameter of GetTexLevelParameter and GetRenderbufferParameterivEXT. + */ + public static final int + GL_DEPTH_COMPONENT32F = 0x8CAC, + GL_DEPTH32F_STENCIL8 = 0x8CAD; + + /** + * Accepted by the {@code type} parameter of DrawPixels, ReadPixels, TexImage1D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, and + * GetTexImage. + */ + public static final int GL_FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD; + + private ARBDepthBufferFloat() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDepthClamp.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDepthClamp.java new file mode 100644 index 00000000..85cf19d5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDepthClamp.java @@ -0,0 +1,37 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_depth_clamp extension. + * + *Conventional OpenGL clips geometric primitives to a clip volume with six faces, two of which are the near and far clip planes. Clipping to the near and + * far planes of the clip volume ensures that interpolated depth values (after the depth range transform) must be in the [0,1] range.
+ * + *In some rendering applications such as shadow volumes, it is useful to allow line and polygon primitives to be rasterized without clipping the primitive + * to the near or far clip volume planes (side clip volume planes clip normally). Without the near and far clip planes, rasterization (pixel coverage + * determination) in X and Y can proceed normally if we ignore the near and far clip planes. The one major issue is that fragments of a primitive may + * extend beyond the conventional window space depth range for depth values (typically the range [0,1]). Rather than discarding fragments that defy the + * window space depth range (effectively what near and far plane clipping accomplish), the depth values can be clamped to the current depth range.
+ * + *This extension provides exactly such functionality. This functionality is useful to obviate the need for near plane capping of stenciled shadow volumes. + * The functionality may also be useful for rendering geometry "beyond" the far plane if an alternative algorithm (rather than depth testing) for hidden + * surface removal is applied to such geometry (specifically, the painter's algorithm). Similar situations at the near clip plane can be avoided at the + * near clip plane where apparently solid objects can be "seen through" if they intersect the near clip plane.
+ * + *Promoted to core in {@link GL32 OpenGL 3.2}.
+ */ +public final class ARBDepthClamp { + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_DEPTH_CLAMP = 0x864F; + + private ARBDepthClamp() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDepthTexture.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDepthTexture.java new file mode 100644 index 00000000..28777421 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDepthTexture.java @@ -0,0 +1,34 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_depth_texture extension. + * + *This extension defines a new depth texture format. An important application of depth texture images is shadow casting, but separating this from the + * shadow extension allows for the potential use of depth textures in other applications such as image-based rendering or displacement mapping. This + * extension does not define new depth-texture environment functions, such as filtering or applying the depth values computed from a texture but leaves + * this to other extensions, such as the shadow extension.
+ * + *Promoted to core in {@link GL14 OpenGL 1.4}.
+ */ +public final class ARBDepthTexture { + + /** Accepted by the {@code internalFormat} parameter of TexImage1D, TexImage2D, CopyTexImage1D and CopyTexImage2D. */ + public static final int + GL_DEPTH_COMPONENT16_ARB = 0x81A5, + GL_DEPTH_COMPONENT24_ARB = 0x81A6, + GL_DEPTH_COMPONENT32_ARB = 0x81A7; + + /** Accepted by the {@code pname} parameter of GetTexLevelParameterfv and GetTexLevelParameteriv. */ + public static final int GL_TEXTURE_DEPTH_SIZE_ARB = 0x884A; + + /** Accepted by the {@code pname} parameter of TexParameterf, TexParameteri, TexParameterfv, TexParameteriv, GetTexParameterfv, and GetTexParameteriv. */ + public static final int GL_DEPTH_TEXTURE_MODE_ARB = 0x884B; + + private ARBDepthTexture() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDirectStateAccess.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDirectStateAccess.java new file mode 100644 index 00000000..41e80980 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDirectStateAccess.java @@ -0,0 +1,3569 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_direct_state_access extension. + * + *In unextended OpenGL, most mutation of state contained in objects is through an indirection known as a binding. Objects are attached to a context + * (either directly or indirectly via a container) and then commands to modify or query their state are issued on that context, indirecting through its + * attachments and into the underlying object. This is known as `bind-to-edit'.
+ * + *This extension derives from the GL_EXT_direct_state_access extension, which added accessors for most state on most objects, allowing it to be queried + * and modified without the object needing to be bound to a context. In cases where a single property of an object is to be modified, directly accessing + * its state can be more efficient than binding the object to the context and then indirecting through it. Further, directly accessing the state of objects + * through their names rather than by bind-to-edit does not disturb the bindings of the current context, which is useful for tools, middleware and other + * applications that are unaware of the outer state but it can also avoid cases of redundant state changes.
+ * + *Requires {@link GL20 OpenGL 2.0}. Promoted to core in {@link GL45C OpenGL 4.5}.
+ */ +public class ARBDirectStateAccess { + + /** Accepted by the {@code pname} parameter of GetTextureParameter{if}v and GetTextureParameterI{i ui}v. */ + public static final int GL_TEXTURE_TARGET = 0x1006; + + /** Accepted by the {@code pname} parameter of GetQueryObjectiv. */ + public static final int GL_QUERY_TARGET = 0x82EA; + + static { GL.initialize(); } + + protected ARBDirectStateAccess() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.Set| {@link GL42#GL_TRANSFORM_FEEDBACK_PAUSED TRANSFORM_FEEDBACK_PAUSED} | {@link GL42#GL_TRANSFORM_FEEDBACK_ACTIVE TRANSFORM_FEEDBACK_ACTIVE} |
| {@link GL42#GL_TRANSFORM_FEEDBACK_PAUSED TRANSFORM_FEEDBACK_PAUSED} | {@link GL42#GL_TRANSFORM_FEEDBACK_ACTIVE TRANSFORM_FEEDBACK_ACTIVE} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_BINDING TRANSFORM_FEEDBACK_BUFFER_BINDING} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_BINDING TRANSFORM_FEEDBACK_BUFFER_BINDING} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_START TRANSFORM_FEEDBACK_BUFFER_START} | {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_SIZE TRANSFORM_FEEDBACK_BUFFER_SIZE} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_START TRANSFORM_FEEDBACK_BUFFER_START} | {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_SIZE TRANSFORM_FEEDBACK_BUFFER_SIZE} |
If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("GLsizeiptr") long size, @NativeType("GLbitfield") int flags) { + GL45C.glNamedBufferStorage(buffer, size, flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") ByteBuffer data, @NativeType("GLbitfield") int flags) { + GL45C.glNamedBufferStorage(buffer, data, flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") ShortBuffer data, @NativeType("GLbitfield") int flags) { + GL45C.glNamedBufferStorage(buffer, data, flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") IntBuffer data, @NativeType("GLbitfield") int flags) { + GL45C.glNamedBufferStorage(buffer, data, flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") FloatBuffer data, @NativeType("GLbitfield") int flags) { + GL45C.glNamedBufferStorage(buffer, data, flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") DoubleBuffer data, @NativeType("GLbitfield") int flags) { + GL45C.glNamedBufferStorage(buffer, data, flags); + } + + // --- [ glNamedBufferData ] --- + + /** + * Unsafe version of: {@link #glNamedBufferData NamedBufferData} + * + * @param size the size in bytes of the buffer object's new data store + */ + public static void nglNamedBufferData(int buffer, long size, long data, int usage) { + GL45C.nglNamedBufferData(buffer, size, data, usage); + } + + /** + * DSA version of {@link GL15C#glBufferData BufferData}. + * + * @param size the size in bytes of the buffer object's new data store + * @param usage the expected usage pattern of the data store. One of:| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_READ_ONLY READ_ONLY} | {@link GL15#GL_WRITE_ONLY WRITE_ONLY} | {@link GL15#GL_READ_WRITE READ_WRITE} |
| {@link GL15#GL_READ_ONLY READ_ONLY} | {@link GL15#GL_WRITE_ONLY WRITE_ONLY} | {@link GL15#GL_READ_WRITE READ_WRITE} |
| {@link GL15#GL_READ_ONLY READ_ONLY} | {@link GL15#GL_WRITE_ONLY WRITE_ONLY} | {@link GL15#GL_READ_WRITE READ_WRITE} |
| {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} | {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT} | {@link GL30#GL_MAP_INVALIDATE_RANGE_BIT MAP_INVALIDATE_RANGE_BIT} | {@link GL30#GL_MAP_INVALIDATE_BUFFER_BIT MAP_INVALIDATE_BUFFER_BIT} |
| {@link GL30#GL_MAP_FLUSH_EXPLICIT_BIT MAP_FLUSH_EXPLICIT_BIT} | {@link GL30#GL_MAP_UNSYNCHRONIZED_BIT MAP_UNSYNCHRONIZED_BIT} |
| {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} | {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT} | {@link GL30#GL_MAP_INVALIDATE_RANGE_BIT MAP_INVALIDATE_RANGE_BIT} | {@link GL30#GL_MAP_INVALIDATE_BUFFER_BIT MAP_INVALIDATE_BUFFER_BIT} |
| {@link GL30#GL_MAP_FLUSH_EXPLICIT_BIT MAP_FLUSH_EXPLICIT_BIT} | {@link GL30#GL_MAP_UNSYNCHRONIZED_BIT MAP_UNSYNCHRONIZED_BIT} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_BUFFER_MAP_POINTER BUFFER_MAP_POINTER} |
| {@link GL15#GL_BUFFER_MAP_POINTER BUFFER_MAP_POINTER} |
| {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL11#GL_NONE NONE} | {@link GL11#GL_FRONT_LEFT FRONT_LEFT} | {@link GL11#GL_FRONT_RIGHT FRONT_RIGHT} | {@link GL11#GL_BACK_LEFT BACK_LEFT} | {@link GL11#GL_BACK_RIGHT BACK_RIGHT} | {@link GL11#GL_FRONT FRONT} | {@link GL11#GL_BACK BACK} | {@link GL11#GL_LEFT LEFT} |
| {@link GL11#GL_RIGHT RIGHT} | {@link GL11#GL_FRONT_AND_BACK FRONT_AND_BACK} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link GL11#GL_NONE NONE} | {@link GL11#GL_FRONT_LEFT FRONT_LEFT} | {@link GL11#GL_FRONT_RIGHT FRONT_RIGHT} | {@link GL11#GL_BACK_LEFT BACK_LEFT} | {@link GL11#GL_BACK_RIGHT BACK_RIGHT} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} |
| GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link GL11#GL_NONE NONE} | {@link GL11#GL_FRONT_LEFT FRONT_LEFT} | {@link GL11#GL_FRONT_RIGHT FRONT_RIGHT} | {@link GL11#GL_BACK_LEFT BACK_LEFT} | {@link GL11#GL_BACK_RIGHT BACK_RIGHT} | {@link GL11#GL_FRONT FRONT} | {@link GL11#GL_BACK BACK} | {@link GL11#GL_LEFT LEFT} |
| {@link GL11#GL_RIGHT RIGHT} | {@link GL11#GL_FRONT_AND_BACK FRONT_AND_BACK} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link GL11#GL_COLOR COLOR} | {@link GL11#GL_STENCIL STENCIL} |
| {@link GL11#GL_COLOR COLOR} |
| {@link GL11#GL_COLOR COLOR} | {@link GL11#GL_DEPTH DEPTH} |
| {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_COLOR_BUFFER_BIT COLOR_BUFFER_BIT} | {@link GL11#GL_DEPTH_BUFFER_BIT DEPTH_BUFFER_BIT} | {@link GL11#GL_STENCIL_BUFFER_BIT STENCIL_BUFFER_BIT} |
| {@link GL11#GL_NEAREST NEAREST} | {@link GL11#GL_LINEAR LINEAR} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME FRAMEBUFFER_ATTACHMENT_OBJECT_NAME} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE FRAMEBUFFER_ATTACHMENT_RED_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE FRAMEBUFFER_ATTACHMENT_GREEN_SIZE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE FRAMEBUFFER_ATTACHMENT_BLUE_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE} |
| {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME FRAMEBUFFER_ATTACHMENT_OBJECT_NAME} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE FRAMEBUFFER_ATTACHMENT_RED_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE FRAMEBUFFER_ATTACHMENT_GREEN_SIZE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE FRAMEBUFFER_ATTACHMENT_BLUE_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE} |
| {@link GL30#GL_RENDERBUFFER_WIDTH RENDERBUFFER_WIDTH} | {@link GL30#GL_RENDERBUFFER_HEIGHT RENDERBUFFER_HEIGHT} | {@link GL30#GL_RENDERBUFFER_INTERNAL_FORMAT RENDERBUFFER_INTERNAL_FORMAT} |
| {@link GL30#GL_RENDERBUFFER_RED_SIZE RENDERBUFFER_RED_SIZE} | {@link GL30#GL_RENDERBUFFER_GREEN_SIZE RENDERBUFFER_GREEN_SIZE} | {@link GL30#GL_RENDERBUFFER_BLUE_SIZE RENDERBUFFER_BLUE_SIZE} |
| {@link GL30#GL_RENDERBUFFER_ALPHA_SIZE RENDERBUFFER_ALPHA_SIZE} | {@link GL30#GL_RENDERBUFFER_DEPTH_SIZE RENDERBUFFER_DEPTH_SIZE} | {@link GL30#GL_RENDERBUFFER_STENCIL_SIZE RENDERBUFFER_STENCIL_SIZE} |
| {@link GL30#GL_RENDERBUFFER_SAMPLES RENDERBUFFER_SAMPLES} |
| {@link GL30#GL_RENDERBUFFER_WIDTH RENDERBUFFER_WIDTH} | {@link GL30#GL_RENDERBUFFER_HEIGHT RENDERBUFFER_HEIGHT} | {@link GL30#GL_RENDERBUFFER_INTERNAL_FORMAT RENDERBUFFER_INTERNAL_FORMAT} |
| {@link GL30#GL_RENDERBUFFER_RED_SIZE RENDERBUFFER_RED_SIZE} | {@link GL30#GL_RENDERBUFFER_GREEN_SIZE RENDERBUFFER_GREEN_SIZE} | {@link GL30#GL_RENDERBUFFER_BLUE_SIZE RENDERBUFFER_BLUE_SIZE} |
| {@link GL30#GL_RENDERBUFFER_ALPHA_SIZE RENDERBUFFER_ALPHA_SIZE} | {@link GL30#GL_RENDERBUFFER_DEPTH_SIZE RENDERBUFFER_DEPTH_SIZE} | {@link GL30#GL_RENDERBUFFER_STENCIL_SIZE RENDERBUFFER_STENCIL_SIZE} |
| {@link GL30#GL_RENDERBUFFER_SAMPLES RENDERBUFFER_SAMPLES} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
{@code texture} must be zero or the name of an existing texture object. When {@code texture} is the name of an existing texture object, that object is + * bound to the target, in the corresponding texture unit, that was specified when the object was created. When {@code texture} is zero, each of the targets + * enumerated at the beginning of this section is reset to its default texture for the corresponding texture image unit.
+ * + * @param unit the texture unit number + * @param texture the texture name + */ + public static void glBindTextureUnit(@NativeType("GLuint") int unit, @NativeType("GLuint") int texture) { + GL45C.glBindTextureUnit(unit, texture); + } + + // --- [ glGetTextureImage ] --- + + /** + * Unsafe version of: {@link #glGetTextureImage GetTextureImage} + * + * @param bufSize the size of the buffer to receive the retrieved pixel data + */ + public static void nglGetTextureImage(int texture, int level, int format, int type, int bufSize, long pixels) { + GL45C.nglGetTextureImage(texture, level, format, type, bufSize, pixels); + } + + /** + * DSA version of {@link GL11C#glGetTexImage GetTexImage}. + * + * @param texture the texture name + * @param level the level-of-detail number + * @param format the pixel format. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_WIDTH TEXTURE_WIDTH} | {@link GL11#GL_TEXTURE_HEIGHT TEXTURE_HEIGHT} | {@link GL12#GL_TEXTURE_DEPTH TEXTURE_DEPTH} | {@link GL32#GL_TEXTURE_SAMPLES TEXTURE_SAMPLES} |
| {@link GL32#GL_TEXTURE_FIXED_SAMPLE_LOCATIONS TEXTURE_FIXED_SAMPLE_LOCATIONS} | {@link GL11#GL_TEXTURE_INTERNAL_FORMAT TEXTURE_INTERNAL_FORMAT} | {@link GL11#GL_TEXTURE_RED_SIZE TEXTURE_RED_SIZE} | {@link GL11#GL_TEXTURE_GREEN_SIZE TEXTURE_GREEN_SIZE} |
| {@link GL11#GL_TEXTURE_BLUE_SIZE TEXTURE_BLUE_SIZE} | {@link GL11#GL_TEXTURE_ALPHA_SIZE TEXTURE_ALPHA_SIZE} | {@link GL14#GL_TEXTURE_DEPTH_SIZE TEXTURE_DEPTH_SIZE} | {@link GL30#GL_TEXTURE_STENCIL_SIZE TEXTURE_STENCIL_SIZE} |
| {@link GL30#GL_TEXTURE_SHARED_SIZE TEXTURE_SHARED_SIZE} | {@link GL30#GL_TEXTURE_ALPHA_TYPE TEXTURE_ALPHA_TYPE} | {@link GL30#GL_TEXTURE_DEPTH_TYPE TEXTURE_DEPTH_TYPE} | {@link GL13#GL_TEXTURE_COMPRESSED TEXTURE_COMPRESSED} |
| {@link GL13#GL_TEXTURE_COMPRESSED_IMAGE_SIZE TEXTURE_COMPRESSED_IMAGE_SIZE} | {@link GL31#GL_TEXTURE_BUFFER_DATA_STORE_BINDING TEXTURE_BUFFER_DATA_STORE_BINDING} | {@link GL43#GL_TEXTURE_BUFFER_OFFSET TEXTURE_BUFFER_OFFSET} | {@link GL43#GL_TEXTURE_BUFFER_SIZE TEXTURE_BUFFER_SIZE} |
| {@link GL11#GL_TEXTURE_WIDTH TEXTURE_WIDTH} | {@link GL11#GL_TEXTURE_HEIGHT TEXTURE_HEIGHT} | {@link GL12#GL_TEXTURE_DEPTH TEXTURE_DEPTH} | {@link GL32#GL_TEXTURE_SAMPLES TEXTURE_SAMPLES} |
| {@link GL32#GL_TEXTURE_FIXED_SAMPLE_LOCATIONS TEXTURE_FIXED_SAMPLE_LOCATIONS} | {@link GL11#GL_TEXTURE_INTERNAL_FORMAT TEXTURE_INTERNAL_FORMAT} | {@link GL11#GL_TEXTURE_RED_SIZE TEXTURE_RED_SIZE} | {@link GL11#GL_TEXTURE_GREEN_SIZE TEXTURE_GREEN_SIZE} |
| {@link GL11#GL_TEXTURE_BLUE_SIZE TEXTURE_BLUE_SIZE} | {@link GL11#GL_TEXTURE_ALPHA_SIZE TEXTURE_ALPHA_SIZE} | {@link GL14#GL_TEXTURE_DEPTH_SIZE TEXTURE_DEPTH_SIZE} | {@link GL30#GL_TEXTURE_STENCIL_SIZE TEXTURE_STENCIL_SIZE} |
| {@link GL30#GL_TEXTURE_SHARED_SIZE TEXTURE_SHARED_SIZE} | {@link GL30#GL_TEXTURE_ALPHA_TYPE TEXTURE_ALPHA_TYPE} | {@link GL30#GL_TEXTURE_DEPTH_TYPE TEXTURE_DEPTH_TYPE} | {@link GL13#GL_TEXTURE_COMPRESSED TEXTURE_COMPRESSED} |
| {@link GL13#GL_TEXTURE_COMPRESSED_IMAGE_SIZE TEXTURE_COMPRESSED_IMAGE_SIZE} | {@link GL31#GL_TEXTURE_BUFFER_DATA_STORE_BINDING TEXTURE_BUFFER_DATA_STORE_BINDING} | {@link GL43#GL_TEXTURE_BUFFER_OFFSET TEXTURE_BUFFER_OFFSET} | {@link GL43#GL_TEXTURE_BUFFER_SIZE TEXTURE_BUFFER_SIZE} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
| {@link GL42#GL_IMAGE_FORMAT_COMPATIBILITY_TYPE IMAGE_FORMAT_COMPATIBILITY_TYPE} | {@link GL42#GL_TEXTURE_IMMUTABLE_FORMAT TEXTURE_IMMUTABLE_FORMAT} | {@link GL43#GL_TEXTURE_IMMUTABLE_LEVELS TEXTURE_IMMUTABLE_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LEVEL TEXTURE_VIEW_MIN_LEVEL} |
| {@link GL43#GL_TEXTURE_VIEW_NUM_LEVELS TEXTURE_VIEW_NUM_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LAYER TEXTURE_VIEW_MIN_LAYER} | {@link GL43#GL_TEXTURE_VIEW_NUM_LAYERS TEXTURE_VIEW_NUM_LAYERS} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
| {@link GL42#GL_IMAGE_FORMAT_COMPATIBILITY_TYPE IMAGE_FORMAT_COMPATIBILITY_TYPE} | {@link GL42#GL_TEXTURE_IMMUTABLE_FORMAT TEXTURE_IMMUTABLE_FORMAT} | {@link GL43#GL_TEXTURE_IMMUTABLE_LEVELS TEXTURE_IMMUTABLE_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LEVEL TEXTURE_VIEW_MIN_LEVEL} |
| {@link GL43#GL_TEXTURE_VIEW_NUM_LEVELS TEXTURE_VIEW_NUM_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LAYER TEXTURE_VIEW_MIN_LAYER} | {@link GL43#GL_TEXTURE_VIEW_NUM_LAYERS TEXTURE_VIEW_NUM_LAYERS} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL15#GL_ELEMENT_ARRAY_BUFFER_BINDING ELEMENT_ARRAY_BUFFER_BINDING} |
| {@link GL15#GL_ELEMENT_ARRAY_BUFFER_BINDING ELEMENT_ARRAY_BUFFER_BINDING} |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_ENABLED VERTEX_ATTRIB_ARRAY_ENABLED} | {@link GL20#GL_VERTEX_ATTRIB_ARRAY_SIZE VERTEX_ATTRIB_ARRAY_SIZE}, |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_STRIDE VERTEX_ATTRIB_ARRAY_STRIDE} | {@link GL20#GL_VERTEX_ATTRIB_ARRAY_TYPE VERTEX_ATTRIB_ARRAY_TYPE} |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_NORMALIZED VERTEX_ATTRIB_ARRAY_NORMALIZED} | {@link GL30#GL_VERTEX_ATTRIB_ARRAY_INTEGER VERTEX_ATTRIB_ARRAY_INTEGER} |
| {@link GL33#GL_VERTEX_ATTRIB_ARRAY_DIVISOR VERTEX_ATTRIB_ARRAY_DIVISOR} | {@link GL43#GL_VERTEX_ATTRIB_ARRAY_LONG VERTEX_ATTRIB_ARRAY_LONG} |
| {@link GL43#GL_VERTEX_ATTRIB_RELATIVE_OFFSET VERTEX_ATTRIB_RELATIVE_OFFSET} |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_ENABLED VERTEX_ATTRIB_ARRAY_ENABLED} | {@link GL20#GL_VERTEX_ATTRIB_ARRAY_SIZE VERTEX_ATTRIB_ARRAY_SIZE}, |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_STRIDE VERTEX_ATTRIB_ARRAY_STRIDE} | {@link GL20#GL_VERTEX_ATTRIB_ARRAY_TYPE VERTEX_ATTRIB_ARRAY_TYPE} |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_NORMALIZED VERTEX_ATTRIB_ARRAY_NORMALIZED} | {@link GL30#GL_VERTEX_ATTRIB_ARRAY_INTEGER VERTEX_ATTRIB_ARRAY_INTEGER} |
| {@link GL33#GL_VERTEX_ATTRIB_ARRAY_DIVISOR VERTEX_ATTRIB_ARRAY_DIVISOR} | {@link GL43#GL_VERTEX_ATTRIB_ARRAY_LONG VERTEX_ATTRIB_ARRAY_LONG} |
| {@link GL43#GL_VERTEX_ATTRIB_RELATIVE_OFFSET VERTEX_ATTRIB_RELATIVE_OFFSET} |
| {@link GL43#GL_VERTEX_BINDING_OFFSET VERTEX_BINDING_OFFSET} |
| {@link GL43#GL_VERTEX_BINDING_OFFSET VERTEX_BINDING_OFFSET} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
This extension extends {@link ARBFragmentProgram ARB_fragment_program} and {@link ARBFragmentShader ARB_fragment_shader} to allow multiple output colors, and provides a mechanism for + * directing those outputs to multiple color buffers.
+ * + *Requires {@link GL13 OpenGL 1.3}. Promoted to core in {@link GL20 OpenGL 2.0}.
+ */ +public class ARBDrawBuffers { + + /** Accepted by the {@code pname} parameters of GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_MAX_DRAW_BUFFERS_ARB = 0x8824, + GL_DRAW_BUFFER0_ARB = 0x8825, + GL_DRAW_BUFFER1_ARB = 0x8826, + GL_DRAW_BUFFER2_ARB = 0x8827, + GL_DRAW_BUFFER3_ARB = 0x8828, + GL_DRAW_BUFFER4_ARB = 0x8829, + GL_DRAW_BUFFER5_ARB = 0x882A, + GL_DRAW_BUFFER6_ARB = 0x882B, + GL_DRAW_BUFFER7_ARB = 0x882C, + GL_DRAW_BUFFER8_ARB = 0x882D, + GL_DRAW_BUFFER9_ARB = 0x882E, + GL_DRAW_BUFFER10_ARB = 0x882F, + GL_DRAW_BUFFER11_ARB = 0x8830, + GL_DRAW_BUFFER12_ARB = 0x8831, + GL_DRAW_BUFFER13_ARB = 0x8832, + GL_DRAW_BUFFER14_ARB = 0x8833, + GL_DRAW_BUFFER15_ARB = 0x8834; + + static { GL.initialize(); } + + protected ARBDrawBuffers() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDrawBuffersARB + ); + } + + // --- [ glDrawBuffersARB ] --- + + /** + * Unsafe version of: {@link #glDrawBuffersARB DrawBuffersARB} + * + * @param n the number of buffers in {@code bufs} + */ + public static native void nglDrawBuffersARB(int n, long bufs); + + /** + * Defines the draw buffers to which all output colors are written. + * + * @param bufs a buffer of symbolic constants specifying the buffer to which each output color is written. One of:| {@link GL11#GL_NONE NONE} | {@link GL11#GL_FRONT_LEFT FRONT_LEFT} | {@link GL11#GL_FRONT_RIGHT FRONT_RIGHT} | {@link GL11#GL_BACK_LEFT BACK_LEFT} | {@link GL11#GL_BACK_RIGHT BACK_RIGHT} | {@link GL11#GL_AUX0 AUX0} | {@link GL11#GL_AUX1 AUX1} | {@link GL11#GL_AUX2 AUX2} |
| {@link GL11#GL_AUX3 AUX3} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | GL30.GL_COLOR_ATTACHMENT[1-15] |
This extension builds upon the {@link ARBDrawBuffers ARB_draw_buffers} and {@link EXTDrawBuffers2 EXT_draw_buffers2} extensions. In ARB_draw_buffers (part of OpenGL 2.0), separate + * values could be written to each color buffer. This was further enhanced by EXT_draw_buffers2 by adding in the ability to enable blending and to set + * color write masks independently per color output.
+ * + *This extension provides the ability to set individual blend equations and blend functions for each color output.
+ * + *Requires {@link GL20 OpenGL 2.0} and {@link EXTDrawBuffers2 EXT_draw_buffers2}. Promoted to core in {@link GL40 OpenGL 4.0}.
+ */ +public class ARBDrawBuffersBlend { + + static { GL.initialize(); } + + protected ARBDrawBuffersBlend() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBlendEquationiARB, caps.glBlendEquationSeparateiARB, caps.glBlendFunciARB, caps.glBlendFuncSeparateiARB + ); + } + + // --- [ glBlendEquationiARB ] --- + + /** + * Provides a way to enable blending and set color write masks independently per color output. + * + *This call modifies the blend equations associated with an individual draw buffer.
+ * + *The error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} is generated if the {@code buf} parameter is outside the range [0, {@link GL20#GL_MAX_DRAW_BUFFERS MAX_DRAW_BUFFERS} – 1].
+ * + *The error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} is generated if {@code mode} is not one of {@link GL14#GL_FUNC_ADD FUNC_ADD}, {@link GL14#GL_FUNC_SUBTRACT FUNC_SUBTRACT}, + * {@link GL14#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT}, {@link GL14#GL_MAX MAX}, or {@link GL14#GL_MIN MIN}.
+ * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if this method is executed between the execution of {@link GL11#glBegin Begin} and the corresponding execution + * of {@link GL11#glEnd End}.
+ * + * @param buf an integer that indicates the {@link GL11#GL_DRAW_BUFFER DRAW_BUFFER} to modify. + * @param mode determines both the RGB and alpha blend equations. One of:| {@link GL14#GL_FUNC_ADD FUNC_ADD} | {@link GL14#GL_FUNC_SUBTRACT FUNC_SUBTRACT} | {@link GL14#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} | {@link GL14#GL_MIN MIN} | {@link GL14#GL_MAX MAX} |
This call modifies the blend equations associated with an individual draw buffer.
+ * + *The error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} is generated if the {@code buf} parameter is outside the range [0, {@link GL20#GL_MAX_DRAW_BUFFERS MAX_DRAW_BUFFERS} – 1].
+ * + *The error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} is generated if either {@code modeRGB} or {@code modeAlpha} are not one of {@link GL14#GL_FUNC_ADD FUNC_ADD}, + * {@link GL14#GL_FUNC_SUBTRACT FUNC_SUBTRACT}, {@link GL14#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT}, {@link GL14#GL_MAX MAX}, or {@link GL14#GL_MIN MIN}.
+ * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if this method is executed between the execution of {@link GL11#glBegin Begin} and the corresponding execution + * of {@link GL11#glEnd End}.
+ * + * @param buf an integer that indicates the {@link GL11#GL_DRAW_BUFFER DRAW_BUFFER} to modify. + * @param modeRGB the RGB blend equation. One of:| {@link GL14#GL_FUNC_ADD FUNC_ADD} | {@link GL14#GL_FUNC_SUBTRACT FUNC_SUBTRACT} | {@link GL14#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} | {@link GL14#GL_MIN MIN} | {@link GL14#GL_MAX MAX} |
| {@link GL14#GL_FUNC_ADD FUNC_ADD} | {@link GL14#GL_FUNC_SUBTRACT FUNC_SUBTRACT} | {@link GL14#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} | {@link GL14#GL_MIN MIN} | {@link GL14#GL_MAX MAX} |
This call modifies the blend functions associated with an individual draw buffer.
+ * + *The error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} is generated if the {@code buf} parameter is outside the range [0, {@link GL20#GL_MAX_DRAW_BUFFERS MAX_DRAW_BUFFERS} – 1].
+ * + *The error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} is generated if either {@code src}, or {@code dst} is not an accepted value.
+ * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if this method is executed between the execution of {@link GL11#glBegin Begin} and the corresponding execution + * of {@link GL11#glEnd End}.
+ * + * @param buf an integer that indicates the {@link GL11#GL_DRAW_BUFFER DRAW_BUFFER} to modify. + * @param src determines both RGB and alpha source functions + * @param dst determines both RGB and alpha destination functions + */ + public static native void glBlendFunciARB(@NativeType("GLuint") int buf, @NativeType("GLenum") int src, @NativeType("GLenum") int dst); + + // --- [ glBlendFuncSeparateiARB ] --- + + /** + * Provides a way to enable blending and set color write masks independently per color output. + * + *This call modifies the blend functions associated with an individual draw buffer.
+ * + *The error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} is generated if the {@code buf} parameter is outside the range [0, {@link GL20#GL_MAX_DRAW_BUFFERS MAX_DRAW_BUFFERS} – 1].
+ * + *The error {@link GL11#GL_INVALID_ENUM INVALID_ENUM} is generated if either {@code srcRGB}, {@code dstRGB}, {@code srcAlpha}, or {@code dstAlpha} is not an accepted value.
+ * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if this method is executed between the execution of {@link GL11#glBegin Begin} and the corresponding execution + * of {@link GL11#glEnd End}.
+ * + * @param buf an integer that indicates the {@link GL11#GL_DRAW_BUFFER DRAW_BUFFER} to modify. + * @param srcRGB the source RGB blend function + * @param dstRGB the destination RGB blend function + * @param srcAlpha the source alpha blend function + * @param dstAlpha the destination alpha blend function + */ + public static native void glBlendFuncSeparateiARB(@NativeType("GLuint") int buf, @NativeType("GLenum") int srcRGB, @NativeType("GLenum") int dstRGB, @NativeType("GLenum") int srcAlpha, @NativeType("GLenum") int dstAlpha); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDrawElementsBaseVertex.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDrawElementsBaseVertex.java new file mode 100644 index 00000000..3ddba417 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBDrawElementsBaseVertex.java @@ -0,0 +1,340 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_draw_elements_base_vertex extension. + * + *This extension provides a method to specify a "base vertex offset" value which is effectively added to every vertex index that is transferred through + * {@link GL11C#glDrawElements DrawElements}.
+ * + *This mechanism can be used to decouple a set of indices from the actual vertex array that it is referencing. This is useful if an application stores + * multiple indexed models in a single vertex array. The same index array can be used to draw the model no matter where it ends up in a larger vertex array + * simply by changing the base vertex value. Without this functionality, it would be necessary to rebind all the vertex attributes every time geometry is + * switched and this can have larger performance penalty.
+ * + *For example consider the (very contrived and simple) example of drawing two triangles to form a quad. In the typical example you have the following + * setup:
+ * + *
+ * vertices indices
+ * ---------- -----
+ * 0 | (-1, 1) | 0 | 0 |
+ * 1 | (-1, -1) | 1 | 1 |
+ * 2 | ( 1, -1) | 2 | 2 |
+ * 3 | ( 1, 1) | 3 | 3 |
+ * ---------- 4 | 0 |
+ * 5 | 2 |
+ * -----which is normally rendered with the call
+ * + *
+ * DrawElements(TRIANGLES, 6, UNSIGNED_BYTE, &indices).Now consider the case where the vertices you want to draw are not at the start of a vertex array but are instead located at offset 100 into a larger + * array:
+ * + *
+ * vertices2 indices2
+ * ---------- -----
+ * .... 0 | 100 |
+ * 100 | (-1, 1) | 1 | 101 |
+ * 101 | (-1, -1) | 2 | 102 |
+ * 102 | ( 1, -1) | 3 | 103 |
+ * 103 | ( 1, 1) | 4 | 100 |
+ * .... 5 | 102 |
+ * ---------- -----The typical choices for rendering this are to rebind your vertex attributes with an additional offset of 100*stride, or to create an new array of + * indices (as indices2 in the example). However both rebinding vertex attributes and rebuilding index arrays can be quite costly activities.
+ * + *With the new drawing commands introduced by this extension you can instead draw using vertices2 and the new draw call:
+ * + *
+ * DrawElementsBaseVertex(TRIANGLES, 6, UNSIGNED_BYTE, &indices, 100)Promoted to core in {@link GL32 OpenGL 3.2}.
+ */ +public class ARBDrawElementsBaseVertex { + + static { GL.initialize(); } + + protected ARBDrawElementsBaseVertex() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDrawElementsBaseVertex, caps.glDrawRangeElementsBaseVertex, caps.glDrawElementsInstancedBaseVertex, caps.glMultiDrawElementsBaseVertex + ); + } + + // --- [ glDrawElementsBaseVertex ] --- + + /** + * Unsafe version of: {@link #glDrawElementsBaseVertex DrawElementsBaseVertex} + * + * @param count the number of elements to be rendered + * @param type the type of the values in {@code indices}. One of:| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
LWJGL note: Use {@link org.lwjgl.system.MemoryUtil#memAddress} to retrieve pointers to the index buffers.
+ * + * @param mode the kind of primitives to render. One of:| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
This extension provides a mechanism for supplying the arguments to a + * DrawArraysInstanced or DrawElementsInstancedBaseVertex from buffer object + * memory. This is not particularly useful for applications where the CPU + * knows the values of the arguments beforehand, but is helpful when the + * values will be generated on the GPU through any mechanism that can write + * to a buffer object including image stores, atomic counters, or compute + * interop. This allows the GPU to consume these arguments without a round- + * trip to the CPU or the expensive synchronization that would involve. This + * is similar to the DrawTransformFeedbackEXT command from + * EXT_transform_feedback2, but offers much more flexibility in both + * generating the arguments and in the type of Draws that can be accomplished.
+ * + *Requires {@link GL31 OpenGL 3.1}. Promoted to core in {@link GL40 OpenGL 4.0}.
+ */ +public class ARBDrawIndirect { + + /** + * Accepted by the {@code target} parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, GetBufferPointerv, + * MapBufferRange, FlushMappedBufferRange, GetBufferParameteriv, and CopyBufferSubData. + */ + public static final int GL_DRAW_INDIRECT_BUFFER = 0x8F3F; + + /** Accepted by the {@code value} parameter of GetIntegerv, GetBooleanv, GetFloatv, and GetDoublev. */ + public static final int GL_DRAW_INDIRECT_BUFFER_BINDING = 0x8F43; + + static { GL.initialize(); } + + protected ARBDrawIndirect() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDrawArraysIndirect, caps.glDrawElementsIndirect + ); + } + + // --- [ glDrawArraysIndirect ] --- + + /** Unsafe version of: {@link #glDrawArraysIndirect DrawArraysIndirect} */ + public static void nglDrawArraysIndirect(int mode, long indirect) { + GL40C.nglDrawArraysIndirect(mode, indirect); + } + + /** + * Renders primitives from array data, taking parameters from memory. + * + *{@code glDrawArraysIndirect} behaves similarly to {@link GL42C#glDrawArraysInstancedBaseInstance DrawArraysInstancedBaseInstance}, except that the parameters to + * glDrawArraysInstancedBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance; // must be 0 unless OpenGL 4.2 is supported
+ * } DrawArraysIndirectCommand;
+ *
+ * const DrawArraysIndirectCommand *cmd = (const DrawArraysIndirectCommand *)indirect;
+ * glDrawArraysInstancedBaseInstance(mode, cmd->first, cmd->count, cmd->primCount, cmd->baseInstance);| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
{@code glDrawArraysIndirect} behaves similarly to {@link GL42C#glDrawArraysInstancedBaseInstance DrawArraysInstancedBaseInstance}, except that the parameters to + * glDrawArraysInstancedBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance; // must be 0 unless OpenGL 4.2 is supported
+ * } DrawArraysIndirectCommand;
+ *
+ * const DrawArraysIndirectCommand *cmd = (const DrawArraysIndirectCommand *)indirect;
+ * glDrawArraysInstancedBaseInstance(mode, cmd->first, cmd->count, cmd->primCount, cmd->baseInstance);| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
{@code glDrawArraysIndirect} behaves similarly to {@link GL42C#glDrawArraysInstancedBaseInstance DrawArraysInstancedBaseInstance}, except that the parameters to + * glDrawArraysInstancedBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance; // must be 0 unless OpenGL 4.2 is supported
+ * } DrawArraysIndirectCommand;
+ *
+ * const DrawArraysIndirectCommand *cmd = (const DrawArraysIndirectCommand *)indirect;
+ * glDrawArraysInstancedBaseInstance(mode, cmd->first, cmd->count, cmd->primCount, cmd->baseInstance);| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
{@code glDrawElementsIndirect} behaves similarly to {@link GL42C#glDrawElementsInstancedBaseVertexBaseInstance DrawElementsInstancedBaseVertexBaseInstance}, execpt that the parameters to + * glDrawElementsInstancedBaseVertexBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;{@code glDrawElementsIndirect} is equivalent to:
+ * + *
+ * void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect) {
+ * const DrawElementsIndirectCommand *cmd = (const DrawElementsIndirectCommand *)indirect;
+ * glDrawElementsInstancedBaseVertexBaseInstance(
+ * mode,
+ * cmd->count,
+ * type,
+ * cmd->firstIndex + size-of-type,
+ * cmd->primCount,
+ * cmd->baseVertex,
+ * cmd->baseInstance
+ * );
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
{@code glDrawElementsIndirect} behaves similarly to {@link GL42C#glDrawElementsInstancedBaseVertexBaseInstance DrawElementsInstancedBaseVertexBaseInstance}, execpt that the parameters to + * glDrawElementsInstancedBaseVertexBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;{@code glDrawElementsIndirect} is equivalent to:
+ * + *
+ * void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect) {
+ * const DrawElementsIndirectCommand *cmd = (const DrawElementsIndirectCommand *)indirect;
+ * glDrawElementsInstancedBaseVertexBaseInstance(
+ * mode,
+ * cmd->count,
+ * type,
+ * cmd->firstIndex + size-of-type,
+ * cmd->primCount,
+ * cmd->baseVertex,
+ * cmd->baseInstance
+ * );
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
{@code glDrawElementsIndirect} behaves similarly to {@link GL42C#glDrawElementsInstancedBaseVertexBaseInstance DrawElementsInstancedBaseVertexBaseInstance}, execpt that the parameters to + * glDrawElementsInstancedBaseVertexBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;{@code glDrawElementsIndirect} is equivalent to:
+ * + *
+ * void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect) {
+ * const DrawElementsIndirectCommand *cmd = (const DrawElementsIndirectCommand *)indirect;
+ * glDrawElementsInstancedBaseVertexBaseInstance(
+ * mode,
+ * cmd->count,
+ * type,
+ * cmd->firstIndex + size-of-type,
+ * cmd->primCount,
+ * cmd->baseVertex,
+ * cmd->baseInstance
+ * );
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
A common use case in GL for some applications is to be able to draw the same object, or groups of similar objects that share vertex data, primitive + * count and type, multiple times. This extension provides a means of accelerating such use cases while restricting the number of API calls, and keeping + * the amount of duplicate data to a minimum.
+ * + *This extension introduces two draw calls which are conceptually equivalent to a series of draw calls. Each conceptual call in this series is considered + * an "instance" of the actual draw call.
+ * + *This extension also introduces a read-only built-in variable to GLSL which contains the "instance ID." This variable initially contains 0, but increases + * by one after each conceptual draw call.
+ * + *By using the instance ID or multiples thereof as an index into a uniform array containing transform data, vertex shaders can draw multiple instances of + * an object with a single draw call.
+ * + *Requires {@link GL30 OpenGL 3.0} or {@link EXTGPUShader4 EXT_gpu_shader4} or NV_vertex_program4. Promoted to core in {@link GL31 OpenGL 3.1}.
+ */ +public class ARBDrawInstanced { + + static { GL.initialize(); } + + protected ARBDrawInstanced() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDrawArraysInstancedARB, caps.glDrawElementsInstancedARB + ); + } + + // --- [ glDrawArraysInstancedARB ] --- + + /** + * Draw multiple instances of a range of elements. + * + * @param mode the kind of primitives to render. One of:| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
This extension adds support for features of OpenGL ES 2.0 that are missing from OpenGL 3.x. Enabling these features will ease the process of porting + * applications from OpenGL ES 2.0 to OpenGL.
+ * + *Promoted to core in {@link GL41 OpenGL 4.1}.
+ */ +public class ARBES2Compatibility { + + /** Accepted by the {@code value} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int + GL_SHADER_COMPILER = 0x8DFA, + GL_SHADER_BINARY_FORMATS = 0x8DF8, + GL_NUM_SHADER_BINARY_FORMATS = 0x8DF9, + GL_MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB, + GL_MAX_VARYING_VECTORS = 0x8DFC, + GL_MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD, + GL_IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A, + GL_IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B; + + /** Accepted by the {@code type} parameter of VertexAttribPointer. */ + public static final int GL_FIXED = 0x140C; + + /** Accepted by the {@code precisiontype} parameter of GetShaderPrecisionFormat. */ + public static final int + GL_LOW_FLOAT = 0x8DF0, + GL_MEDIUM_FLOAT = 0x8DF1, + GL_HIGH_FLOAT = 0x8DF2, + GL_LOW_INT = 0x8DF3, + GL_MEDIUM_INT = 0x8DF4, + GL_HIGH_INT = 0x8DF5; + + /** Accepted by the {@code format} parameter of most commands taking sized internal formats. */ + public static final int GL_RGB565 = 0x8D62; + + static { GL.initialize(); } + + protected ARBES2Compatibility() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glReleaseShaderCompiler, caps.glShaderBinary, caps.glGetShaderPrecisionFormat, caps.glDepthRangef, caps.glClearDepthf + ); + } + + // --- [ glReleaseShaderCompiler ] --- + + /** Releases resources allocated by the shader compiler. This is a hint from the application, and does not prevent later use of the shader compiler. */ + public static void glReleaseShaderCompiler() { + GL41C.glReleaseShaderCompiler(); + } + + // --- [ glShaderBinary ] --- + + /** + * Unsafe version of: {@link #glShaderBinary ShaderBinary} + * + * @param count the number of shader object handles contained in {@code shaders} + * @param length the length of the array whose address is given in binary + */ + public static void nglShaderBinary(int count, long shaders, int binaryformat, long binary, int length) { + GL41C.nglShaderBinary(count, shaders, binaryformat, binary, length); + } + + /** + * Loads pre-compiled shader binaries. + * + * @param shaders an array of shader handles into which to load pre-compiled shader binaries + * @param binaryformat the format of the shader binaries contained in {@code binary} + * @param binary an array of bytes containing pre-compiled binary shader code + */ + public static void glShaderBinary(@NativeType("GLuint const *") IntBuffer shaders, @NativeType("GLenum") int binaryformat, @NativeType("void const *") ByteBuffer binary) { + GL41C.glShaderBinary(shaders, binaryformat, binary); + } + + // --- [ glGetShaderPrecisionFormat ] --- + + /** Unsafe version of: {@link #glGetShaderPrecisionFormat GetShaderPrecisionFormat} */ + public static void nglGetShaderPrecisionFormat(int shadertype, int precisiontype, long range, long precision) { + GL41C.nglGetShaderPrecisionFormat(shadertype, precisiontype, range, precision); + } + + /** + * Retrieves the range and precision for numeric formats supported by the shader compiler. + * + * @param shadertype the type of shader whose precision to query. One of:| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} |
This extension adds support for features of OpenGL ES 3.1 that are missing from OpenGL 4.4. Enabling these features will ease the process of porting + * applications from OpenGL ES 3.1 to OpenGL. Enabling these features will ease the process of porting applications from OpenGL ES 3.1 to OpenGL.
+ * + *In particular this adds the following features:
+ * + *Requires {@link GL44 OpenGL 4.4}, {@link ARBES2Compatibility ARB_ES2_compatibility}, {@link ARBES3Compatibility ARB_ES3_compatibility}. Promoted to core in {@link GL45 OpenGL 4.5}.
+ */ +public class ARBES31Compatibility { + + static { GL.initialize(); } + + protected ARBES31Compatibility() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glMemoryBarrierByRegion + ); + } + + // --- [ glMemoryBarrierByRegion ] --- + + /** + * Behaves like {@link GL42C#glMemoryBarrier MemoryBarrier}, with two differences: + * + *First, it narrows the region under consideration so that only reads/writes of prior fragment shaders that are invoked for a smaller region of the + * framebuffer will be completed/reflected prior to subsequent reads/write of following fragment shaders. The size of the region is implementation + * dependent and may be as small as one framebuffer pixel.
+ * + *Second, it only applies to memory transactions that may be read by or written by a fragment shader.
+ * + *When barriers is {@link GL42#GL_ALL_BARRIER_BITS ALL_BARRIER_BITS}, shader memory accesses will be synchronized relative to all these barrier bits, but not to other + * barrier bits specific to {@link GL42C#glMemoryBarrier MemoryBarrier}. This implies that reads/writes for scatter/gather-like algorithms may or may not be + * completed/reflected after a MemoryBarrierByRegion command. However, for uses such as deferred shading, where a linked list of visible + * surfaces with the head at a framebuffer address may be constructed, and the entirety of the list is only dependent on previous executions at that + * framebuffer address, MemoryBarrierByRegion may be significantly more efficient than {@link GL42C#glMemoryBarrier MemoryBarrier}.
+ * + * @param barriers the barriers to insert. One or more of:| {@link GL42#GL_ATOMIC_COUNTER_BARRIER_BIT ATOMIC_COUNTER_BARRIER_BIT} | {@link GL42#GL_FRAMEBUFFER_BARRIER_BIT FRAMEBUFFER_BARRIER_BIT} | {@link GL42#GL_SHADER_IMAGE_ACCESS_BARRIER_BIT SHADER_IMAGE_ACCESS_BARRIER_BIT} |
| {@link GL43#GL_SHADER_STORAGE_BARRIER_BIT SHADER_STORAGE_BARRIER_BIT} | {@link GL42#GL_TEXTURE_FETCH_BARRIER_BIT TEXTURE_FETCH_BARRIER_BIT} | {@link GL42#GL_UNIFORM_BARRIER_BIT UNIFORM_BARRIER_BIT} |
This extension adds support for features of OpenGL ES 3.2 that are missing from OpenGL 4.5. Enabling these features will ease the process of porting + * applications from OpenGL ES 3.2 to OpenGL.
+ * + *In particular this adds the following features:
+ * + *For full OpenGL ES 3.2 compatibility the implementation must support {@link KHRBlendEquationAdvanced KHR_blend_equation_advanced} and {@link KHRTextureCompressionASTCLDR KHR_texture_compression_astc_ldr}. + * Those features are not defined in this extension spec since they are already defined at the KHR level.
+ * + *Requires {@link GL45 OpenGL 4.5}, {@link ARBES2Compatibility ARB_ES2_compatibility}, {@link ARBES3Compatibility ARB_ES3_compatibility} and {@link ARBES31Compatibility ARB_ES3_1_compatibility}.
+ */ +public class ARBES32Compatibility { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetFloatv, GetIntegerv, and GetInteger64v. */ + public static final int + GL_PRIMITIVE_BOUNDING_BOX_ARB = 0x92BE, + GL_MULTISAMPLE_LINE_WIDTH_RANGE_ARB = 0x9381, + GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY_ARB = 0x9382; + + static { GL.initialize(); } + + protected ARBES32Compatibility() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glPrimitiveBoundingBoxARB + ); + } + + // --- [ glPrimitiveBoundingBoxARB ] --- + + /** + * Specifies the primitive bounding box. + * + *Implementations may be able to optimize performance if the application provides bounds of primitives that will be generated by the tessellation + * primitive generator or the geometry shader prior to executing those stages. If the provided bounds are incorrect and primitives extend beyond them, the + * rasterizer may or may not generate fragments for the portions of primitives outside the bounds.
+ * + * @param minX the minimum x clip space coordinate + * @param minY the minimum y clip space coordinate + * @param minZ the minimum z clip space coordinate + * @param minW the minimum w clip space coordinate + * @param maxX the maximum x clip space coordinate + * @param maxY the maximum y clip space coordinate + * @param maxZ the maximum z clip space coordinate + * @param maxW the maximum w clip space coordinate + */ + public static native void glPrimitiveBoundingBoxARB(@NativeType("GLfloat") float minX, @NativeType("GLfloat") float minY, @NativeType("GLfloat") float minZ, @NativeType("GLfloat") float minW, @NativeType("GLfloat") float maxX, @NativeType("GLfloat") float maxY, @NativeType("GLfloat") float maxZ, @NativeType("GLfloat") float maxW); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBES3Compatibility.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBES3Compatibility.java new file mode 100644 index 00000000..7be5cdb3 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBES3Compatibility.java @@ -0,0 +1,43 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_ES3_compatibility extension. + * + *This extension adds support for features of OpenGL ES 3.0 that are missing from OpenGL 3.x. Enabling these features will ease the process of porting + * applications from OpenGL ES 3.0 to OpenGL. These features include conservative boolean occlusion queries, primitive restart with a fixed index, the + * OpenGL ES Shading Language 3.00 specification, and the dependencies stated below.
+ * + *Requires {@link GL33 OpenGL 3.3}, {@link ARBES2Compatibility ARB_ES2_compatibility}, {@link ARBInvalidateSubdata ARB_invalidate_subdata} and {@link ARBTextureStorage ARB_texture_storage}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public final class ARBES3Compatibility { + + /** Accepted by the {@code internalformat} parameter of CompressedTexImage2D. */ + public static final int + GL_COMPRESSED_RGB8_ETC2 = 0x9274, + GL_COMPRESSED_SRGB8_ETC2 = 0x9275, + GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276, + GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277, + GL_COMPRESSED_RGBA8_ETC2_EAC = 0x9278, + GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279, + GL_COMPRESSED_R11_EAC = 0x9270, + GL_COMPRESSED_SIGNED_R11_EAC = 0x9271, + GL_COMPRESSED_RG11_EAC = 0x9272, + GL_COMPRESSED_SIGNED_RG11_EAC = 0x9273; + + /** Accepted by the {@code target} parameter of Enable and Disable. */ + public static final int GL_PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69; + + /** Accepted by the {@code target} parameter of BeginQuery, EndQuery, GetQueryIndexediv and GetQueryiv. */ + public static final int GL_ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A; + + /** Accepted by the {@code value} parameter of the GetInteger functions. */ + public static final int GL_MAX_ELEMENT_INDEX = 0x8D6B; + + private ARBES3Compatibility() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBEnhancedLayouts.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBEnhancedLayouts.java new file mode 100644 index 00000000..299622ba --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBEnhancedLayouts.java @@ -0,0 +1,35 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_enhanced_layouts extension. + * + *This extension adds the following functionality to layout qualifiers, including broadening the API where this functionality is reflected. The following + * are added:
+ * + *Requires {@link GL31 OpenGL 3.1} and GLSL 1.40. Promoted to core in {@link GL44 OpenGL 4.4}.
+ */ +public final class ARBEnhancedLayouts { + + /** Accepted in the {@code props} array of {@link GL43C#glGetProgramResourceiv GetProgramResourceiv}. */ + public static final int + GL_LOCATION_COMPONENT = 0x934A, + GL_TRANSFORM_FEEDBACK_BUFFER_INDEX = 0x934B, + GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE = 0x934C; + + private ARBEnhancedLayouts() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBExplicitUniformLocation.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBExplicitUniformLocation.java new file mode 100644 index 00000000..f6d92f75 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBExplicitUniformLocation.java @@ -0,0 +1,24 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_explicit_uniform_location extension. + * + *This extension provides a method to pre-assign uniform locations to uniform variables in the default uniform block, including subroutine uniforms. This + * allows an application to modify the uniform values without requiring a GL query like {@link GL20C#glGetUniformLocation GetUniformLocation}, {@link GL40C#glGetSubroutineUniformLocation GetSubroutineUniformLocation} and + * {@link GL40C#glGetSubroutineIndex GetSubroutineIndex}.
+ * + *Requires {@link GL33 OpenGL 3.3} or ARB_explicit_attrib_location. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public final class ARBExplicitUniformLocation { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, GetDoublev, and GetInteger64v. */ + public static final int GL_MAX_UNIFORM_LOCATIONS = 0x826E; + + private ARBExplicitUniformLocation() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBFragmentProgram.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBFragmentProgram.java new file mode 100644 index 00000000..d3f02be7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBFragmentProgram.java @@ -0,0 +1,74 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_fragment_program extension. + * + *Unextended OpenGL mandates a certain set of configurable per- fragment computations defining texture application, texture environment, color sum, and + * fog operations. Several extensions have added further per-fragment computations to OpenGL. For example, extensions have defined new texture environment + * capabilities (ARB_texture_env_add, {@link ARBTextureEnvCombine ARB_texture_env_combine}, {@link ARBTextureEnvDot3 ARB_texture_env_dot3}, ARB_texture_env_crossbar), per-fragment depth + * comparisons ({@link ARBDepthTexture ARB_depth_texture}, {@link ARBShadow ARB_shadow}, {@link ARBShadowAmbient ARB_shadow_ambient}, EXT_shadow_funcs), per-fragment lighting + * (EXT_fragment_lighting, EXT_light_texture), and environment mapped bump mapping + * (ATI_envmap_bumpmap).
+ * + *Each such extension adds a small set of relatively inflexible per-fragment computations.
+ * + *This inflexibility is in contrast to the typical flexibility provided by the underlying programmable floating point engines (whether micro-coded + * fragment engines, DSPs, or CPUs) that are traditionally used to implement OpenGL's texturing computations. The purpose of this extension is to expose to + * the OpenGL application writer a significant degree of per-fragment programmability for computing fragment parameters.
+ * + *For the purposes of discussing this extension, a fragment program is a sequence of floating-point 4-component vector operations that determines how a + * set of program parameters (not specific to an individual fragment) and an input set of per-fragment parameters are transformed to a set of per-fragment + * result parameters.
+ * + *The per-fragment computations for standard OpenGL given a particular set of texture and fog application modes (along with any state for extensions + * defining per-fragment computations) is, in essence, a fragment program. However, the sequence of operations is defined implicitly by the current OpenGL + * state settings rather than defined explicitly as a sequence of instructions.
+ * + *This extension provides an explicit mechanism for defining fragment program instruction sequences for application-defined fragment programs. In order to + * define such fragment programs, this extension defines a fragment programming model including a floating-point 4-component vector instruction set and a + * relatively large set of floating-point 4-component registers.
+ * + *The extension's fragment programming model is designed for efficient hardware implementation and to support a wide variety of fragment programs. By + * design, the entire set of existing fragment programs defined by existing OpenGL per-fragment computation extensions can be implemented using the + * extension's fragment programming model.
+ * + *LWJGL: This extension defines many functions and tokens that are also defined in {@link ARBVertexProgram ARB_vertex_program}. Since these two extensions are often + * used together, the common functionality has only been exposed by {@link ARBVertexProgram ARB_vertex_program}, to avoid static import conflicts.
+ */ +public final class ARBFragmentProgram { + + /** + * Accepted by the {@code cap} parameter of Disable, Enable, and IsEnabled, by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev, and by the {@code target} parameter of ProgramStringARB, BindProgramARB, ProgramEnvParameter4[df][v]ARB, ProgramLocalParameter4[df][v]ARB, + * GetProgramEnvParameter[df]vARB, GetProgramLocalParameter[df]vARB, GetProgramivARB and GetProgramStringARB. + */ + public static final int GL_FRAGMENT_PROGRAM_ARB = 0x8804; + + /** Accepted by the {@code pname} parameter of GetProgramivARB. */ + public static final int + GL_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x8805, + GL_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x8806, + GL_PROGRAM_TEX_INDIRECTIONS_ARB = 0x8807, + GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x8808, + GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x8809, + GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x880A, + GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x880B, + GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x880C, + GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 0x880D, + GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x880E, + GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x880F, + GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x8810; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_MAX_TEXTURE_COORDS_ARB = 0x8871, + GL_MAX_TEXTURE_IMAGE_UNITS_ARB = 0x8872; + + private ARBFragmentProgram() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBFragmentShader.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBFragmentShader.java new file mode 100644 index 00000000..f9cc2f30 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBFragmentShader.java @@ -0,0 +1,32 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_fragment_shader extension. + * + *This extension adds functionality to define fragment shader objects. A fragment shader object is a shader object (see the ARB_shader_objects extension) + * that, when attached to a program object, can be compiled and linked to produce an executable that runs on the fragment processor in OpenGL. The fragment + * processor is a programmable unit that replaces the OpenGL 1.4 fixed-function texturing, color sum and fog stages. This extension also defines how such + * an executable interacts with the fixed functionality fragment processing of OpenGL 1.4. The language is defined in the OpenGL Shading Language + * specification as the Fragment Shading Language.
+ * + *Promoted to core in {@link GL20 OpenGL 2.0}.
+ */ +public final class ARBFragmentShader { + + /** Accepted by the {@code shaderType} argument of CreateShaderObjectARB and returned by the {@code params} parameter of GetObjectParameter{fi}vARB. */ + public static final int GL_FRAGMENT_SHADER_ARB = 0x8B30; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 0x8B49; + + /** Accepted by the {@code target} parameter of Hint and the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 0x8B8B; + + private ARBFragmentShader() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBFramebufferNoAttachments.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBFramebufferNoAttachments.java new file mode 100644 index 00000000..b6ec5fcb --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBFramebufferNoAttachments.java @@ -0,0 +1,185 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the ARB_framebuffer_no_attachments extension. + * + *Framebuffer objects as introduced by {@link ARBFramebufferObject ARB_framebuffer_object} and OpenGL 3.0 provide a generalized mechanism for rendering to off-screen surfaces. + * Each framebuffer object may have depth, stencil and zero or more color attachments that can be written to by the GL. The size of the framebuffer (width, + * height, layer count, sample count) is derived from the attachments of that framebuffer. In unextended OpenGL 4.2, it is not legal to render into a + * framebuffer object that has no attachments. Such a framebuffer would be considered incomplete with the {@link GL30#GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT} + * status.
+ * + *With OpenGL 4.2 and {@link ARBShaderImageLoadStore ARB_shader_image_load_store}, fragment shaders are capable of doing random access writes to buffer and texture memory via + * image loads, stores, and atomics. This ability enables algorithms using the conventional rasterizer to generate a collection of fragments, where each + * fragment shader invocation will write its outputs to buffer or texture memory using image stores or atomics. Such algorithms may have no need to write + * color or depth values to a conventional framebuffer. However, a framebuffer with no attachments will be considered incomplete and no rasterization or + * fragment shader exectuion will occur. To avoid such errors, an application may be required to create an otherwise unnecessary "dummy" texture and attach + * it to the framebuffer (possibly with color writes masked off). If the algorithm requires the rasterizer to operate over a large number of pixels, this + * dummy texture will needlessly consume a significant amount of memory.
+ * + *This extension enables the algorithms described above to work even with a framebuffer with no attachments. Applications can specify default width, + * height, layer count, and sample count parameters for a framebuffer object. When a framebuffer with no attachments is bound, it will be considered + * complete as long as the application has specified non-zero default width and height parameters. For the purposes of rasterization, the framebuffer will + * be considered to have a width, height, layer count, and sample count derived from its default parameters. Framebuffers with one or more attachments are + * not affected by these default parameters; the size of the framebuffer will still be derived from the sizes of the attachments in that case.
+ * + *Additionally, this extension provides queryable implementation-dependent maximums for framebuffer width, height, layer count, and sample count, which + * may differ from similar limits on textures and renderbuffers. These maximums will be used to error-check the default framebuffer parameters and also + * permit implementations to expose the ability to rasterize to an attachment-less framebuffer larger than the maximum supported texture size.
+ * + *Requires {@link GL30 OpenGL 3.0} or {@link ARBFramebufferObject ARB_framebuffer_object}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public class ARBFramebufferNoAttachments { + + /** + * Accepted by the {@code pname} parameter of FramebufferParameteri, GetFramebufferParameteriv, NamedFramebufferParameteriEXT, and + * GetNamedFramebufferParameterivEXT. + */ + public static final int + GL_FRAMEBUFFER_DEFAULT_WIDTH = 0x9310, + GL_FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311, + GL_FRAMEBUFFER_DEFAULT_LAYERS = 0x9312, + GL_FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313, + GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314; + + /** Accepted by the {@code pname} parameter of GetIntegerv, GetBooleanv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int + GL_MAX_FRAMEBUFFER_WIDTH = 0x9315, + GL_MAX_FRAMEBUFFER_HEIGHT = 0x9316, + GL_MAX_FRAMEBUFFER_LAYERS = 0x9317, + GL_MAX_FRAMEBUFFER_SAMPLES = 0x9318; + + static { GL.initialize(); } + + protected ARBFramebufferNoAttachments() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.Set| {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43C#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43C#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43C#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43C#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43C#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43C#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link #GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link #GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link #GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link #GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link #GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link #GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link #GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link #GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link #GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link #GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link #GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link #GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link #GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link #GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link #GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
ARB_framebuffer_object is an extension intended to address the following goals:
+ * + *ARB_framebuffer_object defines an interface for drawing to rendering destinations other than the buffers provided to the GL by the window-system.
+ * + *In this extension, these newly defined rendering destinations are known collectively as "framebuffer-attachable images". This extension provides a + * mechanism for attaching framebuffer-attachable images to the GL framebuffer as one of the standard GL logical buffers: color, depth, and stencil. + * (Attaching a framebuffer-attachable image to the accum logical buffer is left for a future extension to define). When a framebuffer-attachable image is + * attached to the framebuffer, it is used as the source and destination of fragment operations as described in Chapter 4.
+ * + *By allowing the use of a framebuffer-attachable image as a rendering destination, this extension enables a form of "offscreen" rendering. Furthermore, + * "render to texture" is supported by allowing the images of a texture to be used as framebuffer-attachable images. A particular image of a texture object + * is selected for use as a framebuffer-attachable image by specifying the mipmap level, cube map face (for a cube map texture), and layer (for a 3D + * texture) that identifies the image. The "render to texture" semantics of this extension are similar to performing traditional rendering to the + * framebuffer, followed immediately by a call to CopyTexSubImage. However, by using this extension instead, an application can achieve the same + * effect, but with the advantage that the GL can usually eliminate the data copy that would have been incurred by calling CopyTexSubImage.
+ * + *This extension also defines a new GL object type, called a "renderbuffer", which encapsulates a single 2D pixel image. The image of renderbuffer can be + * used as a framebuffer-attachable image for generalized offscreen rendering and it also provides a means to support rendering to GL logical buffer types + * which have no corresponding texture format (stencil, accum, etc). A renderbuffer is similar to a texture in that both renderbuffers and textures can be + * independently allocated and shared among multiple contexts. The framework defined by this extension is general enough that support for attaching images + * from GL objects other than textures and renderbuffers could be added by layered extensions.
+ * + *To facilitate efficient switching between collections of framebuffer-attachable images, this extension introduces another new GL object, called a + * framebuffer object. A framebuffer object contains the state that defines the traditional GL framebuffer, including its set of images. Prior to this + * extension, it was the window-system which defined and managed this collection of images, traditionally by grouping them into a "drawable". The + * window-system API's would also provide a function (i.e., {@link WGL#wglMakeCurrent}, {@link GLX#glXMakeCurrent}, aglSetDrawable, etc.) to bind a drawable with a GL + * context (as is done in the {@link WGLARBPbuffer WGL_ARB_pbuffer} extension). In this extension however, this functionality is subsumed by the GL and the GL provides + * the function BindFramebuffer to bind a framebuffer object to the current context. Later, the context can bind back to the window-system-provided + * framebuffer in order to display rendered content.
+ * + *Previous extensions that enabled rendering to a texture have been much more complicated. One example is the combination of {@code ARB_pbuffer} and + * {@code ARB_render_texture}, both of which are window-system extensions. This combination requires calling {@code MakeCurrent}, an operation that may be + * expensive, to switch between the window and the pbuffer drawables. An application must create one pbuffer per renderable texture in order to portably + * use {@code ARB_render_texture}. An application must maintain at least one GL context per texture format, because each context can only operate on a + * single pixelformat or {@code FBConfig}. All of these characteristics make {@code ARB_render_texture} both inefficient and cumbersome to use.
+ * + *ARB_framebuffer_object, on the other hand, is both simpler to use and more efficient than ARB_render_texture. The ARB_framebuffer_object API is + * contained wholly within the GL API and has no (non-portable) window-system components. Under ARB_framebuffer_object, it is not necessary to create a + * second GL context when rendering to a texture image whose format differs from that of the window. Finally, unlike the pbuffers of + * {@code ARB_render_texture}, a single framebuffer object can facilitate rendering to an unlimited number of texture objects.
+ * + *This extension differs from EXT_framebuffer_object by splitting the framebuffer object binding point into separate DRAW and READ bindings (incorporating + * functionality introduced by EXT_framebuffer_blit). This allows copying directly from one framebuffer to another. In addition, a new high performance + * blit function is added to facilitate these blits and perform some data conversion where allowed.
+ * + *This extension also enables usage of multisampling in conjunction with renderbuffers (incorporating functionality from EXT_packed_depth_stencil), as + * follows:
+ * + *The new operation RenderbufferStorageMultisample() allocates storage for a renderbuffer object that can be used as a multisample buffer. A multisample + * render buffer image differs from a single-sample render buffer image in that a multisample image has a number of {@link GL13#GL_SAMPLES SAMPLES} that is greater than zero. + * No method is provided for creating multisample texture images.
+ * + *All of the framebuffer-attachable images attached to a framebuffer object must have the same number of {@link GL13#GL_SAMPLES SAMPLES} or else the framebuffer object is + * not "framebuffer complete". If a framebuffer object with multisample attachments is "framebuffer complete", then the framebuffer object behaves as if + * {@link GL13#GL_SAMPLE_BUFFERS SAMPLE_BUFFERS} is one.
+ * + *In traditional multisample rendering, where {@link #GL_DRAW_FRAMEBUFFER_BINDING DRAW_FRAMEBUFFER_BINDING} is zero and {@link GL13#GL_SAMPLE_BUFFERS SAMPLE_BUFFERS} is one, the GL spec states that "the color sample + * values are resolved to a single, displayable color each time a pixel is updated." There are, however, several modern hardware implementations that do + * not actually resolve for each sample update, but instead postpones the resolve operation to a later time and resolve a batch of sample updates at a + * time. This is OK as long as the implementation behaves "as if" it had resolved a sample-at-a-time. Unfortunately, however, honoring the "as if" rule can + * sometimes degrade performance.
+ * + *In contrast, when {@link #GL_DRAW_FRAMEBUFFER_BINDING DRAW_FRAMEBUFFER_BINDING} is an application-created framebuffer object, {@link GL13#GL_MULTISAMPLE MULTISAMPLE} is enabled, and {@link GL13#GL_SAMPLE_BUFFERS SAMPLE_BUFFERS} is one, + * there is no implicit per-sample-update resolve. Instead, the application explicitly controls when the resolve operation is performed. The resolve + * operation is affected by calling BlitFramebuffer where the source is a multisample application-created framebuffer object and the destination is a + * single-sample framebuffer object (either application-created or window-system provided).
+ * + *This design for multisample resolve more closely matches current hardware, but still permits implementations which choose to resolve a single sample at + * a time. If hardware that implements the multisample resolution "one sample at a time" exposes ARB_framebuffer_object, it could perform the implicit + * resolve to a driver-managed hidden surface, then read from that surface when the application calls BlitFramebuffer.
+ * + *Another motivation for granting the application explicit control over the multisample resolve operation has to do with the flexibility afforded by + * ARB_framebuffer_object. Previously, a drawable (window or pbuffer) had exclusive access to all of its buffers. There was no mechanism for sharing a + * buffer across multiple drawables. Under ARB_framebuffer_object, however, a mechanism exists for sharing a framebuffer-attachable image across several + * framebuffer objects, as well as sharing an image between a framebuffer object and a texture. If we had retained the "implicit" resolve from traditional + * multisampled rendering, and allowed the creation of "multisample" format renderbuffers, then this type of sharing would have lead to two problematic + * situations:
+ * + *Using {@link #glBlitFramebuffer BlitFramebuffer} as an explicit resolve to serialize access to the multisampled contents and eliminate the implicit per-sample resolve operation, we avoid both of these problems.
+ * + *This extension also enables usage of packed depth-stencil formats in renderbuffers (incorporating functionality from EXT_packed_depth_stencil), as + * follows:
+ * + *Many OpenGL implementations have chosen to interleave the depth and stencil buffers into one buffer, often with 24 bits of depth precision and 8 bits of + * stencil data. 32 bits is more than is needed for the depth buffer much of the time; a 24-bit depth buffer, on the other hand, requires that reads and + * writes of depth data be unaligned with respect to power-of-two boundaries. On the other hand, 8 bits of stencil data is more than sufficient for most + * applications, so it is only natural to pack the two buffers into a single buffer with both depth and stencil data. OpenGL never provides direct access + * to the buffers, so the OpenGL implementation can provide an interface to applications where it appears the one merged buffer is composed of two logical buffers.
+ * + *One disadvantage of this scheme is that OpenGL lacks any means by which this packed data can be handled efficiently. For example, when an application + * reads from the 24-bit depth buffer, using the type {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} will lose 8 bits of data, while {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} has 8 too many. Both require + * expensive format conversion operations. A 24-bit format would be no more suitable, because it would also suffer from the unaligned memory accesses that + * made the standalone 24-bit depth buffer an unattractive proposition in the first place.
+ * + *Many applications, such as parallel rendering applications, may also wish to draw to or read back from both the depth and stencil buffers at the same + * time. Currently this requires two separate operations, reducing performance. Since the buffers are interleaved, drawing to or reading from both should + * be no more expensive than using just one; in some cases, it may even be cheaper.
+ * + *This extension provides a new data format, {@link #GL_DEPTH_STENCIL DEPTH_STENCIL}, that can be used with the {@link GL11#glDrawPixels DrawPixels}, {@link GL11C#glReadPixels ReadPixels}, and {@link GL11#glCopyPixels CopyPixels} + * commands, as well as a packed data type, {@link #GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8}, that is meant to be used with {@link #GL_DEPTH_STENCIL DEPTH_STENCIL}. No other data types are supported with + * {@link #GL_DEPTH_STENCIL DEPTH_STENCIL}. If {@link ARBDepthTexture ARB_depth_texture} or SGIX_depth_texture is supported, {@link #GL_DEPTH_STENCIL DEPTH_STENCIL}/{@link #GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} data can also be used for textures; + * this provides a more efficient way to supply data for a 24-bit depth texture.
+ * + *{@link #GL_DEPTH_STENCIL DEPTH_STENCIL} data, when passed through the pixel path, undergoes both depth and stencil operations. The depth data is scaled and biased by the current + * {@link GL11#GL_DEPTH_SCALE DEPTH_SCALE} and {@link GL11#GL_DEPTH_BIAS DEPTH_BIAS}, while the stencil data is shifted and offset by the current {@link GL11#GL_INDEX_SHIFT INDEX_SHIFT} and {@link GL11#GL_INDEX_OFFSET INDEX_OFFSET}. The stencil + * data is also put through the stencil-to-stencil pixel map.
+ * + *{@link GL11#glDrawPixels DrawPixels} of {@link #GL_DEPTH_STENCIL DEPTH_STENCIL} data operates similarly to that of {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} data, bypassing the OpenGL fragment pipeline entirely, unlike + * the treatment of {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} data. The stencil and depth masks are applied, as are the pixel ownership and scissor tests, but all other + * operations are skipped.
+ * + *{@link GL11C#glReadPixels ReadPixels} of {@link #GL_DEPTH_STENCIL DEPTH_STENCIL} data reads back a rectangle from both the depth and stencil buffers.
+ * + *{@link GL11#glCopyPixels CopyPixels} of {@link #GL_DEPTH_STENCIL DEPTH_STENCIL} data copies a rectangle from both the depth and stencil buffers. Like glDrawPixels, it applies both the stencil and + * depth masks but skips the remainder of the OpenGL fragment pipeline.
+ * + *glTex[Sub]Image[1,2,3]D of {@link #GL_DEPTH_STENCIL DEPTH_STENCIL} data loads depth and stencil data into a depth_stencil texture. {@link GL11C#glGetTexImage GetTexImage} of {@link #GL_DEPTH_STENCIL DEPTH_STENCIL} data can be + * used to retrieve depth and stencil data from a depth/stencil texture.
+ * + *In addition, a new base internal format, {@link #GL_DEPTH_STENCIL DEPTH_STENCIL}, can be used by both texture images and renderbuffer storage. When an image with a + * {@link #GL_DEPTH_STENCIL DEPTH_STENCIL} internal format is attached to both the depth and stencil attachment points of a framebuffer object, then it becomes both the depth and + * stencil buffers of the framebuffer. This fits nicely with hardware that interleaves both depth and stencil data into a single buffer. When a texture + * with {@link #GL_DEPTH_STENCIL DEPTH_STENCIL} data is bound for texturing, only the depth component is accessible through the texture fetcher. The stencil data can be written + * with TexImage or CopyTexImage, and can be read with {@link GL11C#glGetTexImage GetTexImage}. When a {@link #GL_DEPTH_STENCIL DEPTH_STENCIL} image is attached to the stencil attachment of the bound + * framebuffer object, the stencil data can be accessed through any operation that reads from or writes to the framebuffer's stencil buffer.
+ * + *Glossary of Helpful Terms
+ * + *An "attach" operation is similar to a "bind" operation in that both represent a reference to the attached or bound object for the purpose of + * managing object lifetimes and both enable manipulation of the state of the attached or bound object.
+ * + *However, an "attach" is also different from a "bind" in that "binding" an unused object creates a new object, while "attaching" does not. + * Additionally, "bind" establishes a connection between a context and an object, while "attach" establishes a connection between two objects.
+ * + *Finally, if object "A" is attached to object "B" and object "B" is bound to context "C", then in most respects, we treat "A" as if it is + * implicitly bound to "C".
Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public class ARBFramebufferObject { + + /** + * Accepted by the {@code target} parameter of BindFramebuffer, CheckFramebufferStatus, FramebufferTexture{1D|2D|3D}, FramebufferRenderbuffer, and + * GetFramebufferAttachmentParameteriv. + */ + public static final int + GL_FRAMEBUFFER = 0x8D40, + GL_READ_FRAMEBUFFER = 0x8CA8, + GL_DRAW_FRAMEBUFFER = 0x8CA9; + + /** + * Accepted by the {@code target} parameter of BindRenderbuffer, RenderbufferStorage, and GetRenderbufferParameteriv, and returned by + * GetFramebufferAttachmentParameteriv. + */ + public static final int GL_RENDERBUFFER = 0x8D41; + + /** Accepted by the {@code internalformat} parameter of RenderbufferStorage. */ + public static final int + GL_STENCIL_INDEX1 = 0x8D46, + GL_STENCIL_INDEX4 = 0x8D47, + GL_STENCIL_INDEX8 = 0x8D48, + GL_STENCIL_INDEX16 = 0x8D49; + + /** Accepted by the {@code pname} parameter of GetRenderbufferParameteriv. */ + public static final int + GL_RENDERBUFFER_WIDTH = 0x8D42, + GL_RENDERBUFFER_HEIGHT = 0x8D43, + GL_RENDERBUFFER_INTERNAL_FORMAT = 0x8D44, + GL_RENDERBUFFER_RED_SIZE = 0x8D50, + GL_RENDERBUFFER_GREEN_SIZE = 0x8D51, + GL_RENDERBUFFER_BLUE_SIZE = 0x8D52, + GL_RENDERBUFFER_ALPHA_SIZE = 0x8D53, + GL_RENDERBUFFER_DEPTH_SIZE = 0x8D54, + GL_RENDERBUFFER_STENCIL_SIZE = 0x8D55, + GL_RENDERBUFFER_SAMPLES = 0x8CAB; + + /** Accepted by the {@code pname} parameter of GetFramebufferAttachmentParameteriv. */ + public static final int + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0, + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4, + GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210, + GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211, + GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212, + GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213, + GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214, + GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215, + GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216, + GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217; + + /** Returned in {@code params} by GetFramebufferAttachmentParameteriv. */ + public static final int + GL_UNSIGNED_NORMALIZED = 0x8C17, + GL_FRAMEBUFFER_DEFAULT = 0x8218, + GL_INDEX = 0x8222; + + /** Accepted by the {@code attachment} parameter of FramebufferTexture{1D|2D|3D}, FramebufferRenderbuffer, and GetFramebufferAttachmentParameteriv. */ + public static final int + GL_COLOR_ATTACHMENT0 = 0x8CE0, + GL_COLOR_ATTACHMENT1 = 0x8CE1, + GL_COLOR_ATTACHMENT2 = 0x8CE2, + GL_COLOR_ATTACHMENT3 = 0x8CE3, + GL_COLOR_ATTACHMENT4 = 0x8CE4, + GL_COLOR_ATTACHMENT5 = 0x8CE5, + GL_COLOR_ATTACHMENT6 = 0x8CE6, + GL_COLOR_ATTACHMENT7 = 0x8CE7, + GL_COLOR_ATTACHMENT8 = 0x8CE8, + GL_COLOR_ATTACHMENT9 = 0x8CE9, + GL_COLOR_ATTACHMENT10 = 0x8CEA, + GL_COLOR_ATTACHMENT11 = 0x8CEB, + GL_COLOR_ATTACHMENT12 = 0x8CEC, + GL_COLOR_ATTACHMENT13 = 0x8CED, + GL_COLOR_ATTACHMENT14 = 0x8CEE, + GL_COLOR_ATTACHMENT15 = 0x8CEF, + GL_DEPTH_ATTACHMENT = 0x8D00, + GL_STENCIL_ATTACHMENT = 0x8D20, + GL_DEPTH_STENCIL_ATTACHMENT = 0x821A; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_MAX_SAMPLES = 0x8D57; + + /** Returned by CheckFramebufferStatus(). */ + public static final int + GL_FRAMEBUFFER_COMPLETE = 0x8CD5, + GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6, + GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7, + GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB, + GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC, + GL_FRAMEBUFFER_UNSUPPORTED = 0x8CDD, + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56, + GL_FRAMEBUFFER_UNDEFINED = 0x8219; + + /** Accepted by the {@code pname} parameters of GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_FRAMEBUFFER_BINDING = 0x8CA6, + GL_DRAW_FRAMEBUFFER_BINDING = 0x8CA6, + GL_READ_FRAMEBUFFER_BINDING = 0x8CAA, + GL_RENDERBUFFER_BINDING = 0x8CA7, + GL_MAX_COLOR_ATTACHMENTS = 0x8CDF, + GL_MAX_RENDERBUFFER_SIZE = 0x84E8; + + /** Returned by GetError(). */ + public static final int GL_INVALID_FRAMEBUFFER_OPERATION = 0x506; + + /** + * Accepted by the {@code format} parameter of DrawPixels, ReadPixels, TexImage1D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, and + * GetTexImage, by the {@code type} parameter of CopyPixels, by the {@code internalformat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, + * CopyTexImage2D, and RenderbufferStorage, and returned in the {@code data} parameter of GetTexLevelParameter and GetRenderbufferParameteriv. + */ + public static final int GL_DEPTH_STENCIL = 0x84F9; + + /** + * Accepted by the {@code type} parameter of DrawPixels, ReadPixels, TexImage1D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, and + * GetTexImage. + */ + public static final int GL_UNSIGNED_INT_24_8 = 0x84FA; + + /** + * Accepted by the {@code internalformat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D, and RenderbufferStorage, and + * returned in the {@code data} parameter of GetTexLevelParameter and GetRenderbufferParameteriv. + */ + public static final int GL_DEPTH24_STENCIL8 = 0x88F0; + + /** Accepted by the {@code value} parameter of GetTexLevelParameter. */ + public static final int GL_TEXTURE_STENCIL_SIZE = 0x88F1; + + static { GL.initialize(); } + + protected ARBFramebufferObject() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glIsRenderbuffer, caps.glBindRenderbuffer, caps.glDeleteRenderbuffers, caps.glGenRenderbuffers, caps.glRenderbufferStorage, + caps.glRenderbufferStorageMultisample, caps.glGetRenderbufferParameteriv, caps.glIsFramebuffer, caps.glBindFramebuffer, caps.glDeleteFramebuffers, + caps.glGenFramebuffers, caps.glCheckFramebufferStatus, caps.glFramebufferTexture1D, caps.glFramebufferTexture2D, caps.glFramebufferTexture3D, + caps.glFramebufferTextureLayer, caps.glFramebufferRenderbuffer, caps.glGetFramebufferAttachmentParameteriv, caps.glBlitFramebuffer, + caps.glGenerateMipmap + ); + } + + // --- [ glIsRenderbuffer ] --- + + /** + * Determines if a name corresponds to a renderbuffer object. + * + * @param renderbuffer a value that may be the name of a renderbuffer object + */ + @NativeType("GLboolean") + public static boolean glIsRenderbuffer(@NativeType("GLuint") int renderbuffer) { + return GL30C.glIsRenderbuffer(renderbuffer); + } + + // --- [ glBindRenderbuffer ] --- + + /** + * Binds a renderbuffer to a renderbuffer target. + * + * @param target the renderbuffer target of the binding operation. Must be:| {@link GL30C#GL_RENDERBUFFER RENDERBUFFER} |
| {@link GL30C#GL_RENDERBUFFER RENDERBUFFER} |
{@link #glRenderbufferStorage RenderbufferStorage} is equivalent to calling this method with the samples set to zero.
+ * + * @param target the target of the allocation. Must be:| {@link GL30C#GL_RENDERBUFFER RENDERBUFFER} |
| {@link GL30C#GL_RENDERBUFFER RENDERBUFFER} |
| {@link GL30C#GL_RENDERBUFFER_WIDTH RENDERBUFFER_WIDTH} | {@link GL30C#GL_RENDERBUFFER_HEIGHT RENDERBUFFER_HEIGHT} | {@link GL30C#GL_RENDERBUFFER_INTERNAL_FORMAT RENDERBUFFER_INTERNAL_FORMAT} |
| {@link GL30C#GL_RENDERBUFFER_RED_SIZE RENDERBUFFER_RED_SIZE} | {@link GL30C#GL_RENDERBUFFER_GREEN_SIZE RENDERBUFFER_GREEN_SIZE} | {@link GL30C#GL_RENDERBUFFER_BLUE_SIZE RENDERBUFFER_BLUE_SIZE} |
| {@link GL30C#GL_RENDERBUFFER_ALPHA_SIZE RENDERBUFFER_ALPHA_SIZE} | {@link GL30C#GL_RENDERBUFFER_DEPTH_SIZE RENDERBUFFER_DEPTH_SIZE} | {@link GL30C#GL_RENDERBUFFER_STENCIL_SIZE RENDERBUFFER_STENCIL_SIZE} |
| {@link GL30C#GL_RENDERBUFFER_SAMPLES RENDERBUFFER_SAMPLES} |
| {@link GL30C#GL_RENDERBUFFER RENDERBUFFER} |
| {@link GL30C#GL_RENDERBUFFER_WIDTH RENDERBUFFER_WIDTH} | {@link GL30C#GL_RENDERBUFFER_HEIGHT RENDERBUFFER_HEIGHT} | {@link GL30C#GL_RENDERBUFFER_INTERNAL_FORMAT RENDERBUFFER_INTERNAL_FORMAT} |
| {@link GL30C#GL_RENDERBUFFER_RED_SIZE RENDERBUFFER_RED_SIZE} | {@link GL30C#GL_RENDERBUFFER_GREEN_SIZE RENDERBUFFER_GREEN_SIZE} | {@link GL30C#GL_RENDERBUFFER_BLUE_SIZE RENDERBUFFER_BLUE_SIZE} |
| {@link GL30C#GL_RENDERBUFFER_ALPHA_SIZE RENDERBUFFER_ALPHA_SIZE} | {@link GL30C#GL_RENDERBUFFER_DEPTH_SIZE RENDERBUFFER_DEPTH_SIZE} | {@link GL30C#GL_RENDERBUFFER_STENCIL_SIZE RENDERBUFFER_STENCIL_SIZE} |
| {@link GL30C#GL_RENDERBUFFER_SAMPLES RENDERBUFFER_SAMPLES} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30C#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30C#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30C#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30C#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30C#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30C#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30C#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30C#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30C#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30C#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30C#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30C#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30C#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30C#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30C#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30C#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30C#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30C#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30C#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30C#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30C#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30C#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30C#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30C#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30C#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30C#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30C#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30C#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30C#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30C#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30C#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30C#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30C#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30C#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30C#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30C#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30C#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30C#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30C#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30C#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30C#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30C#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30C#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30C#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30C#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30C#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30C#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30C#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30C#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30C#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30C#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30C#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30C#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30C#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30C#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30C#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30C#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30C#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30C#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30C#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30C#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30C#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30C#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30C#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30C#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30C#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30C#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30C#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30C#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30C#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30C#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30C#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30C#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30C#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30C#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30C#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30C#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30C#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30C#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30C#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30C#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30C#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30C#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30C#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30C#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30C#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30C#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30C#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30C#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30C#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30C#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30C#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30C#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30C#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30C#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30C#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30C#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30C#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30C#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30C#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30C#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30C#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30C#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30C#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30C#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30C#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30C#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30C#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30C#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30C#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30C#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30C#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30C#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30C#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30C#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30C#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30C#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30C#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30C#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30C#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30C#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30C#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30C#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30C#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30C#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30C#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30C#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30C#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30C#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30C#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30C#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30C#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30C#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30C#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30C#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30C#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30C#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30C#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30C#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30C#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30C#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30C#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30C#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30C#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30C#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30C#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30C#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30C#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30C#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30C#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30C#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30C#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30C#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30C#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30C#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30C#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30C#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30C#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30C#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30C#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30C#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30C#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30C#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30C#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30C#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30C#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30C#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30C#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30C#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30C#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30C#GL_RENDERBUFFER RENDERBUFFER} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30C#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30C#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30C#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30C#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30C#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30C#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30C#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30C#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30C#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30C#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30C#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30C#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30C#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30C#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30C#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30C#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30C#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30C#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30C#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30C#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30C#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30C#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30C#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30C#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30C#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30C#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30C#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30C#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30C#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30C#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30C#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30C#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30C#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30C#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME FRAMEBUFFER_ATTACHMENT_OBJECT_NAME} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE FRAMEBUFFER_ATTACHMENT_RED_SIZE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE FRAMEBUFFER_ATTACHMENT_GREEN_SIZE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE FRAMEBUFFER_ATTACHMENT_BLUE_SIZE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30C#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30C#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30C#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30C#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30C#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30C#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30C#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30C#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30C#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30C#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30C#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30C#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30C#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30C#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30C#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30C#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30C#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30C#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30C#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30C#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30C#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30C#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30C#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30C#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30C#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30C#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30C#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30C#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30C#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30C#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30C#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30C#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30C#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30C#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME FRAMEBUFFER_ATTACHMENT_OBJECT_NAME} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE FRAMEBUFFER_ATTACHMENT_RED_SIZE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE FRAMEBUFFER_ATTACHMENT_GREEN_SIZE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE FRAMEBUFFER_ATTACHMENT_BLUE_SIZE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE} |
| {@link GL11#GL_COLOR_BUFFER_BIT COLOR_BUFFER_BIT} | {@link GL11#GL_DEPTH_BUFFER_BIT DEPTH_BUFFER_BIT} | {@link GL11#GL_STENCIL_BUFFER_BIT STENCIL_BUFFER_BIT} |
| {@link GL11#GL_NEAREST NEAREST} | {@link GL11#GL_LINEAR LINEAR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30C#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL30C#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
Conventionally, OpenGL assumes framebuffer color components are stored in a linear color space. In particular, framebuffer blending is a linear + * operation.
+ * + *The sRGB color space is based on typical (non-linear) monitor characteristics expected in a dimly lit office. It has been standardized by the + * International Electrotechnical Commission (IEC) as IEC 61966-2-1. The sRGB color space roughly corresponds to 2.2 gamma correction.
+ * + *This extension adds a framebuffer capability for sRGB framebuffer update and blending. When blending is disabled but the new sRGB updated mode is + * enabled (assume the framebuffer supports the capability), high-precision linear color component values for red, green, and blue generated by fragment + * coloring are encoded for sRGB prior to being written into the framebuffer. When blending is enabled along with the new sRGB update mode, red, green, and + * blue framebuffer color components are treated as sRGB values that are converted to linear color values, blended with the high-precision color values + * generated by fragment coloring, and then the blend result is encoded for sRGB just prior to being written into the framebuffer.
+ * + *The primary motivation for this extension is that it allows OpenGL applications to render into a framebuffer that is scanned to a monitor configured to + * assume framebuffer color values are sRGB encoded. This assumption is roughly true of most PC monitors with default gamma correction. This allows + * applications to achieve faithful color reproduction for OpenGL rendering without adjusting the monitor's gamma correction.
+ * + *Requires {@link ARBFramebufferObject ARB_framebuffer_object}. Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public final class ARBFramebufferSRGB { + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_FRAMEBUFFER_SRGB = 0x8DB9; + + private ARBFramebufferSRGB() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBGLSPIRV.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBGLSPIRV.java new file mode 100644 index 00000000..33df2aff --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBGLSPIRV.java @@ -0,0 +1,172 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the ARB_gl_spirv extension. + * + *This is version 100 of the GL_ARB_gl_spirv extension.
+ * + *This extension does two things:
+ * + *Requires {@link GL33 OpenGL 3.3}.
+ */ +public class ARBGLSPIRV { + + /** Accepted by the {@code binaryformat} parameter of {@link GL41C#glShaderBinary ShaderBinary}. */ + public static final int GL_SHADER_BINARY_FORMAT_SPIR_V_ARB = 0x9551; + + /** Accepted by the {@code pname} parameter of {@link GL20C#glGetShaderiv GetShaderiv}. */ + public static final int GL_SPIR_V_BINARY_ARB = 0x9552; + + static { GL.initialize(); } + + protected ARBGLSPIRV() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glSpecializeShaderARB + ); + } + + // --- [ glSpecializeShaderARB ] --- + + /** + * Unsafe version of: {@link #glSpecializeShaderARB SpecializeShaderARB} + * + * @param numSpecializationConstants the number of specialization constants whose values to set in this call + */ + public static native void nglSpecializeShaderARB(int shader, long pEntryPoint, int numSpecializationConstants, long pConstantIndex, long pConstantValue); + + /** + * Specializes a shader created from a SPIR-V module. + * + *Shaders associated with SPIR-V modules must be specialized before they can be linked into a program object. It is not necessary to specialize the + * shader before it is attached to a program object. Once specialized, a shader may not be specialized again without first re-associating the original + * SPIR-V module with it, through {@link GL41C#glShaderBinary ShaderBinary}.
+ * + *Specialization does two things:
+ * + *On successful shader specialization, the compile status for shader is set to {@link GL11#GL_TRUE TRUE}. On failure, the compile status for shader is set to {@link GL11#GL_FALSE FALSE} and + * additional information about the cause of the failure may be available in the shader compilation log.
+ * + * @param shader the name of a shader object containing unspecialized SPIR-V as created from a successful call to {@link GL41C#glShaderBinary ShaderBinary} to which a SPIR-V module was + * passed + * @param pEntryPoint a pointer to a null-terminated UTF-8 string specifying the name of the entry point in the SPIR-V module to use for this shader + * @param pConstantIndex is a pointer to an array of {@code numSpecializationConstants} unsigned integers, each holding the index of a specialization constant in the SPIR-V + * module whose value to set. + * + *Specialization constants not referenced by {@code pConstantIndex} retain their default values as specified in the SPIR-V module.
+ * @param pConstantValue an entry in {@code pConstantValue} is used to set the value of the specialization constant indexed by the corresponding entry in + * {@code pConstantIndex}. + * + *Although this array is of unsigned integer, each entry is bitcast to the appropriate type for the module, and therefore, floating-point constants + * may be set by including their IEEE-754 bit representation in the {@code pConstantValue} array.
+ */ + public static void glSpecializeShaderARB(@NativeType("GLuint") int shader, @NativeType("GLchar const *") ByteBuffer pEntryPoint, @NativeType("GLuint const *") IntBuffer pConstantIndex, @NativeType("GLuint const *") IntBuffer pConstantValue) { + if (CHECKS) { + checkNT1(pEntryPoint); + check(pConstantValue, pConstantIndex.remaining()); + } + nglSpecializeShaderARB(shader, memAddress(pEntryPoint), pConstantIndex.remaining(), memAddress(pConstantIndex), memAddress(pConstantValue)); + } + + /** + * Specializes a shader created from a SPIR-V module. + * + *Shaders associated with SPIR-V modules must be specialized before they can be linked into a program object. It is not necessary to specialize the + * shader before it is attached to a program object. Once specialized, a shader may not be specialized again without first re-associating the original + * SPIR-V module with it, through {@link GL41C#glShaderBinary ShaderBinary}.
+ * + *Specialization does two things:
+ * + *On successful shader specialization, the compile status for shader is set to {@link GL11#GL_TRUE TRUE}. On failure, the compile status for shader is set to {@link GL11#GL_FALSE FALSE} and + * additional information about the cause of the failure may be available in the shader compilation log.
+ * + * @param shader the name of a shader object containing unspecialized SPIR-V as created from a successful call to {@link GL41C#glShaderBinary ShaderBinary} to which a SPIR-V module was + * passed + * @param pEntryPoint a pointer to a null-terminated UTF-8 string specifying the name of the entry point in the SPIR-V module to use for this shader + * @param pConstantIndex is a pointer to an array of {@code numSpecializationConstants} unsigned integers, each holding the index of a specialization constant in the SPIR-V + * module whose value to set. + * + *Specialization constants not referenced by {@code pConstantIndex} retain their default values as specified in the SPIR-V module.
+ * @param pConstantValue an entry in {@code pConstantValue} is used to set the value of the specialization constant indexed by the corresponding entry in + * {@code pConstantIndex}. + * + *Although this array is of unsigned integer, each entry is bitcast to the appropriate type for the module, and therefore, floating-point constants + * may be set by including their IEEE-754 bit representation in the {@code pConstantValue} array.
+ */ + public static void glSpecializeShaderARB(@NativeType("GLuint") int shader, @NativeType("GLchar const *") CharSequence pEntryPoint, @NativeType("GLuint const *") IntBuffer pConstantIndex, @NativeType("GLuint const *") IntBuffer pConstantValue) { + if (CHECKS) { + check(pConstantValue, pConstantIndex.remaining()); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8(pEntryPoint, true); + long pEntryPointEncoded = stack.getPointerAddress(); + nglSpecializeShaderARB(shader, pEntryPointEncoded, pConstantIndex.remaining(), memAddress(pConstantIndex), memAddress(pConstantValue)); + } finally { + stack.setPointer(stackPointer); + } + } + + /** Array version of: {@link #glSpecializeShaderARB SpecializeShaderARB} */ + public static void glSpecializeShaderARB(@NativeType("GLuint") int shader, @NativeType("GLchar const *") ByteBuffer pEntryPoint, @NativeType("GLuint const *") int[] pConstantIndex, @NativeType("GLuint const *") int[] pConstantValue) { + long __functionAddress = GL.getICD().glSpecializeShaderARB; + if (CHECKS) { + check(__functionAddress); + checkNT1(pEntryPoint); + check(pConstantValue, pConstantIndex.length); + } + callPPPV(shader, memAddress(pEntryPoint), pConstantIndex.length, pConstantIndex, pConstantValue, __functionAddress); + } + + /** Array version of: {@link #glSpecializeShaderARB SpecializeShaderARB} */ + public static void glSpecializeShaderARB(@NativeType("GLuint") int shader, @NativeType("GLchar const *") CharSequence pEntryPoint, @NativeType("GLuint const *") int[] pConstantIndex, @NativeType("GLuint const *") int[] pConstantValue) { + long __functionAddress = GL.getICD().glSpecializeShaderARB; + if (CHECKS) { + check(__functionAddress); + check(pConstantValue, pConstantIndex.length); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8(pEntryPoint, true); + long pEntryPointEncoded = stack.getPointerAddress(); + callPPPV(shader, pEntryPointEncoded, pConstantIndex.length, pConstantIndex, pConstantValue, __functionAddress); + } finally { + stack.setPointer(stackPointer); + } + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBGPUShader5.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBGPUShader5.java new file mode 100644 index 00000000..94f98606 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBGPUShader5.java @@ -0,0 +1,78 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_gpu_shader5 extension. + * + *This extension provides a set of new features to the OpenGL Shading Language and related APIs to support capabilities of new GPUs, extending the + * capabilities of version 1.50 of the OpenGL Shading Language. Shaders using the new functionality provided by this extension should enable this + * functionality via the construct:
+ * + *
+ * #extension GL_ARB_gpu_shader5 : require (or enable)This extension provides a variety of new features for all shader types, including:
+ * + *This extension also provides some new capabilities for individual shader types, including:
+ * + *Requires {@link GL32 GL32} and GLSL 1.50. Promoted to core in {@link GL40 OpenGL 4.0}.
+ */ +public final class ARBGPUShader5 { + + /** Accepted by the {@code pname} parameter of GetProgramiv. */ + public static final int GL_GEOMETRY_SHADER_INVOCATIONS = 0x887F; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, GetDoublev, and GetInteger64v. */ + public static final int + GL_MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A, + GL_MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B, + GL_MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C, + GL_FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D, + GL_MAX_VERTEX_STREAMS = 0x8E71; + + private ARBGPUShader5() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBGPUShaderFP64.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBGPUShaderFP64.java new file mode 100644 index 00000000..204b1fe2 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBGPUShaderFP64.java @@ -0,0 +1,957 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the ARB_gpu_shader_fp64 extension. + * + *This extension allows GLSL shaders to use double-precision floating-point data types, including vectors and matrices of doubles. Doubles may be used as + * inputs, outputs, and uniforms.
+ * + *The shading language supports various arithmetic and comparison operators on double-precision scalar, vector, and matrix types, and provides a set of + * built-in functions including:
+ * + *Double-precision versions of angle, trigonometry, and exponential functions are not supported.
+ * + *Implicit conversions are supported from integer and single-precision floating-point values to doubles, and this extension uses the relaxed function + * overloading rules specified by the ARB_gpu_shader5 extension to resolve ambiguities.
+ * + *This extension provides API functions for specifying double-precision uniforms in the default uniform block, including functions similar to the uniform + * functions added by {@link EXTDirectStateAccess EXT_direct_state_access} (if supported).
+ * + *This extension provides an "LF" suffix for specifying double-precision constants. Floating-point constants without a suffix in GLSL are treated as + * single-precision values for backward compatibility with versions not supporting doubles; similar constants are treated as double-precision values in the + * "C" programming language.
+ * + *This extension does not support interpolation of double-precision values; doubles used as fragment shader inputs must be qualified as "flat". + * Additionally, this extension does not allow vertex attributes with 64-bit components. That support is added separately by + * EXT_vertex_attrib_64bit.
+ * + *Requires {@link GL32 GL32} and GLSL 1.50. Promoted to core in {@link GL40 OpenGL 4.0}.
+ */ +public class ARBGPUShaderFP64 { + + /** Returned in the {@code type} parameter of GetActiveUniform, and GetTransformFeedbackVarying. */ + public static final int + GL_DOUBLE_VEC2 = 0x8FFC, + GL_DOUBLE_VEC3 = 0x8FFD, + GL_DOUBLE_VEC4 = 0x8FFE, + GL_DOUBLE_MAT2 = 0x8F46, + GL_DOUBLE_MAT3 = 0x8F47, + GL_DOUBLE_MAT4 = 0x8F48, + GL_DOUBLE_MAT2x3 = 0x8F49, + GL_DOUBLE_MAT2x4 = 0x8F4A, + GL_DOUBLE_MAT3x2 = 0x8F4B, + GL_DOUBLE_MAT3x4 = 0x8F4C, + GL_DOUBLE_MAT4x2 = 0x8F4D, + GL_DOUBLE_MAT4x3 = 0x8F4E; + + static { GL.initialize(); } + + protected ARBGPUShaderFP64() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetThe extension introduces the following features for all shader types:
+ * + *Requires {@link GL40 GL40} and GLSL 4.00.
+ */ +public class ARBGPUShaderInt64 { + + /** Returned by the {@code type} parameter of GetActiveAttrib, GetActiveUniform, and GetTransformFeedbackVarying. */ + public static final int + GL_INT64_ARB = 0x140E, + GL_UNSIGNED_INT64_ARB = 0x140F, + GL_INT64_VEC2_ARB = 0x8FE9, + GL_INT64_VEC3_ARB = 0x8FEA, + GL_INT64_VEC4_ARB = 0x8FEB, + GL_UNSIGNED_INT64_VEC2_ARB = 0x8FF5, + GL_UNSIGNED_INT64_VEC3_ARB = 0x8FF6, + GL_UNSIGNED_INT64_VEC4_ARB = 0x8FF7; + + static { GL.initialize(); } + + protected ARBGPUShaderInt64() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glUniform1i64ARB, caps.glUniform1i64vARB, caps.glProgramUniform1i64ARB, caps.glProgramUniform1i64vARB, caps.glUniform2i64ARB, + caps.glUniform2i64vARB, caps.glProgramUniform2i64ARB, caps.glProgramUniform2i64vARB, caps.glUniform3i64ARB, caps.glUniform3i64vARB, + caps.glProgramUniform3i64ARB, caps.glProgramUniform3i64vARB, caps.glUniform4i64ARB, caps.glUniform4i64vARB, caps.glProgramUniform4i64ARB, + caps.glProgramUniform4i64vARB, caps.glUniform1ui64ARB, caps.glUniform1ui64vARB, caps.glProgramUniform1ui64ARB, caps.glProgramUniform1ui64vARB, + caps.glUniform2ui64ARB, caps.glUniform2ui64vARB, caps.glProgramUniform2ui64ARB, caps.glProgramUniform2ui64vARB, caps.glUniform3ui64ARB, + caps.glUniform3ui64vARB, caps.glProgramUniform3ui64ARB, caps.glProgramUniform3ui64vARB, caps.glUniform4ui64ARB, caps.glUniform4ui64vARB, + caps.glProgramUniform4ui64ARB, caps.glProgramUniform4ui64vARB, caps.glGetUniformi64vARB, caps.glGetUniformui64vARB, caps.glGetnUniformi64vARB, + caps.glGetnUniformui64vARB + ); + } + + // --- [ glUniform1i64ARB ] --- + + /** + * Specifies the value of an int64_t uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + */ + public static native void glUniform1i64ARB(@NativeType("GLint") int location, @NativeType("GLint64") long x); + + // --- [ glUniform1i64vARB ] --- + + /** + * Unsafe version of: {@link #glUniform1i64vARB Uniform1i64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform1i64vARB(int location, int count, long value); + + /** + * Specifies the value of a single int64_t uniform variable or a int64_t uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified int64_t variable + */ + public static void glUniform1i64vARB(@NativeType("GLint") int location, @NativeType("GLint64 *") LongBuffer value) { + nglUniform1i64vARB(location, value.remaining(), memAddress(value)); + } + + // --- [ glProgramUniform1i64ARB ] --- + + /** + * Specifies the value of an int64_t uniform variable for the specified program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + */ + public static native void glProgramUniform1i64ARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64") long x); + + // --- [ glProgramUniform1i64vARB ] --- + + /** + * Unsafe version of: {@link #glProgramUniform1i64vARB ProgramUniform1i64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglProgramUniform1i64vARB(int program, int location, int count, long value); + + /** + * Specifies the value of a single int64_t uniform variable or a int64_t uniform variable array for the specified program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified int64_t variable + */ + public static void glProgramUniform1i64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64 *") LongBuffer value) { + nglProgramUniform1i64vARB(program, location, value.remaining(), memAddress(value)); + } + + // --- [ glUniform2i64ARB ] --- + + /** + * Specifies the value of an i64vec2 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + * @param y the uniform y value + */ + public static native void glUniform2i64ARB(@NativeType("GLint") int location, @NativeType("GLint64") long x, @NativeType("GLint64") long y); + + // --- [ glUniform2i64vARB ] --- + + /** + * Unsafe version of: {@link #glUniform2i64vARB Uniform2i64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform2i64vARB(int location, int count, long value); + + /** + * Specifies the value of a single i64vec2 uniform variable or a i64vec2 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified i64vec2 variable + */ + public static void glUniform2i64vARB(@NativeType("GLint") int location, @NativeType("GLint64 *") LongBuffer value) { + nglUniform2i64vARB(location, value.remaining() >> 1, memAddress(value)); + } + + // --- [ glProgramUniform2i64ARB ] --- + + /** + * Specifies the value of an i64vec2 uniform variable for the specified program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + * @param y the uniform y value + */ + public static native void glProgramUniform2i64ARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64") long x, @NativeType("GLint64") long y); + + // --- [ glProgramUniform2i64vARB ] --- + + /** + * Unsafe version of: {@link #glProgramUniform2i64vARB ProgramUniform2i64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglProgramUniform2i64vARB(int program, int location, int count, long value); + + /** + * Specifies the value of a single i64vec2 uniform variable or a i64vec2 uniform variable array for the specified program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified i64vec2 variable + */ + public static void glProgramUniform2i64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64 *") LongBuffer value) { + nglProgramUniform2i64vARB(program, location, value.remaining() >> 1, memAddress(value)); + } + + // --- [ glUniform3i64ARB ] --- + + /** + * Specifies the value of an i64vec3 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + * @param y the uniform y value + * @param z the uniform z value + */ + public static native void glUniform3i64ARB(@NativeType("GLint") int location, @NativeType("GLint64") long x, @NativeType("GLint64") long y, @NativeType("GLint64") long z); + + // --- [ glUniform3i64vARB ] --- + + /** + * Unsafe version of: {@link #glUniform3i64vARB Uniform3i64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform3i64vARB(int location, int count, long value); + + /** + * Specifies the value of a single i64vec3 uniform variable or a i64vec3 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified i64vec3 variable + */ + public static void glUniform3i64vARB(@NativeType("GLint") int location, @NativeType("GLint64 *") LongBuffer value) { + nglUniform3i64vARB(location, value.remaining() / 3, memAddress(value)); + } + + // --- [ glProgramUniform3i64ARB ] --- + + /** + * Specifies the value of an i64vec3 uniform variable for the specified program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + * @param y the uniform y value + * @param z the uniform z value + */ + public static native void glProgramUniform3i64ARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64") long x, @NativeType("GLint64") long y, @NativeType("GLint64") long z); + + // --- [ glProgramUniform3i64vARB ] --- + + /** + * Unsafe version of: {@link #glProgramUniform3i64vARB ProgramUniform3i64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglProgramUniform3i64vARB(int program, int location, int count, long value); + + /** + * Specifies the value of a single i64vec3 uniform variable or a i64vec3 uniform variable array for the specified program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified i64vec3 variable + */ + public static void glProgramUniform3i64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64 *") LongBuffer value) { + nglProgramUniform3i64vARB(program, location, value.remaining() / 3, memAddress(value)); + } + + // --- [ glUniform4i64ARB ] --- + + /** + * Specifies the value of an i64vec4 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + * @param y the uniform y value + * @param z the uniform z value + * @param w the uniform w value + */ + public static native void glUniform4i64ARB(@NativeType("GLint") int location, @NativeType("GLint64") long x, @NativeType("GLint64") long y, @NativeType("GLint64") long z, @NativeType("GLint64") long w); + + // --- [ glUniform4i64vARB ] --- + + /** + * Unsafe version of: {@link #glUniform4i64vARB Uniform4i64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform4i64vARB(int location, int count, long value); + + /** + * Specifies the value of a single i64vec4 uniform variable or a i64vec4 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified i64vec4 variable + */ + public static void glUniform4i64vARB(@NativeType("GLint") int location, @NativeType("GLint64 *") LongBuffer value) { + nglUniform4i64vARB(location, value.remaining() >> 2, memAddress(value)); + } + + // --- [ glProgramUniform4i64ARB ] --- + + /** + * Specifies the value of an i64vec4 uniform variable for the specified program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + * @param y the uniform y value + * @param z the uniform z value + * @param w the uniform w value + */ + public static native void glProgramUniform4i64ARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64") long x, @NativeType("GLint64") long y, @NativeType("GLint64") long z, @NativeType("GLint64") long w); + + // --- [ glProgramUniform4i64vARB ] --- + + /** + * Unsafe version of: {@link #glProgramUniform4i64vARB ProgramUniform4i64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglProgramUniform4i64vARB(int program, int location, int count, long value); + + /** + * Specifies the value of a single i64vec4 uniform variable or a i64vec4 uniform variable array for the specified program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified i64vec4 variable + */ + public static void glProgramUniform4i64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64 *") LongBuffer value) { + nglProgramUniform4i64vARB(program, location, value.remaining() >> 2, memAddress(value)); + } + + // --- [ glUniform1ui64ARB ] --- + + /** + * Specifies the value of an uint64_t uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + */ + public static native void glUniform1ui64ARB(@NativeType("GLint") int location, @NativeType("GLuint64") long x); + + // --- [ glUniform1ui64vARB ] --- + + /** + * Unsafe version of: {@link #glUniform1ui64vARB Uniform1ui64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform1ui64vARB(int location, int count, long value); + + /** + * Specifies the value of a single uint64_t uniform variable or a uint64_t uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uint64_t variable + */ + public static void glUniform1ui64vARB(@NativeType("GLint") int location, @NativeType("GLuint64 const *") LongBuffer value) { + nglUniform1ui64vARB(location, value.remaining(), memAddress(value)); + } + + // --- [ glProgramUniform1ui64ARB ] --- + + /** + * Specifies the value of an uint64_t uniform variable for the current program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + */ + public static native void glProgramUniform1ui64ARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64") long x); + + // --- [ glProgramUniform1ui64vARB ] --- + + /** + * Unsafe version of: {@link #glProgramUniform1ui64vARB ProgramUniform1ui64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglProgramUniform1ui64vARB(int program, int location, int count, long value); + + /** + * Specifies the value of a single uint64_t uniform variable or a uint64_t uniform variable array for the specified program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uint64_t variable + */ + public static void glProgramUniform1ui64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64 const *") LongBuffer value) { + nglProgramUniform1ui64vARB(program, location, value.remaining(), memAddress(value)); + } + + // --- [ glUniform2ui64ARB ] --- + + /** + * Specifies the value of an u64vec2 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + * @param y the uniform y value + */ + public static native void glUniform2ui64ARB(@NativeType("GLint") int location, @NativeType("GLuint64") long x, @NativeType("GLuint64") long y); + + // --- [ glUniform2ui64vARB ] --- + + /** + * Unsafe version of: {@link #glUniform2ui64vARB Uniform2ui64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform2ui64vARB(int location, int count, long value); + + /** + * Specifies the value of a single u64vec2 uniform variable or a u64vec2 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified u64vec2 variable + */ + public static void glUniform2ui64vARB(@NativeType("GLint") int location, @NativeType("GLuint64 const *") LongBuffer value) { + nglUniform2ui64vARB(location, value.remaining() >> 1, memAddress(value)); + } + + // --- [ glProgramUniform2ui64ARB ] --- + + /** + * Specifies the value of an u64vec2 uniform variable for the current program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + * @param y the uniform y value + */ + public static native void glProgramUniform2ui64ARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64") long x, @NativeType("GLuint64") long y); + + // --- [ glProgramUniform2ui64vARB ] --- + + /** + * Unsafe version of: {@link #glProgramUniform2ui64vARB ProgramUniform2ui64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglProgramUniform2ui64vARB(int program, int location, int count, long value); + + /** + * Specifies the value of a single u64vec2 uniform variable or a u64vec2 uniform variable array for the specified program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified u64vec2 variable + */ + public static void glProgramUniform2ui64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64 const *") LongBuffer value) { + nglProgramUniform2ui64vARB(program, location, value.remaining() >> 1, memAddress(value)); + } + + // --- [ glUniform3ui64ARB ] --- + + /** + * Specifies the value of an u64vec3 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + * @param y the uniform y value + * @param z the uniform z value + */ + public static native void glUniform3ui64ARB(@NativeType("GLint") int location, @NativeType("GLuint64") long x, @NativeType("GLuint64") long y, @NativeType("GLuint64") long z); + + // --- [ glUniform3ui64vARB ] --- + + /** + * Unsafe version of: {@link #glUniform3ui64vARB Uniform3ui64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform3ui64vARB(int location, int count, long value); + + /** + * Specifies the value of a single u64vec3 uniform variable or a u64vec3 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified u64vec3 variable + */ + public static void glUniform3ui64vARB(@NativeType("GLint") int location, @NativeType("GLuint64 const *") LongBuffer value) { + nglUniform3ui64vARB(location, value.remaining() / 3, memAddress(value)); + } + + // --- [ glProgramUniform3ui64ARB ] --- + + /** + * Specifies the value of an u64vec3 uniform variable for the current program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + * @param y the uniform y value + * @param z the uniform z value + */ + public static native void glProgramUniform3ui64ARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64") long x, @NativeType("GLuint64") long y, @NativeType("GLuint64") long z); + + // --- [ glProgramUniform3ui64vARB ] --- + + /** + * Unsafe version of: {@link #glProgramUniform3ui64vARB ProgramUniform3ui64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglProgramUniform3ui64vARB(int program, int location, int count, long value); + + /** + * Specifies the value of a single u64vec3 uniform variable or a u64vec3 uniform variable array for the specified program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified u64vec3 variable + */ + public static void glProgramUniform3ui64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64 const *") LongBuffer value) { + nglProgramUniform3ui64vARB(program, location, value.remaining() / 3, memAddress(value)); + } + + // --- [ glUniform4ui64ARB ] --- + + /** + * Specifies the value of an u64vec4 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + * @param y the uniform y value + * @param z the uniform z value + * @param w the uniform w value + */ + public static native void glUniform4ui64ARB(@NativeType("GLint") int location, @NativeType("GLuint64") long x, @NativeType("GLuint64") long y, @NativeType("GLuint64") long z, @NativeType("GLuint64") long w); + + // --- [ glUniform4ui64vARB ] --- + + /** + * Unsafe version of: {@link #glUniform4ui64vARB Uniform4ui64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform4ui64vARB(int location, int count, long value); + + /** + * Specifies the value of a single u64vec4 uniform variable or a u64vec4 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified u64vec4 variable + */ + public static void glUniform4ui64vARB(@NativeType("GLint") int location, @NativeType("GLuint64 const *") LongBuffer value) { + nglUniform4ui64vARB(location, value.remaining() >> 2, memAddress(value)); + } + + // --- [ glProgramUniform4ui64ARB ] --- + + /** + * Specifies the value of an u64vec4 uniform variable for the current program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param x the uniform x value + * @param y the uniform y value + * @param z the uniform z value + * @param w the uniform w value + */ + public static native void glProgramUniform4ui64ARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64") long x, @NativeType("GLuint64") long y, @NativeType("GLuint64") long z, @NativeType("GLuint64") long w); + + // --- [ glProgramUniform4ui64vARB ] --- + + /** + * Unsafe version of: {@link #glProgramUniform4ui64vARB ProgramUniform4ui64vARB} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglProgramUniform4ui64vARB(int program, int location, int count, long value); + + /** + * Specifies the value of a single u64vec4 uniform variable or a u64vec4 uniform variable array for the specified program object. + * + * @param program the program object + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified u64vec4 variable + */ + public static void glProgramUniform4ui64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64 const *") LongBuffer value) { + nglProgramUniform4ui64vARB(program, location, value.remaining() >> 2, memAddress(value)); + } + + // --- [ glGetUniformi64vARB ] --- + + /** Unsafe version of: {@link #glGetUniformi64vARB GetUniformi64vARB} */ + public static native void nglGetUniformi64vARB(int program, int location, long params); + + /** + * Returns the int64_t value(s) of a uniform variable. + * + * @param program the program object to be queried + * @param location the location of the uniform variable to be queried + * @param params the value of the specified uniform variable + */ + public static void glGetUniformi64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64 *") LongBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetUniformi64vARB(program, location, memAddress(params)); + } + + /** + * Returns the int64_t value(s) of a uniform variable. + * + * @param program the program object to be queried + * @param location the location of the uniform variable to be queried + */ + @NativeType("void") + public static long glGetUniformi64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer params = stack.callocLong(1); + nglGetUniformi64vARB(program, location, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetUniformui64vARB ] --- + + /** Unsafe version of: {@link #glGetUniformui64vARB GetUniformui64vARB} */ + public static native void nglGetUniformui64vARB(int program, int location, long params); + + /** + * Returns the uint64_t value(s) of a uniform variable. + * + * @param program the program object to be queried + * @param location the location of the uniform variable to be queried + * @param params the value of the specified uniform variable + */ + public static void glGetUniformui64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64 *") LongBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetUniformui64vARB(program, location, memAddress(params)); + } + + /** + * Returns the uint64_t value(s) of a uniform variable. + * + * @param program the program object to be queried + * @param location the location of the uniform variable to be queried + */ + @NativeType("void") + public static long glGetUniformui64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer params = stack.callocLong(1); + nglGetUniformui64vARB(program, location, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetnUniformi64vARB ] --- + + /** + * Unsafe version of: {@link #glGetnUniformi64vARB GetnUniformi64vARB} + * + * @param bufSize the maximum number of values to write in {@code params} + */ + public static native void nglGetnUniformi64vARB(int program, int location, int bufSize, long params); + + /** + * Robust version of {@link #glGetUniformi64vARB GetUniformi64vARB}. + * + * @param program the program object to be queried + * @param location the location of the uniform variable to be queried + * @param params the value of the specified uniform variable + */ + public static void glGetnUniformi64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64 *") LongBuffer params) { + nglGetnUniformi64vARB(program, location, params.remaining(), memAddress(params)); + } + + /** + * Robust version of {@link #glGetUniformi64vARB GetUniformi64vARB}. + * + * @param program the program object to be queried + * @param location the location of the uniform variable to be queried + */ + @NativeType("void") + public static long glGetnUniformi64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer params = stack.callocLong(1); + nglGetnUniformi64vARB(program, location, 1, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetnUniformui64vARB ] --- + + /** + * Unsafe version of: {@link #glGetnUniformui64vARB GetnUniformui64vARB} + * + * @param bufSize the maximum number of values to write in {@code params} + */ + public static native void nglGetnUniformui64vARB(int program, int location, int bufSize, long params); + + /** + * Robust version of {@link #glGetUniformui64vARB GetUniformui64vARB}. + * + * @param program the program object to be queried + * @param location the location of the uniform variable to be queried + * @param params the value of the specified uniform variable + */ + public static void glGetnUniformui64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64 *") LongBuffer params) { + nglGetnUniformui64vARB(program, location, params.remaining(), memAddress(params)); + } + + /** + * Robust version of {@link #glGetUniformui64vARB GetUniformui64vARB}. + * + * @param program the program object to be queried + * @param location the location of the uniform variable to be queried + */ + @NativeType("void") + public static long glGetnUniformui64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer params = stack.callocLong(1); + nglGetnUniformui64vARB(program, location, 1, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + /** Array version of: {@link #glUniform1i64vARB Uniform1i64vARB} */ + public static void glUniform1i64vARB(@NativeType("GLint") int location, @NativeType("GLint64 *") long[] value) { + long __functionAddress = GL.getICD().glUniform1i64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length, value, __functionAddress); + } + + /** Array version of: {@link #glProgramUniform1i64vARB ProgramUniform1i64vARB} */ + public static void glProgramUniform1i64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64 *") long[] value) { + long __functionAddress = GL.getICD().glProgramUniform1i64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(program, location, value.length, value, __functionAddress); + } + + /** Array version of: {@link #glUniform2i64vARB Uniform2i64vARB} */ + public static void glUniform2i64vARB(@NativeType("GLint") int location, @NativeType("GLint64 *") long[] value) { + long __functionAddress = GL.getICD().glUniform2i64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length >> 1, value, __functionAddress); + } + + /** Array version of: {@link #glProgramUniform2i64vARB ProgramUniform2i64vARB} */ + public static void glProgramUniform2i64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64 *") long[] value) { + long __functionAddress = GL.getICD().glProgramUniform2i64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(program, location, value.length >> 1, value, __functionAddress); + } + + /** Array version of: {@link #glUniform3i64vARB Uniform3i64vARB} */ + public static void glUniform3i64vARB(@NativeType("GLint") int location, @NativeType("GLint64 *") long[] value) { + long __functionAddress = GL.getICD().glUniform3i64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length / 3, value, __functionAddress); + } + + /** Array version of: {@link #glProgramUniform3i64vARB ProgramUniform3i64vARB} */ + public static void glProgramUniform3i64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64 *") long[] value) { + long __functionAddress = GL.getICD().glProgramUniform3i64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(program, location, value.length / 3, value, __functionAddress); + } + + /** Array version of: {@link #glUniform4i64vARB Uniform4i64vARB} */ + public static void glUniform4i64vARB(@NativeType("GLint") int location, @NativeType("GLint64 *") long[] value) { + long __functionAddress = GL.getICD().glUniform4i64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length >> 2, value, __functionAddress); + } + + /** Array version of: {@link #glProgramUniform4i64vARB ProgramUniform4i64vARB} */ + public static void glProgramUniform4i64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64 *") long[] value) { + long __functionAddress = GL.getICD().glProgramUniform4i64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(program, location, value.length >> 2, value, __functionAddress); + } + + /** Array version of: {@link #glUniform1ui64vARB Uniform1ui64vARB} */ + public static void glUniform1ui64vARB(@NativeType("GLint") int location, @NativeType("GLuint64 const *") long[] value) { + long __functionAddress = GL.getICD().glUniform1ui64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length, value, __functionAddress); + } + + /** Array version of: {@link #glProgramUniform1ui64vARB ProgramUniform1ui64vARB} */ + public static void glProgramUniform1ui64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64 const *") long[] value) { + long __functionAddress = GL.getICD().glProgramUniform1ui64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(program, location, value.length, value, __functionAddress); + } + + /** Array version of: {@link #glUniform2ui64vARB Uniform2ui64vARB} */ + public static void glUniform2ui64vARB(@NativeType("GLint") int location, @NativeType("GLuint64 const *") long[] value) { + long __functionAddress = GL.getICD().glUniform2ui64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length >> 1, value, __functionAddress); + } + + /** Array version of: {@link #glProgramUniform2ui64vARB ProgramUniform2ui64vARB} */ + public static void glProgramUniform2ui64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64 const *") long[] value) { + long __functionAddress = GL.getICD().glProgramUniform2ui64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(program, location, value.length >> 1, value, __functionAddress); + } + + /** Array version of: {@link #glUniform3ui64vARB Uniform3ui64vARB} */ + public static void glUniform3ui64vARB(@NativeType("GLint") int location, @NativeType("GLuint64 const *") long[] value) { + long __functionAddress = GL.getICD().glUniform3ui64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length / 3, value, __functionAddress); + } + + /** Array version of: {@link #glProgramUniform3ui64vARB ProgramUniform3ui64vARB} */ + public static void glProgramUniform3ui64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64 const *") long[] value) { + long __functionAddress = GL.getICD().glProgramUniform3ui64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(program, location, value.length / 3, value, __functionAddress); + } + + /** Array version of: {@link #glUniform4ui64vARB Uniform4ui64vARB} */ + public static void glUniform4ui64vARB(@NativeType("GLint") int location, @NativeType("GLuint64 const *") long[] value) { + long __functionAddress = GL.getICD().glUniform4ui64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length >> 2, value, __functionAddress); + } + + /** Array version of: {@link #glProgramUniform4ui64vARB ProgramUniform4ui64vARB} */ + public static void glProgramUniform4ui64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64 const *") long[] value) { + long __functionAddress = GL.getICD().glProgramUniform4ui64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(program, location, value.length >> 2, value, __functionAddress); + } + + /** Array version of: {@link #glGetUniformi64vARB GetUniformi64vARB} */ + public static void glGetUniformi64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64 *") long[] params) { + long __functionAddress = GL.getICD().glGetUniformi64vARB; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(program, location, params, __functionAddress); + } + + /** Array version of: {@link #glGetUniformui64vARB GetUniformui64vARB} */ + public static void glGetUniformui64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64 *") long[] params) { + long __functionAddress = GL.getICD().glGetUniformui64vARB; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(program, location, params, __functionAddress); + } + + /** Array version of: {@link #glGetnUniformi64vARB GetnUniformi64vARB} */ + public static void glGetnUniformi64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLint64 *") long[] params) { + long __functionAddress = GL.getICD().glGetnUniformi64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(program, location, params.length, params, __functionAddress); + } + + /** Array version of: {@link #glGetnUniformui64vARB GetnUniformui64vARB} */ + public static void glGetnUniformui64vARB(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64 *") long[] params) { + long __functionAddress = GL.getICD().glGetnUniformui64vARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(program, location, params.length, params, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBGeometryShader4.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBGeometryShader4.java new file mode 100644 index 00000000..2ea37060 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBGeometryShader4.java @@ -0,0 +1,172 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_geometry_shader4 extension. + * + *ARB_geometry_shader4 defines a new shader type available to be run on the GPU, called a geometry shader. Geometry shaders are run after vertices are + * transformed, but prior to color clamping, flat shading and clipping.
+ * + *A geometry shader begins with a single primitive (point, line, triangle). It can read the attributes of any of the vertices in the primitive and use + * them to generate new primitives. A geometry shader has a fixed output primitive type (point, line strip, or triangle strip) and emits vertices to define + * a new primitive. A geometry shader can emit multiple disconnected primitives. The primitives emitted by the geometry shader are clipped and then + * processed like an equivalent OpenGL primitive specified by the application.
+ * + *Furthermore, ARB_geometry_shader4 provides four additional primitive types: lines with adjacency, line strips with adjacency, separate triangles with + * adjacency, and triangle strips with adjacency. Some of the vertices specified in these new primitive types are not part of the ordinary primitives, + * instead they represent neighboring vertices that are adjacent to the two line segment end points (lines/strips) or the three triangle edges + * (triangles/tstrips). These vertices can be accessed by geometry shaders and used to match up the vertices emitted by the geometry shader with those of + * neighboring primitives.
+ * + *Since geometry shaders expect a specific input primitive type, an error will occur if the application presents primitives of a different type. For + * example, if a geometry shader expects points, an error will occur at {@link GL11#glBegin Begin} time, if a primitive mode of {@link GL11#GL_TRIANGLES TRIANGLES} is specified.
+ * + *Promoted to core in {@link GL32 OpenGL 3.2}.
+ */ +public class ARBGeometryShader4 { + + /** Accepted by the {@code type} parameter of CreateShader and returned by the {@code params} parameter of GetShaderiv. */ + public static final int GL_GEOMETRY_SHADER_ARB = 0x8DD9; + + /** Accepted by the {@code pname} parameter of ProgramParameteriARB and GetProgramiv. */ + public static final int + GL_GEOMETRY_VERTICES_OUT_ARB = 0x8DDA, + GL_GEOMETRY_INPUT_TYPE_ARB = 0x8DDB, + GL_GEOMETRY_OUTPUT_TYPE_ARB = 0x8DDC; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = 0x8C29, + GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB = 0x8DDD, + GL_MAX_VERTEX_VARYING_COMPONENTS_ARB = 0x8DDE, + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = 0x8DDF, + GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB = 0x8DE0, + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = 0x8DE1; + + /** Accepted by the {@code mode} parameter of Begin, DrawArrays, MultiDrawArrays, DrawElements, MultiDrawElements, and DrawRangeElements. */ + public static final int + GL_LINES_ADJACENCY_ARB = 0xA, + GL_LINE_STRIP_ADJACENCY_ARB = 0xB, + GL_TRIANGLES_ADJACENCY_ARB = 0xC, + GL_TRIANGLE_STRIP_ADJACENCY_ARB = 0xD; + + /** Returned by CheckFramebufferStatusARB. */ + public static final int + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = 0x8DA8, + GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = 0x8DA9; + + /** Accepted by the {@code pname} parameter of GetFramebufferAttachment- ParameterivARB. */ + public static final int + GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = 0x8DA7, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetIntegerv, GetFloatv, GetDoublev, and + * GetBooleanv. + */ + public static final int GL_PROGRAM_POINT_SIZE_ARB = 0x8642; + + static { GL.initialize(); } + + protected ARBGeometryShader4() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glProgramParameteriARB, caps.glFramebufferTextureARB, caps.glFramebufferTextureLayerARB, caps.glFramebufferTextureFaceARB + ); + } + + // --- [ glProgramParameteriARB ] --- + + /** + * Sets a program object parameter. + * + *The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated if {@code pname} is {@link #GL_GEOMETRY_INPUT_TYPE_ARB GEOMETRY_INPUT_TYPE_ARB} and {@code value} is not one of {@link GL11#GL_POINTS POINTS}, {@link GL11#GL_LINES LINES}, + * {@link #GL_LINES_ADJACENCY_ARB LINES_ADJACENCY_ARB}, {@link GL11#GL_TRIANGLES TRIANGLES} or {@link #GL_TRIANGLES_ADJACENCY_ARB TRIANGLES_ADJACENCY_ARB}.
+ * + *The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated if {@code pname} is {@link #GL_GEOMETRY_OUTPUT_TYPE_ARB GEOMETRY_OUTPUT_TYPE_ARB} and {@code value} is not one of {@link GL11#GL_POINTS POINTS}, {@link GL11#GL_LINE_STRIP LINE_STRIP} or + * {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP}.
+ * + *The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated if {@code pname} is {@link #GL_GEOMETRY_VERTICES_OUT_ARB GEOMETRY_VERTICES_OUT_ARB} and {@code value} is negative.
+ * + *The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated if {@code pname} is {@link #GL_GEOMETRY_VERTICES_OUT_ARB GEOMETRY_VERTICES_OUT_ARB} and {@code value} exceeds {@link #GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB MAX_GEOMETRY_OUTPUT_VERTICES_ARB}.
+ * + *The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated if {@code pname} is set to {@link #GL_GEOMETRY_VERTICES_OUT_ARB GEOMETRY_VERTICES_OUT_ARB} and the product of {@code value} and the sum of all + * components of all active varying variables exceeds {@link #GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB}.
+ * + * @param program the program object + * @param pname the parameter to set. One of:| {@link #GL_GEOMETRY_VERTICES_OUT_ARB GEOMETRY_VERTICES_OUT_ARB} | {@link #GL_GEOMETRY_INPUT_TYPE_ARB GEOMETRY_INPUT_TYPE_ARB} | {@link #GL_GEOMETRY_OUTPUT_TYPE_ARB GEOMETRY_OUTPUT_TYPE_ARB} |
If {@code texture} is zero, any image or array of images attached to the attachment point named by {@code attachment} is detached, and the state of the + * attachment point is reset to its initial values. {@code level} is ignored if {@code texture} is zero.
+ * + *If {@code texture} is non-zero, FramebufferTextureARB attaches level {@code level} of the texture object named {@code texture} to the framebuffer + * attachment point named by {@code attachment}. The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated if {@code texture} is not the name of a texture object, or if + * {@code level} is not a supported texture level number for textures of the type corresponding to {@code target}. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is + * generated if {@code texture} is the name of a buffer texture.
+ * + *If {@code texture} is the name of a three-dimensional texture, cube map texture, or one- or two-dimensional array texture, the texture level attached to + * the framebuffer attachment point is an array of images, and the framebuffer attachment is considered layered.
+ * + * @param target the render target. Must be:| {@link ARBFramebufferObject#GL_FRAMEBUFFER FRAMEBUFFER} |
If {@code texture} is non-zero, the error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated if {@code layer} is negative, or if {@code texture} is not the name of a + * texture object. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated unless {@code texture} is zero or the name of a three-dimensional or one- or + * two-dimensional array texture.
+ * + * @param target the render target. Must be:| {@link ARBFramebufferObject#GL_FRAMEBUFFER FRAMEBUFFER} |
If {@code texture} is non-zero, the error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated if {@code texture} is not the name of a texture object. The error + * {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated unless {@code texture} is zero or the name of a cube map texture.
+ * + * @param target the render target. Must be:| {@link ARBFramebufferObject#GL_FRAMEBUFFER FRAMEBUFFER} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
This extension introduces new commands to retrieve and set the binary representation of a program object. {@link #glGetProgramBinary GetProgramBinary} allows an application to + * cache compiled and linked programs to avoid compiling and linking when used again. This may even allow the GL itself to act as an offline compiler. The + * resulting program binary can be reloaded into the GL via {@link #glProgramBinary ProgramBinary}. This is a very useful path for applications that wish to remain portable by + * shipping pure GLSL source shaders, yet would like to avoid the cost of compiling their shaders at runtime. Instead an application can supply its GLSL + * source shaders during first application run, or even during installation. The application then compiles and links its shaders and reads back the program + * binaries. On subsequent runs, only the program binaries need be supplied.
+ * + *{@link #glProgramBinary ProgramBinary} may also accept binaries in vendor-specific formats produced by specialized offline compilation tools. This extension does not add any + * such formats, but allows for them in further extensions. Though the level of optimization may not be identical -- the offline shader compiler may have + * the luxury of more aggressive optimization at its disposal -- program binaries generated online by the GL are interchangeable with those generated + * offline by an SDK tool.
+ * + *Requires {@link GL30 OpenGL 3.0}. Promoted to core in {@link GL41 OpenGL 4.1}.
+ */ +public class ARBGetProgramBinary { + + /** Accepted by the {@code pname} parameter of ProgramParameteri and GetProgramiv. */ + public static final int GL_PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257; + + /** Accepted by the {@code pname} parameter of GetProgramiv. */ + public static final int GL_PROGRAM_BINARY_LENGTH = 0x8741; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv and GetDoublev. */ + public static final int + GL_NUM_PROGRAM_BINARY_FORMATS = 0x87FE, + GL_PROGRAM_BINARY_FORMATS = 0x87FF; + + static { GL.initialize(); } + + protected ARBGetProgramBinary() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetProgramBinary, caps.glProgramBinary, caps.glProgramParameteri + ); + } + + // --- [ glGetProgramBinary ] --- + + /** + * Unsafe version of: {@link #glGetProgramBinary GetProgramBinary} + * + * @param bufSize the size of the buffer whose address is given by {@code binary} + */ + public static void nglGetProgramBinary(int program, int bufSize, long length, long binaryFormat, long binary) { + GL41C.nglGetProgramBinary(program, bufSize, length, binaryFormat, binary); + } + + /** + * Returns a binary representation of a program object's compiled and linked executable source. + * + * @param program the name of a program object whose binary representation to retrieve + * @param length the address of a variable to receive the number of bytes written into {@code binary} + * @param binaryFormat a variable to receive a token indicating the format of the binary data returned by the GL + * @param binary an array into which the GL will return {@code program}'s binary representation + */ + public static void glGetProgramBinary(@NativeType("GLuint") int program, @Nullable @NativeType("GLsizei *") IntBuffer length, @NativeType("GLenum *") IntBuffer binaryFormat, @NativeType("void *") ByteBuffer binary) { + GL41C.glGetProgramBinary(program, length, binaryFormat, binary); + } + + // --- [ glProgramBinary ] --- + + /** + * Unsafe version of: {@link #glProgramBinary ProgramBinary} + * + * @param length the number of bytes contained in {@code binary} + */ + public static void nglProgramBinary(int program, int binaryFormat, long binary, int length) { + GL41C.nglProgramBinary(program, binaryFormat, binary, length); + } + + /** + * Loads a program object with a program binary. + * + * @param program the name of a program object into which to load a program binary + * @param binaryFormat the format of the binary data in binary + * @param binary an array containing the binary to be loaded into {@code program} + */ + public static void glProgramBinary(@NativeType("GLuint") int program, @NativeType("GLenum") int binaryFormat, @NativeType("void const *") ByteBuffer binary) { + GL41C.glProgramBinary(program, binaryFormat, binary); + } + + // --- [ glProgramParameteri ] --- + + /** + * Specifies the integer value of a program object parameter. + * + * @param program the name of a program object whose parameter to modify + * @param pname the name of the parameter to modify. One of:| {@link GL41C#GL_PROGRAM_BINARY_RETRIEVABLE_HINT PROGRAM_BINARY_RETRIEVABLE_HINT} | {@link GL41C#GL_PROGRAM_SEPARABLE PROGRAM_SEPARABLE} |
This extension adds a new function to get sub-regions of texture images.
+ * + *Requires {@link GL20 OpenGL 2.0}. Promoted to core in {@link GL45 OpenGL 4.5}.
+ */ +public class ARBGetTextureSubImage { + + static { GL.initialize(); } + + protected ARBGetTextureSubImage() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetTextureSubImage, caps.glGetCompressedTextureSubImage + ); + } + + // --- [ glGetTextureSubImage ] --- + + /** + * Unsafe version of: {@link #glGetTextureSubImage GetTextureSubImage} + * + * @param bufSize the size of the buffer to receive the retrieved pixel data + */ + public static void nglGetTextureSubImage(int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int format, int type, int bufSize, long pixels) { + GL45C.nglGetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels); + } + + /** + * Obtains sub-regions of a texture image from a texture object. + * + * @param texture the source texture object name + * @param level the level-of-detail number + * @param xoffset the x-position of the subregion + * @param yoffset the y-position of the subregion + * @param zoffset the z-position of the subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the pixel format. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
This extension introduces a new data type for half-precision (16-bit) floating-point quantities. The floating-point format is very similar to the IEEE + * single-precision floating-point standard, except that it has only 5 exponent bits and 10 mantissa bits. Half-precision floats are smaller than full + * precision floats and provide a larger dynamic range than similarly sized normalized scalar data types.
+ * + *This extension allows applications to use half-precision floating-point data when specifying pixel data. It extends the existing image specification + * commands to accept the new data type.
+ * + *Floating-point data is clamped to [0, 1] at various places in the GL unless clamping is disabled with the ARB_color_buffer_float extension.
+ * + *Requires {@link GL15 OpenGL 1.5}. Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public final class ARBHalfFloatPixel { + + /** + * Accepted by the {@code type} parameter of DrawPixels, ReadPixels, TexImage1D, TexImage2D, TexImage3D, GetTexImage, TexSubImage1D, TexSubImage2D, + * TexSubImage3D, GetHistogram, GetMinmax, ConvolutionFilter1D, ConvolutionFilter2D, GetConvolutionFilter, SeparableFilter2D, GetSeparableFilter, + * ColorTable, ColorSubTable, and GetColorTable. + */ + public static final int GL_HALF_FLOAT_ARB = 0x140B; + + private ARBHalfFloatPixel() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBHalfFloatVertex.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBHalfFloatVertex.java new file mode 100644 index 00000000..e05e03ce --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBHalfFloatVertex.java @@ -0,0 +1,31 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_half_float_vertex extension. + * + *This extension extends the usage of the half-precision (16-bit) floating-point quantities introduced in {@link ARBHalfFloatPixel ARB_half_float_pixel} for usage in + * specifying vertex array data.
+ * + *This extension allows applications to use half-precision floating point data when specifying vertices. This can allow applications to reduce their + * memory footprint, as well as the memory bandwidth required for vertex data.
+ * + *This extension extends the existing vertex array commands to accept the new data type.
+ * + *Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public final class ARBHalfFloatVertex { + + /** + * Accepted by the {@code type} argument of VertexPointer, NormalPointer, ColorPointer, SecondaryColorPointer, FogCoordPointer, TexCoordPointer, and + * VertexAttribPointer. + */ + public static final int GL_HALF_FLOAT = 0x140B; + + private ARBHalfFloatVertex() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBImaging.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBImaging.java new file mode 100644 index 00000000..103e59d8 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBImaging.java @@ -0,0 +1,1317 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** Native bindings to the OpenGL 1.2 optional imaging subset. */ +public class ARBImaging { + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev, and by the {@code target} parameter of ColorTable, CopyColorTable, ColorTableParameteriv, ColorTableParameterfv, + * GetColorTable, GetColorTableParameteriv, and GetColorTableParameterfv. + */ + public static final int + GL_COLOR_TABLE = 0x80D0, + GL_POST_CONVOLUTION_COLOR_TABLE = 0x80D1, + GL_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2; + + /** Accepted by the {@code target} parameter of ColorTable, GetColorTableParameteriv, and GetColorTableParameterfv. */ + public static final int + GL_PROXY_COLOR_TABLE = 0x80D3, + GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4, + GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5; + + /** + * Accepted by the {@code pname} parameter of ColorTableParameteriv, ColorTableParameterfv, GetColorTableParameteriv, and + * GetColorTableParameterfv. + */ + public static final int + GL_COLOR_TABLE_SCALE = 0x80D6, + GL_COLOR_TABLE_BIAS = 0x80D7; + + /** Accepted by the {@code pname} parameter of GetColorTableParameteriv and GetColorTableParameterfv. */ + public static final int + GL_COLOR_TABLE_FORMAT = 0x80D8, + GL_COLOR_TABLE_WIDTH = 0x80D9, + GL_COLOR_TABLE_RED_SIZE = 0x80DA, + GL_COLOR_TABLE_GREEN_SIZE = 0x80DB, + GL_COLOR_TABLE_BLUE_SIZE = 0x80DC, + GL_COLOR_TABLE_ALPHA_SIZE = 0x80DD, + GL_COLOR_TABLE_LUMINANCE_SIZE = 0x80DE, + GL_COLOR_TABLE_INTENSITY_SIZE = 0x80DF; + + /** ErrorCode */ + public static final int GL_TABLE_TOO_LARGE = 0x8031; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev, and by the {@code target} parameter of ConvolutionFilter1D, CopyConvolutionFilter1D, GetConvolutionFilter, ConvolutionParameteri, + * ConvolutionParameterf, ConvolutionParameteriv, ConvolutionParameterfv, GetConvolutionParameteriv, and GetConvolutionParameterfv. + */ + public static final int GL_CONVOLUTION_1D = 0x8010; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev, and by the {@code target} parameter of ConvolutionFilter2D, CopyConvolutionFilter2D, GetConvolutionFilter, ConvolutionParameteri, + * ConvolutionParameterf, ConvolutionParameteriv, ConvolutionParameterfv, GetConvolutionParameteriv, and GetConvolutionParameterfv. + */ + public static final int GL_CONVOLUTION_2D = 0x8011; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev, and by the {@code target} parameter of SeparableFilter2D, SeparableFilter2D, GetSeparableFilter, ConvolutionParameteri, + * ConvolutionParameterf, ConvolutionParameteriv, ConvolutionParameterfv, GetConvolutionParameteriv, and GetConvolutionParameterfv. + */ + public static final int GL_SEPARABLE_2D = 0x8012; + + /** + * Accepted by the {@code pname} parameter of ConvolutionParameteri, ConvolutionParameterf, ConvolutionParameteriv, ConvolutionParameterfv, + * GetConvolutionParameteriv, and GetConvolutionParameterfv. + */ + public static final int GL_CONVOLUTION_BORDER_MODE = 0x8013; + + /** Accepted by the {@code pname} parameter of ConvolutionParameteriv, ConvolutionParameterfv, GetConvolutionParameteriv, and GetConvolutionParameterfv. */ + public static final int + GL_CONVOLUTION_FILTER_SCALE = 0x8014, + GL_CONVOLUTION_FILTER_BIAS = 0x8015; + + /** + * Accepted by the {@code param} parameter of ConvolutionParameteri, and ConvolutionParameterf, and by the {@code params} parameter of + * ConvolutionParameteriv and ConvolutionParameterfv, when the {@code pname} parameter is CONVOLUTION_BORDER_MODE. + */ + public static final int GL_REDUCE = 0x8016; + + /** Accepted by the {@code pname} parameter of GetConvolutionParameteriv and GetConvolutionParameterfv. */ + public static final int + GL_CONVOLUTION_FORMAT = 0x8017, + GL_CONVOLUTION_WIDTH = 0x8018, + GL_CONVOLUTION_HEIGHT = 0x8019, + GL_MAX_CONVOLUTION_WIDTH = 0x801A, + GL_MAX_CONVOLUTION_HEIGHT = 0x801B; + + /** + * Accepted by the {@code pname} parameter of PixelTransferi, PixelTransferf, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, + * and GetDoublev. + */ + public static final int + GL_POST_CONVOLUTION_RED_SCALE = 0x801C, + GL_POST_CONVOLUTION_GREEN_SCALE = 0x801D, + GL_POST_CONVOLUTION_BLUE_SCALE = 0x801E, + GL_POST_CONVOLUTION_ALPHA_SCALE = 0x801F, + GL_POST_CONVOLUTION_RED_BIAS = 0x8020, + GL_POST_CONVOLUTION_GREEN_BIAS = 0x8021, + GL_POST_CONVOLUTION_BLUE_BIAS = 0x8022, + GL_POST_CONVOLUTION_ALPHA_BIAS = 0x8023; + + /** + * Accepted by the {@code param} parameter of ConvolutionParameteri, and ConvolutionParameterf, and by the {@code params} parameter of + * ConvolutionParameteriv and ConvolutionParameterfv, when the {@code pname} parameter is CONVOLUTION_BORDER_MODE. + */ + public static final int + GL_CONSTANT_BORDER = 0x8151, + GL_REPLICATE_BORDER = 0x8153; + + /** Accepted by the {@code pname} parameter of ConvolutionParameteriv, ConvolutionParameterfv, GetConvolutionParameteriv, and GetConvolutionParameterfv. */ + public static final int GL_CONVOLUTION_BORDER_COLOR = 0x8154; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_COLOR_MATRIX = 0x80B1, + GL_COLOR_MATRIX_STACK_DEPTH = 0x80B2, + GL_MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3; + + /** Accepted by the {@code pname} parameter of PixelTransfer*, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_POST_COLOR_MATRIX_RED_SCALE = 0x80B4, + GL_POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5, + GL_POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6, + GL_POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7, + GL_POST_COLOR_MATRIX_RED_BIAS = 0x80B8, + GL_POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9, + GL_POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA, + GL_POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev, and by the {@code target} parameter of Histogram, ResetHistogram, GetHistogram, GetHistogramParameteriv, and + * GetHistogramParameterfv. + */ + public static final int GL_HISTOGRAM = 0x8024; + + /** Accepted by the {@code target} parameter of Histogram, GetHistogramParameteriv, and GetHistogramParameterfv. */ + public static final int GL_PROXY_HISTOGRAM = 0x8025; + + /** Accepted by the {@code pname} parameter of GetHistogramParameteriv and GetHistogramParameterfv. */ + public static final int + GL_HISTOGRAM_WIDTH = 0x8026, + GL_HISTOGRAM_FORMAT = 0x8027, + GL_HISTOGRAM_RED_SIZE = 0x8028, + GL_HISTOGRAM_GREEN_SIZE = 0x8029, + GL_HISTOGRAM_BLUE_SIZE = 0x802A, + GL_HISTOGRAM_ALPHA_SIZE = 0x802B, + GL_HISTOGRAM_LUMINANCE_SIZE = 0x802C, + GL_HISTOGRAM_SINK = 0x802D; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev, and by the {@code target} parameter of Minmax, ResetMinmax, GetMinmax, GetMinmaxParameteriv, and GetMinmaxParameterfv. + */ + public static final int GL_MINMAX = 0x802E; + + /** Accepted by the {@code pname} parameter of GetMinmaxParameteriv and GetMinmaxParameterfv. */ + public static final int + GL_MINMAX_FORMAT = 0x802F, + GL_MINMAX_SINK = 0x8030; + + /** Accepted by the {@code sfactor} and {@code dfactor} parameters of BlendFunc. */ + public static final int + GL_CONSTANT_COLOR = 0x8001, + GL_ONE_MINUS_CONSTANT_COLOR = 0x8002, + GL_CONSTANT_ALPHA = 0x8003, + GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_BLEND_COLOR = 0x8005; + + /** Accepted by the {@code mode} parameter of BlendEquation. */ + public static final int + GL_FUNC_ADD = 0x8006, + GL_MIN = 0x8007, + GL_MAX = 0x8008; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_BLEND_EQUATION = 0x8009; + + /** Accepted by the {@code mode} parameter of BlendEquation. */ + public static final int + GL_FUNC_SUBTRACT = 0x800A, + GL_FUNC_REVERSE_SUBTRACT = 0x800B; + + static { GL.initialize(); } + + protected ARBImaging() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, boolean fc) { + return (fc || checkFunctions( + caps.glColorTable, caps.glCopyColorTable, caps.glColorTableParameteriv, caps.glColorTableParameterfv, caps.glGetColorTable, + caps.glGetColorTableParameteriv, caps.glGetColorTableParameterfv, caps.glColorSubTable, caps.glCopyColorSubTable, caps.glConvolutionFilter1D, + caps.glConvolutionFilter2D, caps.glCopyConvolutionFilter1D, caps.glCopyConvolutionFilter2D, caps.glGetConvolutionFilter, caps.glSeparableFilter2D, + caps.glGetSeparableFilter, caps.glConvolutionParameteri, caps.glConvolutionParameteriv, caps.glConvolutionParameterf, caps.glConvolutionParameterfv, + caps.glGetConvolutionParameteriv, caps.glGetConvolutionParameterfv, caps.glHistogram, caps.glResetHistogram, caps.glGetHistogram, + caps.glGetHistogramParameteriv, caps.glGetHistogramParameterfv, caps.glMinmax, caps.glResetMinmax, caps.glGetMinmax, caps.glGetMinmaxParameteriv, + caps.glGetMinmaxParameterfv + )) && checkFunctions( + caps.glBlendColor, caps.glBlendEquation + ); + } + + // --- [ glColorTable ] --- + + /** Unsafe version of: {@link #glColorTable ColorTable} */ + public static native void nglColorTable(int target, int internalformat, int width, int format, int type, long table); + + /** + * Specifies a color lookup table. + * + * @param target the color table target. One of:| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link #GL_PROXY_COLOR_TABLE PROXY_COLOR_TABLE} | {@link #GL_PROXY_POST_CONVOLUTION_COLOR_TABLE PROXY_POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE PROXY_POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link #GL_PROXY_COLOR_TABLE PROXY_COLOR_TABLE} | {@link #GL_PROXY_POST_CONVOLUTION_COLOR_TABLE PROXY_POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE PROXY_POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link #GL_PROXY_COLOR_TABLE PROXY_COLOR_TABLE} | {@link #GL_PROXY_POST_CONVOLUTION_COLOR_TABLE PROXY_POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE PROXY_POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link #GL_PROXY_COLOR_TABLE PROXY_COLOR_TABLE} | {@link #GL_PROXY_POST_CONVOLUTION_COLOR_TABLE PROXY_POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE PROXY_POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link #GL_PROXY_COLOR_TABLE PROXY_COLOR_TABLE} | {@link #GL_PROXY_POST_CONVOLUTION_COLOR_TABLE PROXY_POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE PROXY_POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link #GL_COLOR_TABLE_SCALE COLOR_TABLE_SCALE} | {@link #GL_COLOR_TABLE_BIAS COLOR_TABLE_BIAS} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link #GL_PROXY_COLOR_TABLE PROXY_COLOR_TABLE} | {@link #GL_PROXY_POST_CONVOLUTION_COLOR_TABLE PROXY_POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE PROXY_POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link #GL_COLOR_TABLE_SCALE COLOR_TABLE_SCALE} | {@link #GL_COLOR_TABLE_BIAS COLOR_TABLE_BIAS} | {@link #GL_COLOR_TABLE_FORMAT COLOR_TABLE_FORMAT} |
| {@link #GL_COLOR_TABLE_WIDTH COLOR_TABLE_WIDTH} | {@link #GL_COLOR_TABLE_RED_SIZE COLOR_TABLE_RED_SIZE} | {@link #GL_COLOR_TABLE_GREEN_SIZE COLOR_TABLE_GREEN_SIZE} |
| {@link #GL_COLOR_TABLE_BLUE_SIZE COLOR_TABLE_BLUE_SIZE} | {@link #GL_COLOR_TABLE_ALPHA_SIZE COLOR_TABLE_ALPHA_SIZE} | {@link #GL_COLOR_TABLE_LUMINANCE_SIZE COLOR_TABLE_LUMINANCE_SIZE} |
| {@link #GL_COLOR_TABLE_INTENSITY_SIZE COLOR_TABLE_INTENSITY_SIZE} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link #GL_PROXY_COLOR_TABLE PROXY_COLOR_TABLE} | {@link #GL_PROXY_POST_CONVOLUTION_COLOR_TABLE PROXY_POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE PROXY_POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link #GL_COLOR_TABLE_SCALE COLOR_TABLE_SCALE} | {@link #GL_COLOR_TABLE_BIAS COLOR_TABLE_BIAS} | {@link #GL_COLOR_TABLE_FORMAT COLOR_TABLE_FORMAT} |
| {@link #GL_COLOR_TABLE_WIDTH COLOR_TABLE_WIDTH} | {@link #GL_COLOR_TABLE_RED_SIZE COLOR_TABLE_RED_SIZE} | {@link #GL_COLOR_TABLE_GREEN_SIZE COLOR_TABLE_GREEN_SIZE} |
| {@link #GL_COLOR_TABLE_BLUE_SIZE COLOR_TABLE_BLUE_SIZE} | {@link #GL_COLOR_TABLE_ALPHA_SIZE COLOR_TABLE_ALPHA_SIZE} | {@link #GL_COLOR_TABLE_LUMINANCE_SIZE COLOR_TABLE_LUMINANCE_SIZE} |
| {@link #GL_COLOR_TABLE_INTENSITY_SIZE COLOR_TABLE_INTENSITY_SIZE} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_COLOR_TABLE COLOR_TABLE} | {@link #GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link #GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link #GL_CONVOLUTION_1D CONVOLUTION_1D} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_CONVOLUTION_1D CONVOLUTION_1D} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_CONVOLUTION_2D CONVOLUTION_2D} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_CONVOLUTION_2D CONVOLUTION_2D} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_CONVOLUTION_1D CONVOLUTION_1D} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link #GL_CONVOLUTION_2D CONVOLUTION_2D} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link #GL_CONVOLUTION_1D CONVOLUTION_1D} | {@link #GL_CONVOLUTION_2D CONVOLUTION_2D} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_CONVOLUTION_1D CONVOLUTION_1D} | {@link #GL_CONVOLUTION_2D CONVOLUTION_2D} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_SEPARABLE_2D SEPARABLE_2D} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_SEPARABLE_2D SEPARABLE_2D} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_SEPARABLE_2D SEPARABLE_2D} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_SEPARABLE_2D SEPARABLE_2D} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_CONVOLUTION_1D CONVOLUTION_1D} | {@link #GL_CONVOLUTION_2D CONVOLUTION_2D} | {@link #GL_SEPARABLE_2D SEPARABLE_2D} |
| {@link #GL_CONVOLUTION_BORDER_MODE CONVOLUTION_BORDER_MODE} |
| {@link #GL_CONVOLUTION_FILTER_SCALE CONVOLUTION_FILTER_SCALE} | {@link #GL_CONVOLUTION_FILTER_BIAS CONVOLUTION_FILTER_BIAS} | {@link #GL_CONVOLUTION_BORDER_COLOR CONVOLUTION_BORDER_COLOR} |
| {@link #GL_CONVOLUTION_FILTER_SCALE CONVOLUTION_FILTER_SCALE} | {@link #GL_CONVOLUTION_FILTER_BIAS CONVOLUTION_FILTER_BIAS} | {@link #GL_CONVOLUTION_BORDER_COLOR CONVOLUTION_BORDER_COLOR} |
| {@link #GL_CONVOLUTION_1D CONVOLUTION_1D} | {@link #GL_CONVOLUTION_2D CONVOLUTION_2D} | {@link #GL_SEPARABLE_2D SEPARABLE_2D} |
| {@link #GL_CONVOLUTION_FORMAT CONVOLUTION_FORMAT} | {@link #GL_CONVOLUTION_WIDTH CONVOLUTION_WIDTH} | {@link #GL_CONVOLUTION_HEIGHT CONVOLUTION_HEIGHT} | {@link #GL_MAX_CONVOLUTION_WIDTH MAX_CONVOLUTION_WIDTH} |
| {@link #GL_MAX_CONVOLUTION_HEIGHT MAX_CONVOLUTION_HEIGHT} |
| {@link #GL_CONVOLUTION_1D CONVOLUTION_1D} | {@link #GL_CONVOLUTION_2D CONVOLUTION_2D} | {@link #GL_SEPARABLE_2D SEPARABLE_2D} |
| {@link #GL_CONVOLUTION_FORMAT CONVOLUTION_FORMAT} | {@link #GL_CONVOLUTION_WIDTH CONVOLUTION_WIDTH} | {@link #GL_CONVOLUTION_HEIGHT CONVOLUTION_HEIGHT} | {@link #GL_MAX_CONVOLUTION_WIDTH MAX_CONVOLUTION_WIDTH} |
| {@link #GL_MAX_CONVOLUTION_HEIGHT MAX_CONVOLUTION_HEIGHT} |
| {@link #GL_HISTOGRAM HISTOGRAM} | {@link #GL_PROXY_HISTOGRAM PROXY_HISTOGRAM} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link #GL_HISTOGRAM HISTOGRAM} |
| {@link #GL_HISTOGRAM HISTOGRAM} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_HISTOGRAM HISTOGRAM} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_HISTOGRAM HISTOGRAM} |
| {@link #GL_HISTOGRAM_WIDTH HISTOGRAM_WIDTH} | {@link #GL_HISTOGRAM_FORMAT HISTOGRAM_FORMAT} | {@link #GL_HISTOGRAM_RED_SIZE HISTOGRAM_RED_SIZE} | {@link #GL_HISTOGRAM_GREEN_SIZE HISTOGRAM_GREEN_SIZE} |
| {@link #GL_HISTOGRAM_BLUE_SIZE HISTOGRAM_BLUE_SIZE} | {@link #GL_HISTOGRAM_ALPHA_SIZE HISTOGRAM_ALPHA_SIZE} | {@link #GL_HISTOGRAM_LUMINANCE_SIZE HISTOGRAM_LUMINANCE_SIZE} | {@link #GL_HISTOGRAM_SINK HISTOGRAM_SINK} |
| {@link #GL_HISTOGRAM HISTOGRAM} |
| {@link #GL_HISTOGRAM_WIDTH HISTOGRAM_WIDTH} | {@link #GL_HISTOGRAM_FORMAT HISTOGRAM_FORMAT} | {@link #GL_HISTOGRAM_RED_SIZE HISTOGRAM_RED_SIZE} | {@link #GL_HISTOGRAM_GREEN_SIZE HISTOGRAM_GREEN_SIZE} |
| {@link #GL_HISTOGRAM_BLUE_SIZE HISTOGRAM_BLUE_SIZE} | {@link #GL_HISTOGRAM_ALPHA_SIZE HISTOGRAM_ALPHA_SIZE} | {@link #GL_HISTOGRAM_LUMINANCE_SIZE HISTOGRAM_LUMINANCE_SIZE} | {@link #GL_HISTOGRAM_SINK HISTOGRAM_SINK} |
| {@link #GL_MINMAX MINMAX} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} | {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} |
| {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} |
| {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_LUMINANCE LUMINANCE} |
| {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} | {@link GL11#GL_INTENSITY INTENSITY} | {@link GL11#GL_ALPHA4 ALPHA4} | {@link GL11#GL_ALPHA8 ALPHA8} | {@link GL11#GL_ALPHA12 ALPHA12} | {@link GL11#GL_ALPHA16 ALPHA16} | {@link GL11#GL_LUMINANCE4 LUMINANCE4} | {@link GL11#GL_LUMINANCE8 LUMINANCE8} |
| {@link GL11#GL_LUMINANCE12 LUMINANCE12} | {@link GL11#GL_LUMINANCE16 LUMINANCE16} | {@link GL11#GL_LUMINANCE4_ALPHA4 LUMINANCE4_ALPHA4} | {@link GL11#GL_LUMINANCE6_ALPHA2 LUMINANCE6_ALPHA2} | {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8} | {@link GL11#GL_LUMINANCE12_ALPHA4 LUMINANCE12_ALPHA4} | {@link GL11#GL_LUMINANCE12_ALPHA12 LUMINANCE12_ALPHA12} | {@link GL11#GL_LUMINANCE16_ALPHA16 LUMINANCE16_ALPHA16} |
| {@link GL11#GL_INTENSITY4 INTENSITY4} | {@link GL11#GL_INTENSITY8 INTENSITY8} | {@link GL11#GL_INTENSITY12 INTENSITY12} | {@link GL11#GL_INTENSITY16 INTENSITY16} | {@link GL21#GL_SLUMINANCE SLUMINANCE} | {@link GL21#GL_SLUMINANCE8_ALPHA8 SLUMINANCE8_ALPHA8} |
| {@link #GL_MINMAX MINMAX} |
| {@link #GL_MINMAX MINMAX} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_MINMAX MINMAX} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_MINMAX MINMAX} |
| {@link #GL_MINMAX MINMAX} |
| {@link #GL_MINMAX MINMAX} |
| {@link #GL_MINMAX MINMAX} |
| {@link GL14C#GL_FUNC_ADD FUNC_ADD} | {@link GL14C#GL_FUNC_SUBTRACT FUNC_SUBTRACT} | {@link GL14C#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} | {@link GL14C#GL_MIN MIN} | {@link GL14C#GL_MAX MAX} |
OpenGL 4.3 (with the introduction of the {@link ARBMultiDrawIndirect ARB_multi_draw_indirect} extension) enhanced the ability of OpenGL to allow a large sets of parameters + * for indirect draws (introduced with OpenGL 4.0) into a buffer object and dispatch the entire list with one API call. This allows, for example, a shader + * (such as a compute shader via shader storage buffers, or a geometry shader via transform feedback) to produce lists of draw commands that can then be + * consumed by OpenGL without a server-client round trip. However, when a variable and potentially unknown number of draws are produced by such a shader, + * it becomes difficult to know how many draws are in the output array(s). Applications must resort to techniques such as transform feedback primitive + * queries, or mapping buffers containing the content of atomic counters, which can cause stalls or bubbles in the OpenGL pipeline.
+ * + *This extension introduces the concept of the "parameter buffer", which is a target allowing buffers to store parameters for certain drawing commands. + * Also in this extension, new variants of {@link GL43C#glMultiDrawArraysIndirect MultiDrawArraysIndirect} and {@link GL43C#glMultiDrawElementsIndirect MultiDrawElementsIndirect} are introduced that source some of their + * parameters from this buffer. Further commands could potentially be introduced that source other parameters from a buffer.
+ * + *Requires {@link GL42 OpenGL 4.2}.
+ */ +public class ARBIndirectParameters { + + /** + * Accepted by the {@code target} parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, GetBufferPointerv, + * MapBufferRange, FlushMappedBufferRange, GetBufferParameteriv, and CopyBufferSubData. + */ + public static final int GL_PARAMETER_BUFFER_ARB = 0x80EE; + + /** Accepted by the {@code value} parameter of GetIntegerv, GetBooleanv, GetFloatv, and GetDoublev. */ + public static final int GL_PARAMETER_BUFFER_BINDING_ARB = 0x80EF; + + static { GL.initialize(); } + + protected ARBIndirectParameters() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glMultiDrawArraysIndirectCountARB, caps.glMultiDrawElementsIndirectCountARB + ); + } + + // --- [ glMultiDrawArraysIndirectCountARB ] --- + + /** Unsafe version of: {@link #glMultiDrawArraysIndirectCountARB MultiDrawArraysIndirectCountARB} */ + public static native void nglMultiDrawArraysIndirectCountARB(int mode, long indirect, long drawcount, int maxdrawcount, int stride); + + /** + * Behaves similarly to {@link GL43C#glMultiDrawArraysIndirect MultiDrawArraysIndirect}, except that {@code drawcount} defines an offset (in bytes) into the buffer object bound to the + * {@link #GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} binding point at which a single {@code sizei} typed value is stored, which contains the draw count. {@code maxdrawcount} specifies + * the maximum number of draws that are expected to be stored in the buffer. If the value stored at {@code drawcount} into the buffer is greater than + * {@code maxdrawcount}, an implementation stop processing draws after {@code maxdrawcount} parameter sets. {@code drawcount} must be a multiple of four. + * + * @param mode what kind of primitives to render. One of:| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
A common use case in GL for some applications is to be able to draw the same object, or groups of similar objects that share vertex data, primitive + * count and type, multiple times. This extension provides a means of accelerating such use cases while restricting the number of API calls, and keeping + * the amount of duplicate data to a minimum.
+ * + *In particular, this extension specifies an alternative to the read-only shader variable introduced by ARB_draw_instanced. It uses the same draw calls + * introduced by that extension, but redefines them so that a vertex shader can instead use vertex array attributes as a source of instance data.
+ * + *This extension introduces an array "divisor" for generic vertex array attributes, which when non-zero specifies that the attribute is "instanced". An + * instanced attribute does not advance per-vertex as usual, but rather after every {@code divisor} conceptual draw calls.
+ * + *(Attributes which aren't instanced are repeated in their entirety for every conceptual draw call.)
+ * + *By specifying transform data in an instanced attribute or series of instanced attributes, vertex shaders can, in concert with the instancing draw calls, + * draw multiple instances of an object with one draw call.
+ * + *Promoted to core in {@link GL33 OpenGL 3.3}.
+ */ +public class ARBInstancedArrays { + + /** Accepted by the {@code pname} parameters of GetVertexAttribdv, GetVertexAttribfv, and GetVertexAttribiv. */ + public static final int GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB = 0x88FE; + + static { GL.initialize(); } + + protected ARBInstancedArrays() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetThis function was added to the extension specification in July 2013. Implemenations are allowed to expose ARB_instanced_arrays without providing this + * function. The correct way to test its availability is:
+ * + *
+ * GLCapabilities caps = GL.getCapabilities();
+ * if (caps.GL_ARB_instanced_arrays && ARBInstancedArrays.getInstance().VertexArrayVertexAttribDivisorEXT != NULL) {
+ * glVertexArrayVertexAttribDivisorEXT(...); // the DSA function can now be used
+ * }OpenGL 4.1 has a number of queries to indicate the maximum number of samples available for different formats. These give a coarse-grained query + * mechanism e.g. an implementation can expose different sample counts for integer and floating-point formats, but not for different floating-point + * formats. There is also no convenient way for the user to determine the granularity of sample counts available, only the maximum.
+ * + *This extension adds a query mechanism that allows the user to determine which sample counts are available for a specific internal format.
+ * + *Requires {@link GL30 OpenGL 3.0} or {@link ARBFramebufferObject ARB_framebuffer_object}. Promoted to core in {@link GL42 OpenGL 4.2}.
+ */ +public class ARBInternalformatQuery { + + /** Accepted by the {@code pname} parameter of GetInternalformativ. */ + public static final int GL_NUM_SAMPLE_COUNTS = 0x9380; + + static { GL.initialize(); } + + protected ARBInternalformatQuery() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetInternalformativ + ); + } + + // --- [ glGetInternalformativ ] --- + + /** + * Unsafe version of: {@link #glGetInternalformativ GetInternalformativ} + * + * @param bufSize the maximum number of values that may be written to params by the function + */ + public static void nglGetInternalformativ(int target, int internalformat, int pname, int bufSize, long params) { + GL42C.nglGetInternalformativ(target, internalformat, pname, bufSize, params); + } + + /** + * Retrieves information about implementation-dependent support for internal formats. + * + * @param target the usage of the internal format. One of:| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
This extension extends the {@link ARBInternalformatQuery#glGetInternalformativ GetInternalformativ} query that was added in the {@link ARBInternalformatQuery ARB_internalformat_query} extension to + * provide applications with more granular per-format capability information.
+ * + *This extension allows the remainder of the texture-style targets to be specified along with any possible internal format. We add queries for additional + * properties supported for an internal format in addition to the multisample-related information that was added in ARB_internalformat_query.
+ * + *The goals of this extension are to:
+ * + *While much of this information can be determined for a single GL version by careful examination of the specification, support for many of these + * properties has been gradually introduced over a number of API revisions. This can observed when considering the range in functionality between the + * various versions of GL 2, 3, and 4, as well as GL ES 2 and 3.
+ * + *In the case of an application which wishes to be scalable and able to run on a variety of possible GL or GL ES versions without being specifically + * tailored for each version, it must either have knowledge of the specifications built up into either the code or tables, or it must do a number of tests + * on startup to determine which capabilities are present.
+ * + *In OpenGL, other than the course-grained extension mechanism, many limitations of, or limited support for, an internalformat can only be signaled by + * failing an operation or by operating at reduced performance. Thus, such tests often involve attempts to create resources, using them in specific ways + * and benchmarking the operations to find out if it is supported in the desired form, and at a required performance level. The extension provides a way + * for these properties and caveats to be directly queried from the implementation.
+ * + *This extension is NOT intended to allow implementations to only support a subset of features that are required by a specific GL version, nor is it + * intended to replace the proper use of extension checks for optional functionality.
+ * + *Requires {@link GL20 OpenGL 2.0} and {@link ARBInternalformatQuery ARB_internalformat_query}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public class ARBInternalformatQuery2 { + + /** Accepted by the {@code target} parameter of GetInternalformativ and GetInternalformati64v. */ + public static final int + GL_TEXTURE_1D = 0xDE0, + GL_TEXTURE_1D_ARRAY = 0x8C18, + GL_TEXTURE_2D = 0xDE1, + GL_TEXTURE_2D_ARRAY = 0x8C1A, + GL_TEXTURE_3D = 0x806F, + GL_TEXTURE_CUBE_MAP = 0x8513, + GL_TEXTURE_CUBE_MAP_ARRAY = 0x9009, + GL_TEXTURE_RECTANGLE = 0x84F5, + GL_TEXTURE_BUFFER = 0x8C2A, + GL_RENDERBUFFER = 0x8D41, + GL_TEXTURE_2D_MULTISAMPLE = 0x9100, + GL_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102; + + /** Accepted by the {@code pname} parameter of GetInternalformativ and GetInternalformati64v. */ + public static final int + GL_SAMPLES = 0x80A9, + GL_NUM_SAMPLE_COUNTS = 0x9380, + GL_INTERNALFORMAT_SUPPORTED = 0x826F, + GL_INTERNALFORMAT_PREFERRED = 0x8270, + GL_INTERNALFORMAT_RED_SIZE = 0x8271, + GL_INTERNALFORMAT_GREEN_SIZE = 0x8272, + GL_INTERNALFORMAT_BLUE_SIZE = 0x8273, + GL_INTERNALFORMAT_ALPHA_SIZE = 0x8274, + GL_INTERNALFORMAT_DEPTH_SIZE = 0x8275, + GL_INTERNALFORMAT_STENCIL_SIZE = 0x8276, + GL_INTERNALFORMAT_SHARED_SIZE = 0x8277, + GL_INTERNALFORMAT_RED_TYPE = 0x8278, + GL_INTERNALFORMAT_GREEN_TYPE = 0x8279, + GL_INTERNALFORMAT_BLUE_TYPE = 0x827A, + GL_INTERNALFORMAT_ALPHA_TYPE = 0x827B, + GL_INTERNALFORMAT_DEPTH_TYPE = 0x827C, + GL_INTERNALFORMAT_STENCIL_TYPE = 0x827D, + GL_MAX_WIDTH = 0x827E, + GL_MAX_HEIGHT = 0x827F, + GL_MAX_DEPTH = 0x8280, + GL_MAX_LAYERS = 0x8281, + GL_MAX_COMBINED_DIMENSIONS = 0x8282, + GL_COLOR_COMPONENTS = 0x8283, + GL_DEPTH_COMPONENTS = 0x8284, + GL_STENCIL_COMPONENTS = 0x8285, + GL_COLOR_RENDERABLE = 0x8286, + GL_DEPTH_RENDERABLE = 0x8287, + GL_STENCIL_RENDERABLE = 0x8288, + GL_FRAMEBUFFER_RENDERABLE = 0x8289, + GL_FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A, + GL_FRAMEBUFFER_BLEND = 0x828B, + GL_READ_PIXELS = 0x828C, + GL_READ_PIXELS_FORMAT = 0x828D, + GL_READ_PIXELS_TYPE = 0x828E, + GL_TEXTURE_IMAGE_FORMAT = 0x828F, + GL_TEXTURE_IMAGE_TYPE = 0x8290, + GL_GET_TEXTURE_IMAGE_FORMAT = 0x8291, + GL_GET_TEXTURE_IMAGE_TYPE = 0x8292, + GL_MIPMAP = 0x8293, + GL_MANUAL_GENERATE_MIPMAP = 0x8294, + GL_AUTO_GENERATE_MIPMAP = 0x8295, + GL_COLOR_ENCODING = 0x8296, + GL_SRGB_READ = 0x8297, + GL_SRGB_WRITE = 0x8298, + GL_SRGB_DECODE_ARB = 0x8299, + GL_FILTER = 0x829A, + GL_VERTEX_TEXTURE = 0x829B, + GL_TESS_CONTROL_TEXTURE = 0x829C, + GL_TESS_EVALUATION_TEXTURE = 0x829D, + GL_GEOMETRY_TEXTURE = 0x829E, + GL_FRAGMENT_TEXTURE = 0x829F, + GL_COMPUTE_TEXTURE = 0x82A0, + GL_TEXTURE_SHADOW = 0x82A1, + GL_TEXTURE_GATHER = 0x82A2, + GL_TEXTURE_GATHER_SHADOW = 0x82A3, + GL_SHADER_IMAGE_LOAD = 0x82A4, + GL_SHADER_IMAGE_STORE = 0x82A5, + GL_SHADER_IMAGE_ATOMIC = 0x82A6, + GL_IMAGE_TEXEL_SIZE = 0x82A7, + GL_IMAGE_COMPATIBILITY_CLASS = 0x82A8, + GL_IMAGE_PIXEL_FORMAT = 0x82A9, + GL_IMAGE_PIXEL_TYPE = 0x82AA, + GL_IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7, + GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC, + GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD, + GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE, + GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF, + GL_TEXTURE_COMPRESSED = 0x86A1, + GL_TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1, + GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2, + GL_TEXTURE_COMPRESSED_BLOCK_SIZE = 0x82B3, + GL_CLEAR_BUFFER = 0x82B4, + GL_TEXTURE_VIEW = 0x82B5, + GL_VIEW_COMPATIBILITY_CLASS = 0x82B6; + + /** Returned as possible responses for various {@code pname} queries to GetInternalformativ and GetInternalformati64v. */ + public static final int + GL_FULL_SUPPORT = 0x82B7, + GL_CAVEAT_SUPPORT = 0x82B8, + GL_IMAGE_CLASS_4_X_32 = 0x82B9, + GL_IMAGE_CLASS_2_X_32 = 0x82BA, + GL_IMAGE_CLASS_1_X_32 = 0x82BB, + GL_IMAGE_CLASS_4_X_16 = 0x82BC, + GL_IMAGE_CLASS_2_X_16 = 0x82BD, + GL_IMAGE_CLASS_1_X_16 = 0x82BE, + GL_IMAGE_CLASS_4_X_8 = 0x82BF, + GL_IMAGE_CLASS_2_X_8 = 0x82C0, + GL_IMAGE_CLASS_1_X_8 = 0x82C1, + GL_IMAGE_CLASS_11_11_10 = 0x82C2, + GL_IMAGE_CLASS_10_10_10_2 = 0x82C3, + GL_VIEW_CLASS_128_BITS = 0x82C4, + GL_VIEW_CLASS_96_BITS = 0x82C5, + GL_VIEW_CLASS_64_BITS = 0x82C6, + GL_VIEW_CLASS_48_BITS = 0x82C7, + GL_VIEW_CLASS_32_BITS = 0x82C8, + GL_VIEW_CLASS_24_BITS = 0x82C9, + GL_VIEW_CLASS_16_BITS = 0x82CA, + GL_VIEW_CLASS_8_BITS = 0x82CB, + GL_VIEW_CLASS_S3TC_DXT1_RGB = 0x82CC, + GL_VIEW_CLASS_S3TC_DXT1_RGBA = 0x82CD, + GL_VIEW_CLASS_S3TC_DXT3_RGBA = 0x82CE, + GL_VIEW_CLASS_S3TC_DXT5_RGBA = 0x82CF, + GL_VIEW_CLASS_RGTC1_RED = 0x82D0, + GL_VIEW_CLASS_RGTC2_RG = 0x82D1, + GL_VIEW_CLASS_BPTC_UNORM = 0x82D2, + GL_VIEW_CLASS_BPTC_FLOAT = 0x82D3; + + static { GL.initialize(); } + + protected ARBInternalformatQuery2() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetInternalformati64v + ); + } + + // --- [ glGetInternalformati64v ] --- + + /** + * Unsafe version of: {@link #glGetInternalformati64v GetInternalformati64v} + * + * @param bufSize the maximum number of values that may be written to params by the function + */ + public static void nglGetInternalformati64v(int target, int internalformat, int pname, int bufSize, long params) { + GL43C.nglGetInternalformati64v(target, internalformat, pname, bufSize, params); + } + + /** + * Retrieves information about implementation-dependent support for internal formats. + * + * @param target the usage of the internal format. One of:| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
This extension adds a mechanism for an application to tell the GL that the previous contents of a subregion of an image or a range of a buffer may be + * invalidated.
+ * + *GL implementations often include several memory spaces, each with distinct performance characteristics, and the implementations transparently move + * allocations between memory spaces. With this extension, an application can tell the GL that the contents of a texture or buffer are no longer needed, + * and the implementation can avoid transferring the data unnecessarily.
+ * + *Examples of when this may be useful include:
+ * + *It is expected that the situations in which the GL will take advantage of this knowledge and achieve increased performance as a result of its use will + * be implementation-dependent. The first three examples may show benefit on tiled renderers where some data won't need to be copied into or out of on-chip + * memory. The fourth example may show a benefit in multi-GPU systems where some data won't need to be copied between GPUs.
+ * + *This extension is a superset of the EXT_discard_framebuffer extension with the following additions:
+ * + *Requires {@link GL20 OpenGL 2.0}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public class ARBInvalidateSubdata { + + static { GL.initialize(); } + + protected ARBInvalidateSubdata() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glInvalidateTexSubImage, caps.glInvalidateTexImage, caps.glInvalidateBufferSubData, caps.glInvalidateBufferData, caps.glInvalidateFramebuffer, + caps.glInvalidateSubFramebuffer + ); + } + + // --- [ glInvalidateTexSubImage ] --- + + /** + * Invalidates a region of a texture image. + * + * @param texture the name of a texture object a subregion of which to invalidate + * @param level the level of detail of the texture object within which the region resides + * @param xoffset the X offset of the region to be invalidated + * @param yoffset the Y offset of the region to be invalidated + * @param zoffset the Z offset of the region to be invalidated + * @param width the width of the region to be invalidated + * @param height the height of the region to be invalidated + * @param depth the depth of the region to be invalidated + */ + public static void glInvalidateTexSubImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLint") int zoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth) { + GL43C.glInvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth); + } + + // --- [ glInvalidateTexImage ] --- + + /** + * Invalidates the entirety of a texture image. + * + * @param texture the name of a texture object to invalidate + * @param level the level of detail of the texture object to invalidate + */ + public static void glInvalidateTexImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level) { + GL43C.glInvalidateTexImage(texture, level); + } + + // --- [ glInvalidateBufferSubData ] --- + + /** + * Invalidates a region of a buffer object's data store. + * + * @param buffer the name of a buffer object, a subrange of whose data store to invalidate + * @param offset the offset within the buffer's data store of the start of the range to be invalidated + * @param length the length of the range within the buffer's data store to be invalidated + */ + public static void glInvalidateBufferSubData(@NativeType("GLuint") int buffer, @NativeType("GLintptr") long offset, @NativeType("GLsizeiptr") long length) { + GL43C.glInvalidateBufferSubData(buffer, offset, length); + } + + // --- [ glInvalidateBufferData ] --- + + /** + * Invalidates the content of a buffer object's data store. + * + * @param buffer the name of a buffer object whose data store to invalidate + */ + public static void glInvalidateBufferData(@NativeType("GLuint") int buffer) { + GL43C.glInvalidateBufferData(buffer); + } + + // --- [ glInvalidateFramebuffer ] --- + + /** + * Unsafe version of: {@link #glInvalidateFramebuffer InvalidateFramebuffer} + * + * @param numAttachments the number of entries in the {@code attachments} array + */ + public static void nglInvalidateFramebuffer(int target, int numAttachments, long attachments) { + GL43C.nglInvalidateFramebuffer(target, numAttachments, attachments); + } + + /** + * Invalidate the content some or all of a framebuffer object's attachments. + * + * @param target the target to which the framebuffer is attached. One of:| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} |
This extension adds a requirement to the pointer returned by {@link GL15C#glMapBuffer MapBuffer} and {@link GL30C#glMapBufferRange MapBufferRange} that they provide a minimum of 64 byte alignment + * to support processing of the data directly with special CPU instructions like SSE and AVX.
+ * + *Requires {@link GL21 OpenGL 2.1}. Promoted to core in {@link GL42 OpenGL 4.2}.
+ */ +public final class ARBMapBufferAlignment { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int GL_MIN_MAP_BUFFER_ALIGNMENT = 0x90BC; + + private ARBMapBufferAlignment() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBMapBufferRange.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBMapBufferRange.java new file mode 100644 index 00000000..f0b06d3f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBMapBufferRange.java @@ -0,0 +1,119 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_map_buffer_range extension. + * + *ARB_map_buffer_range expands the buffer object API to allow greater performance when a client application only needs to write to a sub-range of a buffer + * object. To that end, this extension introduces two new buffer object features: non-serialized buffer modification and explicit sub-range flushing for + * mapped buffer objects.
+ * + *OpenGL requires that commands occur in a FIFO manner meaning that any changes to buffer objects either block until the data has been processed by the + * OpenGL pipeline or else create extra copies to avoid such a block. By providing a method to asynchronously modify buffer object data, an application is + * then able to manage the synchronization points themselves and modify ranges of data contained by a buffer object even though OpenGL might still be using + * other parts of it.
+ * + *This extension also provides a method for explicitly flushing ranges of a mapped buffer object so OpenGL does not have to assume that the entire range + * may have been modified. Further, it allows the application to more precisely specify its intent with respect to reading, writing, and whether the + * previous contents of a mapped range of interest need be preserved prior to modification.
+ * + *Requires {@link GL21 OpenGL 2.1}. Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public class ARBMapBufferRange { + + /** Accepted by the {@code access} parameter of MapBufferRange. */ + public static final int + GL_MAP_READ_BIT = 0x1, + GL_MAP_WRITE_BIT = 0x2, + GL_MAP_INVALIDATE_RANGE_BIT = 0x4, + GL_MAP_INVALIDATE_BUFFER_BIT = 0x8, + GL_MAP_FLUSH_EXPLICIT_BIT = 0x10, + GL_MAP_UNSYNCHRONIZED_BIT = 0x20; + + static { GL.initialize(); } + + protected ARBMapBufferRange() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glMapBufferRange, caps.glFlushMappedBufferRange + ); + } + + // --- [ glMapBufferRange ] --- + + /** Unsafe version of: {@link #glMapBufferRange MapBufferRange} */ + public static long nglMapBufferRange(int target, long offset, long length, int access) { + return GL30C.nglMapBufferRange(target, offset, length, access); + } + + /** + * Maps a section of a buffer object's data store. + * + *LWJGL note: This method comes in 2 flavors:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30C#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL30C#GL_MAP_READ_BIT MAP_READ_BIT} | {@link GL30C#GL_MAP_WRITE_BIT MAP_WRITE_BIT} | {@link GL30C#GL_MAP_INVALIDATE_RANGE_BIT MAP_INVALIDATE_RANGE_BIT} | {@link GL30C#GL_MAP_INVALIDATE_BUFFER_BIT MAP_INVALIDATE_BUFFER_BIT} |
| {@link GL30C#GL_MAP_FLUSH_EXPLICIT_BIT MAP_FLUSH_EXPLICIT_BIT} | {@link GL30C#GL_MAP_UNSYNCHRONIZED_BIT MAP_UNSYNCHRONIZED_BIT} |
LWJGL note: This method comes in 2 flavors:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30C#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL30C#GL_MAP_READ_BIT MAP_READ_BIT} | {@link GL30C#GL_MAP_WRITE_BIT MAP_WRITE_BIT} | {@link GL30C#GL_MAP_INVALIDATE_RANGE_BIT MAP_INVALIDATE_RANGE_BIT} | {@link GL30C#GL_MAP_INVALIDATE_BUFFER_BIT MAP_INVALIDATE_BUFFER_BIT} |
| {@link GL30C#GL_MAP_FLUSH_EXPLICIT_BIT MAP_FLUSH_EXPLICIT_BIT} | {@link GL30C#GL_MAP_UNSYNCHRONIZED_BIT MAP_UNSYNCHRONIZED_BIT} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30C#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
This extension extends the abilities of {@link ARBVertexBlend} to include a palette of modelview matrices. The n vertex units use a palette of m modelview + * matrices. (Where n and m are constrained to implementation defined maxima.) Each vertex has a set of n indices into the palette, and a corresponding set + * of n weights. Matrix indices can be changed for each vertex (between {@link GL11#glBegin Begin} and {@link GL11#glEnd End}).
+ * + *When this extension is utilized, the enabled units transform each vertex by the modelview matrices specified by the vertices' respective indices. These + * results are subsequently scaled by the weights of the respective units and then summed to create the eyespace vertex.
+ * + *A similar procedure is followed for normals. Normals, however, are transformed by the inverse transpose of the modelview matrix.
+ */ +public class ARBMatrixPalette { + + /** + * Accepted by the {@code pname} parameters of GetFloatv, GetDoublev, and IsEnabled, by the {@code mode} parameter of MatrixMode, and by the {@code cap} + * parameters of Enable and Disable. + */ + public static final int GL_MATRIX_PALETTE_ARB = 0x8840; + + /** Accepted by the {@code pname} parameters of GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 0x8841, + GL_MAX_PALETTE_MATRICES_ARB = 0x8842, + GL_CURRENT_PALETTE_MATRIX_ARB = 0x8843; + + /** Accepted by the {@code cap} parameters of EnableClientState and DisableClientState and by the {@code pname} parameter of IsEnabled. */ + public static final int GL_MATRIX_INDEX_ARRAY_ARB = 0x8844; + + /** Accepted by the {@code pname} parameter of GetFloatv. */ + public static final int GL_CURRENT_MATRIX_INDEX_ARB = 0x8845; + + /** Accepted by the {@code pname} parameter of GetIntegerv. */ + public static final int + GL_MATRIX_INDEX_ARRAY_SIZE_ARB = 0x8846, + GL_MATRIX_INDEX_ARRAY_TYPE_ARB = 0x8847, + GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = 0x8848; + + /** Accepted by the {@code pname} parameter of GetPointerv. */ + public static final int GL_MATRIX_INDEX_ARRAY_POINTER_ARB = 0x8849; + + static { GL.initialize(); } + + protected ARBMatrixPalette() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glCurrentPaletteMatrixARB, caps.glMatrixIndexuivARB, caps.glMatrixIndexubvARB, caps.glMatrixIndexusvARB, caps.glMatrixIndexPointerARB + ); + } + + // --- [ glCurrentPaletteMatrixARB ] --- + + /** + * Defines which of the palette's matrices is affected by subsequent matrix operations when the current matrix mode is {@link #GL_MATRIX_PALETTE_ARB MATRIX_PALETTE_ARB}, + * + * @param index the current matrix index. Must be a value between 0 and {@link #GL_MAX_PALETTE_MATRICES_ARB MAX_PALETTE_MATRICES_ARB}. + */ + public static native void glCurrentPaletteMatrixARB(@NativeType("GLint") int index); + + // --- [ glMatrixIndexuivARB ] --- + + /** + * Unsafe version of: {@link #glMatrixIndexuivARB MatrixIndexuivARB} + * + * @param size the number of index values to set. Must be a value between 1 and {@link ARBVertexBlend#GL_MAX_VERTEX_UNITS_ARB MAX_VERTEX_UNITS_ARB}. + */ + public static native void nglMatrixIndexuivARB(int size, long indices); + + /** + * Sets the current matrix indices. + * + * @param indices the matrix index values + */ + public static void glMatrixIndexuivARB(@NativeType("GLuint *") IntBuffer indices) { + nglMatrixIndexuivARB(indices.remaining(), memAddress(indices)); + } + + // --- [ glMatrixIndexubvARB ] --- + + /** + * Unsafe version of: {@link #glMatrixIndexubvARB MatrixIndexubvARB} + * + * @param size the number of index values to set. Must be a value between 1 and {@link ARBVertexBlend#GL_MAX_VERTEX_UNITS_ARB MAX_VERTEX_UNITS_ARB}. + */ + public static native void nglMatrixIndexubvARB(int size, long indices); + + /** + * Byte version of {@link #glMatrixIndexuivARB MatrixIndexuivARB}. + * + * @param indices the matrix index values + */ + public static void glMatrixIndexubvARB(@NativeType("GLubyte *") ByteBuffer indices) { + nglMatrixIndexubvARB(indices.remaining(), memAddress(indices)); + } + + // --- [ glMatrixIndexusvARB ] --- + + /** + * Unsafe version of: {@link #glMatrixIndexusvARB MatrixIndexusvARB} + * + * @param size the number of index values to set. Must be a value between 1 and {@link ARBVertexBlend#GL_MAX_VERTEX_UNITS_ARB MAX_VERTEX_UNITS_ARB}. + */ + public static native void nglMatrixIndexusvARB(int size, long indices); + + /** + * Short version of {@link #glMatrixIndexuivARB MatrixIndexuivARB}. + * + * @param indices the matrix index values + */ + public static void glMatrixIndexusvARB(@NativeType("GLushort *") ShortBuffer indices) { + nglMatrixIndexusvARB(indices.remaining(), memAddress(indices)); + } + + // --- [ glMatrixIndexPointerARB ] --- + + /** + * Unsafe version of: {@link #glMatrixIndexPointerARB MatrixIndexPointerARB} + * + * @param type the data type of the values stored in the array. One of:| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
This extension provides a new set of commands allowing applications to bind or unbind a set of objects in a single call, instead of requiring a separate + * call for each bind or unbind operation. Using a single command allows OpenGL implementations to amortize function call, name space lookup, and + * potential locking overhead over multiple bind or unbind operations. The rendering loops of graphics applications frequently switch between different + * states, binding different sets of resources, including texture objects, sampler objects, textures for image loads and stores, uniform buffers, and + * vertex buffers; this extension provides "multi-bind" entry points for all of these object types.
+ * + *Each command in this extension includes a <first> and <count> parameter, specifying a continguous range of binding points to update, as well + * as an array of <count> object names specifying the objects to bind. Unlike single bind commands, multi-bind commands can be used only to bind or + * unbind existing objects. Passing a previously unused object name (generated or not) results in an error and does not create a new object. For binding + * points with associated data (e.g., ranges of a buffer), separate arrays are used to pass the associated data for each binding point. Passing zero values + * in the array of object names removes the object bound to the current bounding point. Additionally, if {@code NULL} is passed as the array of objects, objects + * bound to the entire range of binding points are unbound, as though the caller passed an array of zeroes.
+ * + *Requires {@link GL30 OpenGL 3.0}. Promoted to core in {@link GL44 OpenGL 4.4}.
+ */ +public class ARBMultiBind { + + static { GL.initialize(); } + + protected ARBMultiBind() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBindBuffersBase, caps.glBindBuffersRange, caps.glBindTextures, caps.glBindSamplers, caps.glBindImageTextures, caps.glBindVertexBuffers + ); + } + + // --- [ glBindBuffersBase ] --- + + /** + * Unsafe version of: {@link #glBindBuffersBase BindBuffersBase} + * + * @param count the number of bindings + */ + public static void nglBindBuffersBase(int target, int first, int count, long buffers) { + GL44C.nglBindBuffersBase(target, first, count, buffers); + } + + /** + * Binds {@code count} existing buffer objects to bindings numbered {@code first} through {@code first+count-1} in the array of buffer binding points + * corresponding to {@code target}. If {@code buffers} is not {@code NULL}, it specifies an array of {@code count} values, each of which must be zero or the name + * of an existing buffer object. It is equivalent to: + * + *
+ * for ( i = 0; i < count; i++ ) {
+ * if ( buffers == NULL ) {
+ * glBindBufferBase(target, first + i, 0);
+ * } else {
+ * glBindBufferBase(target, first + i, buffers[i]);
+ * }
+ * }except that the single general buffer binding corresponding to {@code target} is unmodified, and that buffers will not be created if they do not exist.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
+ * for ( i = 0; i < count; i++ ) {
+ * if ( buffers == NULL ) {
+ * glBindBufferRange(target, first + i, 0, 0, 0);
+ * } else {
+ * glBindBufferRange(target, first + i, buffers[i], offsets[i], sizes[i]);
+ * }
+ * }except that the single general buffer binding corresponding to {@code target} is unmodified, and that buffers will not be created if they do not exist.
+ * + *The values specified in {@code buffers}, {@code offsets}, and {@code sizes} will be checked separately for each binding point. When values for a + * specific binding point are invalid, the state for that binding point will be unchanged and an error will be generated. However, state for other binding + * points will still be changed if their corresponding values are valid.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
{@code BindTextures} is equivalent to:
+ * + *
+ * for ( i = 0; i < count; i++ ) {
+ * uint texture;
+ * if ( textures == NULL ) {
+ * texture = 0;
+ * } else {
+ * texture = textures[i];
+ * }
+ * ActiveTexture(TEXTURE0 + first + i);
+ * if ( texture != 0 ) {
+ * enum target; // target of texture object textures[i]
+ * BindTexture(target, textures[i]);
+ * } else {
+ * for ( target in all supported targets ) {
+ * BindTexture(target, 0);
+ * }
+ * }
+ * }except that the active texture selector retains its original value upon completion of the command, and that textures will not be created if they do not + * exist.
+ * + *The values specified in {@code textures} will be checked separately for each texture image unit. When a value for a specific texture image unit is + * invalid, the state for that texture image unit will be unchanged and an error will be generated. However, state for other texture image units will still + * be changed if their corresponding values are valid.
+ * + * @param first the first texture objects + * @param textures an array of zeros or names of existing texture objects + */ + public static void glBindTextures(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") IntBuffer textures) { + GL44C.glBindTextures(first, textures); + } + + // --- [ glBindSamplers ] --- + + /** + * Unsafe version of: {@link #glBindSamplers BindSamplers} + * + * @param count the number of sampler objects + */ + public static void nglBindSamplers(int first, int count, long samplers) { + GL44C.nglBindSamplers(first, count, samplers); + } + + /** + * Binds {@code count} existing sampler objects to texture image units numbered {@code first} through {@code first+count-1}. If {@code samplers} is not + * {@code NULL}, it specifies an array of {@code count} values, each of which must be zero or the name of an existing sampler object. If {@code samplers} is {@code NULL}, + * each affected texture image unit from {@code first} through {@code first+count-1} will be reset to have no bound sampler object. + * + *{@code BindSamplers} is equivalent to:
+ * + *
+ * for ( i = 0; i < count; i++ ) {
+ * if ( samplers == NULL ) {
+ * glBindSampler(first + i, 0);
+ * } else {
+ * glBindSampler(first + i, samplers[i]);
+ * }
+ * }The values specified in {@code samplers} will be checked separately for each texture image unit. When a value for a specific texture image unit is + * invalid, the state for that texture image unit will be unchanged and an error will be generated. However, state for other texture image units will still + * be changed if their corresponding values are valid.
+ * + * @param first the first sampler object + * @param samplers an array of zeros or names of existing sampler objects + */ + public static void glBindSamplers(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") IntBuffer samplers) { + GL44C.glBindSamplers(first, samplers); + } + + // --- [ glBindImageTextures ] --- + + /** + * Unsafe version of: {@link #glBindImageTextures BindImageTextures} + * + * @param count the number of image units + */ + public static void nglBindImageTextures(int first, int count, long textures) { + GL44C.nglBindImageTextures(first, count, textures); + } + + /** + * Binds {@code count} existing texture objects to image units numbered {@code first} through {@code first+count-1}. If {@code textures} is not {@code NULL}, it + * specifies an array of {@code count} values, each of which must be zero or the name of an existing texture object. If {@code textures} is {@code NULL}, each + * affected image unit from {@code first} through {@code first+count-1} will be reset to have no bound texture object. + * + *When binding a non-zero texture object to an image unit, the image unit {@code level}, {@code layered}, {@code layer}, and {@code access} parameters are + * set to zero, {@link GL11#GL_TRUE TRUE}, zero, and {@link GL15#GL_READ_WRITE READ_WRITE}, respectively. The image unit {@code format} parameter is taken from the internal + * format of the texture image at level zero of the texture object identified by {@code textures}. For cube map textures, the internal format of the + * {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} image of level zero is used. For multisample, multisample array, buffer, and rectangle textures, the internal + * format of the single texture level is used.
+ * + *When unbinding a texture object from an image unit, the image unit parameters {@code level}, {@code layered}, {@code layer}, and {@code format} will be + * reset to their default values of zero, {@link GL11#GL_FALSE FALSE}, 0, and {@link GL30#GL_R8 R8}, respectively.
+ * + *{@code BindImageTextures} is equivalent to:
+ * + *
+ * for ( i = 0; i < count; i++ ) {
+ * if ( textures == NULL || textures[i] = 0 ) {
+ * glBindImageTexture(first + i, 0, 0, FALSE, 0, READ_ONLY, R8);
+ * } else {
+ * glBindImageTexture(first + i, textures[i], 0, TRUE, 0, READ_WRITE, lookupInternalFormat(textures[i]));
+ * }
+ * }where {@code lookupInternalFormat} returns the internal format of the specified texture object.
+ * + *The values specified in {@code textures} will be checked separately for each image unit. When a value for a specific image unit is invalid, the state + * for that image unit will be unchanged and an error will be generated. However, state for other image units will still be changed if their corresponding + * values are valid.
+ * + * @param first the first image unit + * @param textures an array of zeros or names of existing texture objects + */ + public static void glBindImageTextures(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") IntBuffer textures) { + GL44C.glBindImageTextures(first, textures); + } + + // --- [ glBindVertexBuffers ] --- + + /** + * Unsafe version of: {@link #glBindVertexBuffers BindVertexBuffers} + * + * @param count the number of vertex buffer binding points + */ + public static void nglBindVertexBuffers(int first, int count, long buffers, long offsets, long strides) { + GL44C.nglBindVertexBuffers(first, count, buffers, offsets, strides); + } + + /** + * Binds {@code count} existing buffer objects to vertex buffer binding points numbered {@code first} through {@code first+count-1}. If {@code buffers} is + * not {@code NULL}, it specifies an array of {@code count} values, each of which must be zero or the name of an existing buffer object. {@code offsets} and + * {@code strides} specify arrays of {@code count} values indicating the offset of the first element and stride between elements in each buffer, + * respectively. If {@code buffers} is {@code NULL}, each affected vertex buffer binding point from {@code first} through {@code first+count-1} will be reset to + * have no bound buffer object. In this case, the offsets and strides associated with the binding points are set to default values, ignoring + * {@code offsets} and {@code strides}. + * + *{@code BindVertexBuffers} is equivalent to:
+ * + *
+ * for ( i = 0; i < count; i++ ) {
+ * if ( buffers == NULL ) {
+ * glBindVertexBuffer(first + i, 0, 0, 16);
+ * } else {
+ * glBindVertexBuffer(first + i, buffers[i], offsets[i], strides[i]);
+ * }
+ * }except that buffers will not be created if they do not exist.
+ * + *The values specified in {@code buffers}, {@code offsets}, and {@code strides} will be checked separately for each vertex buffer binding point. When a + * value for a specific binding point is invalid, the state for that binding point will be unchanged and an error will be generated. However, state for + * other binding points will still be changed if their corresponding values are valid.
+ * + * @param first the first vertex buffer binding point + * @param buffers an array of zeros or names of existing buffers objects + * @param offsets an array of offses + * @param strides an array of stride values + */ + public static void glBindVertexBuffers(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") IntBuffer buffers, @Nullable @NativeType("GLintptr const *") PointerBuffer offsets, @Nullable @NativeType("GLsizei const *") IntBuffer strides) { + GL44C.glBindVertexBuffers(first, buffers, offsets, strides); + } + + /** Array version of: {@link #glBindBuffersBase BindBuffersBase} */ + public static void glBindBuffersBase(@NativeType("GLenum") int target, @NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] buffers) { + GL44C.glBindBuffersBase(target, first, buffers); + } + + /** Array version of: {@link #glBindBuffersRange BindBuffersRange} */ + public static void glBindBuffersRange(@NativeType("GLenum") int target, @NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] buffers, @Nullable @NativeType("GLintptr const *") PointerBuffer offsets, @Nullable @NativeType("GLsizeiptr const *") PointerBuffer sizes) { + GL44C.glBindBuffersRange(target, first, buffers, offsets, sizes); + } + + /** Array version of: {@link #glBindTextures BindTextures} */ + public static void glBindTextures(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] textures) { + GL44C.glBindTextures(first, textures); + } + + /** Array version of: {@link #glBindSamplers BindSamplers} */ + public static void glBindSamplers(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] samplers) { + GL44C.glBindSamplers(first, samplers); + } + + /** Array version of: {@link #glBindImageTextures BindImageTextures} */ + public static void glBindImageTextures(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] textures) { + GL44C.glBindImageTextures(first, textures); + } + + /** Array version of: {@link #glBindVertexBuffers BindVertexBuffers} */ + public static void glBindVertexBuffers(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] buffers, @Nullable @NativeType("GLintptr const *") PointerBuffer offsets, @Nullable @NativeType("GLsizei const *") int[] strides) { + GL44C.glBindVertexBuffers(first, buffers, offsets, strides); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBMultiDrawIndirect.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBMultiDrawIndirect.java new file mode 100644 index 00000000..295ad599 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBMultiDrawIndirect.java @@ -0,0 +1,275 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_multi_draw_indirect extension. + * + *The {@link ARBDrawIndirect ARB_draw_indirect} extension (included in OpenGL 4.0) introduced mechanisms whereby the parameters for a draw function may be provided in a + * structure contained in a buffer object rather than as parameters to the drawing procedure. This is known as an indirect draw and is exposed as two new + * functions, {@link ARBDrawIndirect#glDrawArraysIndirect DrawArraysIndirect} and {@link ARBDrawIndirect#glDrawElementsIndirect DrawElementsIndirect}. Each of these functions generates a single batch of + * primitives.
+ * + *This extension builds on this functionality by providing procedures to invoke multiple draws from a single procedure call. This allows large batches of + * drawing commands to be assembled in server memory (via a buffer object) which may then be dispatched through a single function call.
+ * + *Requires {@link GL40 OpenGL 4.0} or {@link ARBDrawIndirect ARB_draw_indirect}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public class ARBMultiDrawIndirect { + + static { GL.initialize(); } + + protected ARBMultiDrawIndirect() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glMultiDrawArraysIndirect, caps.glMultiDrawElementsIndirect + ); + } + + // --- [ glMultiDrawArraysIndirect ] --- + + /** Unsafe version of: {@link #glMultiDrawArraysIndirect MultiDrawArraysIndirect} */ + public static void nglMultiDrawArraysIndirect(int mode, long indirect, int drawcount, int stride) { + GL43C.nglMultiDrawArraysIndirect(mode, indirect, drawcount, stride); + } + + /** + * Renders multiple sets of primitives from array data, taking parameters from memory. + * + *The parameters addressed by {@code indirect} are packed into an array of structures, each element of which takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance;
+ * } DrawArraysIndirectCommand;A single call to {@code glMultiDrawArraysIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawArraysIndirect(mode, (DrawArraysIndirectCommand*)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawArraysIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
The parameters addressed by {@code indirect} are packed into an array of structures, each element of which takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance;
+ * } DrawArraysIndirectCommand;A single call to {@code glMultiDrawArraysIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawArraysIndirect(mode, (DrawArraysIndirectCommand*)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawArraysIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
The parameters addressed by {@code indirect} are packed into an array of structures, each element of which takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance;
+ * } DrawArraysIndirectCommand;A single call to {@code glMultiDrawArraysIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawArraysIndirect(mode, (DrawArraysIndirectCommand*)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawArraysIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
The parameters addressed by indirect are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;A single call to {@code glMultiDrawElementsIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawElementsIndirect(mode, type, (DrawElementsIndirectCommand *)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawElementsIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
The parameters addressed by indirect are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;A single call to {@code glMultiDrawElementsIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawElementsIndirect(mode, type, (DrawElementsIndirectCommand *)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawElementsIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
The parameters addressed by indirect are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;A single call to {@code glMultiDrawElementsIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawElementsIndirect(mode, type, (DrawElementsIndirectCommand *)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawElementsIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
This extension provides a mechanism to antialias all GL primitives: points, lines, polygons, bitmaps, and images. The technique is to sample all + * primitives multiple times at each pixel. The color sample values are resolved to a single, displayable color each time a pixel is updated, so the + * antialiasing appears to be automatic at the application level. Because each sample includes depth and stencil information, the depth and stencil + * functions perform equivalently to the single-sample mode.
+ * + *An additional buffer, called the multisample buffer, is added to the framebuffer. Pixel sample values, including color, depth, and stencil values, are + * stored in this buffer. When the framebuffer includes a multisample buffer, it does not also include separate depth or stencil buffers, even if the + * multisample buffer does not store depth or stencil values. Color buffers (left/right, front/back, and aux) do coexist with the multisample buffer, + * however.
+ * + *Multisample antialiasing is most valuable for rendering polygons, because it requires no sorting for hidden surface elimination, and it correctly + * handles adjacent polygons, object silhouettes, and even intersecting polygons. If only points or lines are being rendered, the "smooth" antialiasing + * mechanism provided by the base GL may result in a higher quality image. This extension is designed to allow multisample and smooth antialiasing + * techniques to be alternated during the rendering of a single scene.
+ */ +public class ARBMultisample { + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int + GL_MULTISAMPLE_ARB = 0x809D, + GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = 0x809E, + GL_SAMPLE_ALPHA_TO_ONE_ARB = 0x809F, + GL_SAMPLE_COVERAGE_ARB = 0x80A0; + + /** Accepted by the {@code mask} parameter of PushAttrib. */ + public static final int GL_MULTISAMPLE_BIT_ARB = 0x20000000; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int + GL_SAMPLE_BUFFERS_ARB = 0x80A8, + GL_SAMPLES_ARB = 0x80A9, + GL_SAMPLE_COVERAGE_VALUE_ARB = 0x80AA, + GL_SAMPLE_COVERAGE_INVERT_ARB = 0x80AB; + + static { GL.initialize(); } + + protected ARBMultisample() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glSampleCoverageARB + ); + } + + // --- [ glSampleCoverageARB ] --- + + /** + * Specifies simultaneously the values of {@link #GL_SAMPLE_COVERAGE_VALUE_ARB SAMPLE_COVERAGE_VALUE_ARB} and {@link #GL_SAMPLE_COVERAGE_INVERT_ARB SAMPLE_COVERAGE_INVERT_ARB}. + * + *If {@link #GL_SAMPLE_COVERAGE_ARB SAMPLE_COVERAGE_ARB} is enabled, the fragment coverage is ANDed with another temporary coverage. This temporary coverage is a function of the value + * of {@link #GL_SAMPLE_COVERAGE_VALUE_ARB SAMPLE_COVERAGE_VALUE_ARB}. If {@link #GL_SAMPLE_COVERAGE_INVERT_ARB SAMPLE_COVERAGE_INVERT_ARB} is {@link GL11#GL_TRUE TRUE}, the temporary coverage is inverted (all bit values are inverted) before it + * is ANDed with the fragment coverage.
+ * + * @param value the desired coverage value + * @param invert if true, the temporary coverage is inverted. One of:| {@link GL11#GL_TRUE TRUE} | {@link GL11#GL_FALSE FALSE} |
This extension allows application of multiple textures to a fragment in one rendering pass.
+ * + *Promoted to core in {@link GL13 OpenGL 1.3}.
+ */ +public class ARBMultitexture { + + /** Accepted by the {@code texture} parameter of ActiveTexture and MultiTexCoord. */ + public static final int + GL_TEXTURE0_ARB = 0x84C0, + GL_TEXTURE1_ARB = 0x84C1, + GL_TEXTURE2_ARB = 0x84C2, + GL_TEXTURE3_ARB = 0x84C3, + GL_TEXTURE4_ARB = 0x84C4, + GL_TEXTURE5_ARB = 0x84C5, + GL_TEXTURE6_ARB = 0x84C6, + GL_TEXTURE7_ARB = 0x84C7, + GL_TEXTURE8_ARB = 0x84C8, + GL_TEXTURE9_ARB = 0x84C9, + GL_TEXTURE10_ARB = 0x84CA, + GL_TEXTURE11_ARB = 0x84CB, + GL_TEXTURE12_ARB = 0x84CC, + GL_TEXTURE13_ARB = 0x84CD, + GL_TEXTURE14_ARB = 0x84CE, + GL_TEXTURE15_ARB = 0x84CF, + GL_TEXTURE16_ARB = 0x84D0, + GL_TEXTURE17_ARB = 0x84D1, + GL_TEXTURE18_ARB = 0x84D2, + GL_TEXTURE19_ARB = 0x84D3, + GL_TEXTURE20_ARB = 0x84D4, + GL_TEXTURE21_ARB = 0x84D5, + GL_TEXTURE22_ARB = 0x84D6, + GL_TEXTURE23_ARB = 0x84D7, + GL_TEXTURE24_ARB = 0x84D8, + GL_TEXTURE25_ARB = 0x84D9, + GL_TEXTURE26_ARB = 0x84DA, + GL_TEXTURE27_ARB = 0x84DB, + GL_TEXTURE28_ARB = 0x84DC, + GL_TEXTURE29_ARB = 0x84DD, + GL_TEXTURE30_ARB = 0x84DE, + GL_TEXTURE31_ARB = 0x84DF; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int + GL_ACTIVE_TEXTURE_ARB = 0x84E0, + GL_CLIENT_ACTIVE_TEXTURE_ARB = 0x84E1, + GL_MAX_TEXTURE_UNITS_ARB = 0x84E2; + + static { GL.initialize(); } + + protected ARBMultitexture() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glActiveTextureARB, caps.glClientActiveTextureARB, caps.glMultiTexCoord1fARB, caps.glMultiTexCoord1sARB, caps.glMultiTexCoord1iARB, + caps.glMultiTexCoord1dARB, caps.glMultiTexCoord1fvARB, caps.glMultiTexCoord1svARB, caps.glMultiTexCoord1ivARB, caps.glMultiTexCoord1dvARB, + caps.glMultiTexCoord2fARB, caps.glMultiTexCoord2sARB, caps.glMultiTexCoord2iARB, caps.glMultiTexCoord2dARB, caps.glMultiTexCoord2fvARB, + caps.glMultiTexCoord2svARB, caps.glMultiTexCoord2ivARB, caps.glMultiTexCoord2dvARB, caps.glMultiTexCoord3fARB, caps.glMultiTexCoord3sARB, + caps.glMultiTexCoord3iARB, caps.glMultiTexCoord3dARB, caps.glMultiTexCoord3fvARB, caps.glMultiTexCoord3svARB, caps.glMultiTexCoord3ivARB, + caps.glMultiTexCoord3dvARB, caps.glMultiTexCoord4fARB, caps.glMultiTexCoord4sARB, caps.glMultiTexCoord4iARB, caps.glMultiTexCoord4dARB, + caps.glMultiTexCoord4fvARB, caps.glMultiTexCoord4svARB, caps.glMultiTexCoord4ivARB, caps.glMultiTexCoord4dvARB + ); + } + + // --- [ glActiveTextureARB ] --- + + /** + * Selects which texture unit subsequent texture state calls will affect. The number of texture units an implementation supports is implementation + * dependent. + * + * @param texture which texture unit to make active. One of:| {@link #GL_TEXTURE0_ARB TEXTURE0_ARB} | GL_TEXTURE[1-31] |
| {@link #GL_TEXTURE0_ARB TEXTURE0_ARB} | GL_TEXTURE[1-31] |
This extension defines a mechanism whereby an application can query the number of pixels (or, more precisely, samples) drawn by a primitive or group of + * primitives.
+ * + *The primary purpose of such a query (hereafter referred to as an "occlusion query") is to determine the visibility of an object. Typically, the + * application will render the major occluders in the scene, then perform an occlusion query for the bounding box of each detail object in the scene. Only + * if said bounding box is visible, i.e., if at least one sample is drawn, should the corresponding object be drawn.
+ * + *The earlier HP_occlusion_test extension defined a similar mechanism, but it had two major shortcomings.
+ * + *This extension solves both of those problems. It returns as its result the number of samples that pass the depth and stencil tests, and it encapsulates + * occlusion queries in "query objects" that allow applications to issue many queries before asking for the result of any one. As a result, they can + * overlap the time it takes for the occlusion query results to be returned with other, more useful work, such as rendering other parts of the scene or + * performing other computations on the CPU.
+ * + *There are many situations where a pixel/sample count, rather than a boolean result, is useful.
+ * + *Promoted to core in {@link GL15 OpenGL 1.5}.
+ */ +public class ARBOcclusionQuery { + + /** Accepted by the {@code target} parameter of BeginQueryARB, EndQueryARB, and GetQueryivARB. */ + public static final int GL_SAMPLES_PASSED_ARB = 0x8914; + + /** Accepted by the {@code pname} parameter of GetQueryivARB. */ + public static final int + GL_QUERY_COUNTER_BITS_ARB = 0x8864, + GL_CURRENT_QUERY_ARB = 0x8865; + + /** Accepted by the {@code pname} parameter of GetQueryObjectivARB and GetQueryObjectuivARB. */ + public static final int + GL_QUERY_RESULT_ARB = 0x8866, + GL_QUERY_RESULT_AVAILABLE_ARB = 0x8867; + + static { GL.initialize(); } + + protected ARBOcclusionQuery() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGenQueriesARB, caps.glDeleteQueriesARB, caps.glIsQueryARB, caps.glBeginQueryARB, caps.glEndQueryARB, caps.glGetQueryivARB, + caps.glGetQueryObjectivARB, caps.glGetQueryObjectuivARB + ); + } + + // --- [ glGenQueriesARB ] --- + + /** + * Unsafe version of: {@link #glGenQueriesARB GenQueriesARB} + * + * @param n the number of query object names to be generated + */ + public static native void nglGenQueriesARB(int n, long ids); + + /** + * Generates query object names. + * + * @param ids a buffer in which the generated query object names are stored + */ + public static void glGenQueriesARB(@NativeType("GLuint *") IntBuffer ids) { + nglGenQueriesARB(ids.remaining(), memAddress(ids)); + } + + /** Generates query object names. */ + @NativeType("void") + public static int glGenQueriesARB() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer ids = stack.callocInt(1); + nglGenQueriesARB(1, memAddress(ids)); + return ids.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glDeleteQueriesARB ] --- + + /** + * Unsafe version of: {@link #glDeleteQueriesARB DeleteQueriesARB} + * + * @param n the number of query objects to be deleted + */ + public static native void nglDeleteQueriesARB(int n, long ids); + + /** + * Deletes named query objects. + * + * @param ids an array of query objects to be deleted + */ + public static void glDeleteQueriesARB(@NativeType("GLuint const *") IntBuffer ids) { + nglDeleteQueriesARB(ids.remaining(), memAddress(ids)); + } + + /** Deletes named query objects. */ + public static void glDeleteQueriesARB(@NativeType("GLuint const *") int id) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer ids = stack.ints(id); + nglDeleteQueriesARB(1, memAddress(ids)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glIsQueryARB ] --- + + /** + * Determine if a name corresponds to a query object. + * + * @param id a value that may be the name of a query object + */ + @NativeType("GLboolean") + public static native boolean glIsQueryARB(@NativeType("GLuint") int id); + + // --- [ glBeginQueryARB ] --- + + /** + * Creates a query object and makes it active. + * + * @param target the target type of query object established. One of:| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link #GL_QUERY_COUNTER_BITS_ARB QUERY_COUNTER_BITS_ARB} | {@link #GL_CURRENT_QUERY_ARB CURRENT_QUERY_ARB} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link #GL_QUERY_COUNTER_BITS_ARB QUERY_COUNTER_BITS_ARB} | {@link #GL_CURRENT_QUERY_ARB CURRENT_QUERY_ARB} |
| {@link #GL_QUERY_RESULT_ARB QUERY_RESULT_ARB} | {@link #GL_QUERY_RESULT_AVAILABLE_ARB QUERY_RESULT_AVAILABLE_ARB} |
| {@link #GL_QUERY_RESULT_ARB QUERY_RESULT_ARB} | {@link #GL_QUERY_RESULT_AVAILABLE_ARB QUERY_RESULT_AVAILABLE_ARB} |
| {@link #GL_QUERY_RESULT_ARB QUERY_RESULT_ARB} | {@link #GL_QUERY_RESULT_AVAILABLE_ARB QUERY_RESULT_AVAILABLE_ARB} |
| {@link #GL_QUERY_RESULT_ARB QUERY_RESULT_ARB} | {@link #GL_QUERY_RESULT_AVAILABLE_ARB QUERY_RESULT_AVAILABLE_ARB} |
This extension trivially adds a boolean occlusion query to {@link ARBOcclusionQuery ARB_occlusion_query}.
+ * + *While the counter-based occlusion query provided by ARB_occlusion_query is flexible, there is still value to a simple boolean, which is often sufficient + * for applications.
+ * + *Promoted to core in {@link GL33 OpenGL 3.3}.
+ */ +public final class ARBOcclusionQuery2 { + + /** Accepted by the {@code target} parameter of BeginQuery, EndQuery, and GetQueryiv. */ + public static final int GL_ANY_SAMPLES_PASSED = 0x8C2F; + + private ARBOcclusionQuery2() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBParallelShaderCompile.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBParallelShaderCompile.java new file mode 100644 index 00000000..0f275e21 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBParallelShaderCompile.java @@ -0,0 +1,57 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_parallel_shader_compile extension. + * + *Compiling GLSL into implementation-specific code can be a time consuming process, so a GL implementation may wish to perform the compilation in a + * separate CPU thread. This extension provides a mechanism for the application to provide a hint to limit the number of threads it wants to be used to + * compile shaders, as well as a query to determine if the compilation process is complete.
+ * + *Requires {@link GL30 OpenGL 3.0}.
+ */ +public class ARBParallelShaderCompile { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int GL_MAX_SHADER_COMPILER_THREADS_ARB = 0x91B0; + + /** Accepted as part of the {@code pname} parameter to GetShaderiv() and accepted as part of the {@code pname} parameter to GetProgramiv(). */ + public static final int GL_COMPLETION_STATUS_ARB = 0x91B1; + + static { GL.initialize(); } + + protected ARBParallelShaderCompile() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glMaxShaderCompilerThreadsARB + ); + } + + // --- [ glMaxShaderCompilerThreadsARB ] --- + + /** + * Application may use the following to hint to the driver the maximum number background threads it would like to be used in the process of compiling + * shaders or linking programs. + * + *An implementation may combine the maximum compiler thread request from multiple contexts in a share group in an implementation-specific way.
+ * + *An application can query the current MaxShaderCompilerThreads() {@code count} by calling {@link GL11C#glGetIntegerv GetIntegerv} with {@code pname} set to + * {@link #GL_MAX_SHADER_COMPILER_THREADS_ARB MAX_SHADER_COMPILER_THREADS_ARB}.
+ * + * @param count the number of background threads. A {@code count} of zero specifies a request for no parallel compiling or linking and a {@code count} of + * {@code 0xFFFFFFFF} requests an implementation-specific maximum. + */ + public static native void glMaxShaderCompilerThreadsARB(@NativeType("GLuint") int count); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBPipelineStatisticsQuery.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBPipelineStatisticsQuery.java new file mode 100644 index 00000000..cdf84b26 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBPipelineStatisticsQuery.java @@ -0,0 +1,45 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_pipeline_statistics_query extension. + * + *This extension introduces new query types that allow applications to get statistics information about different parts of the pipeline:
+ * + *Requires {@link GL30 OpenGL 3.0}.
+ */ +public final class ARBPipelineStatisticsQuery { + + /** + * Accepted by the {@code target} parameter of {@link GL15C#glBeginQuery BeginQuery}, {@link GL15C#glEndQuery EndQuery}, {@link GL15C#glGetQueryiv GetQueryiv}, + * {@link GL40C#glBeginQueryIndexed BeginQueryIndexed}, {@link GL40C#glEndQueryIndexed EndQueryIndexed} and {@link GL40C#glGetQueryIndexediv GetQueryIndexediv}. + */ + public static final int + GL_VERTICES_SUBMITTED_ARB = 0x82EE, + GL_PRIMITIVES_SUBMITTED_ARB = 0x82EF, + GL_VERTEX_SHADER_INVOCATIONS_ARB = 0x82F0, + GL_TESS_CONTROL_SHADER_PATCHES_ARB = 0x82F1, + GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB = 0x82F2, + GL_GEOMETRY_SHADER_INVOCATIONS = 0x887F, + GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB = 0x82F3, + GL_FRAGMENT_SHADER_INVOCATIONS_ARB = 0x82F4, + GL_COMPUTE_SHADER_INVOCATIONS_ARB = 0x82F5, + GL_CLIPPING_INPUT_PRIMITIVES_ARB = 0x82F6, + GL_CLIPPING_OUTPUT_PRIMITIVES_ARB = 0x82F7; + + private ARBPipelineStatisticsQuery() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBPixelBufferObject.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBPixelBufferObject.java new file mode 100644 index 00000000..e16e03e9 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBPixelBufferObject.java @@ -0,0 +1,65 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_pixel_buffer_object extension. + * + *This extension expands on the interface provided by the {@link ARBVertexBufferObject ARB_vertex_buffer_object} extension (and later integrated into {@link GL15 OpenGL 1.5}) in order to + * permit buffer objects to be used not only with vertex array data, but also with pixel data. The intent is to provide more acceleration opportunities + * for OpenGL pixel commands.
+ * + *While a single buffer object can be bound for both vertex arrays and pixel commands, we use the designations vertex buffer object (VBO) and pixel buffer + * object (PBO) to indicate their particular usage in a given situation.
+ * + *Recall that buffer objects conceptually are nothing more than arrays of bytes, just like any chunk of memory. {@link ARBVertexBufferObject ARB_vertex_buffer_object} allows GL + * commands to source data from a buffer object by binding the buffer object to a given target and then overloading a certain set of GL commands' pointer + * arguments to refer to offsets inside the buffer, rather than pointers to user memory. An offset is encoded in a pointer by adding the offset to a null + * pointer.
+ * + *This extension does not add any new functionality to buffer objects themselves. It simply adds two new targets to which buffer objects can be bound: + * {@link #GL_PIXEL_PACK_BUFFER_ARB PIXEL_PACK_BUFFER_ARB} and {@link #GL_PIXEL_UNPACK_BUFFER_ARB PIXEL_UNPACK_BUFFER_ARB}. When a buffer object is bound to the {@link #GL_PIXEL_PACK_BUFFER_ARB PIXEL_PACK_BUFFER_ARB} target, commands such as + * {@link GL11C#glReadPixels ReadPixels} pack (write) their data into a buffer object. When a buffer object is bound to the {@link #GL_PIXEL_UNPACK_BUFFER_ARB PIXEL_UNPACK_BUFFER_ARB} target, commands such as + * {@link GL11#glDrawPixels DrawPixels} and {@link GL11C#glTexImage2D TexImage2D} unpack (read) their data from a buffer object.
+ * + *There are a several approaches to improve graphics performance with PBOs. Some of the most interesting approaches are:
+ * + *Requires {@link GL15 OpenGL 1.5} or {@link ARBVertexBufferObject ARB_vertex_buffer_object}. Promoted to core in {@link GL21 OpenGL 2.1}.
+ */ +public final class ARBPixelBufferObject { + + /** + * Accepted by the {@code target} parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, GetBufferParameteriv, and + * GetBufferPointerv. + */ + public static final int + GL_PIXEL_PACK_BUFFER_ARB = 0x88EB, + GL_PIXEL_UNPACK_BUFFER_ARB = 0x88EC; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ED, + GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88EF; + + private ARBPixelBufferObject() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBPointParameters.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBPointParameters.java new file mode 100644 index 00000000..19004588 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBPointParameters.java @@ -0,0 +1,94 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the ARB_point_parameters extension. + * + *This extension supports additional geometric characteristics of points. It can be used to render particles or tiny light sources, commonly referred to + * as "Light points".
+ * + *The raster brightness of a point is a function of the point area, point color, point transparency, and the response of the display's electron gun and + * phosphor. The point area and the point transparency are derived from the point size, currently provided with the {@code size} parameter of + * {@link GL11C#glPointSize PointSize}.
+ * + *The primary motivation is to allow the size of a point to be affected by distance attenuation. When distance attenuation has an effect, the final point + * size decreases as the distance of the point from the eye increases.
+ * + *The secondary motivation is a mean to control the mapping from the point size to the raster point area and point transparency. This is done in order to + * increase the dynamic range of the raster brightness of points. In other words, the alpha component of a point may be decreased (and its transparency + * increased) as its area shrinks below a defined threshold.
+ * + *Promoted to core in {@link GL14 OpenGL 1.4}.
+ */ +public class ARBPointParameters { + + /** Accepted by the {@code pname} parameter of PointParameterfvARB, and the {@code pname} of Get. */ + public static final int + GL_POINT_SIZE_MIN_ARB = 0x8126, + GL_POINT_SIZE_MAX_ARB = 0x8127, + GL_POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128, + GL_POINT_DISTANCE_ATTENUATION_ARB = 0x8129; + + static { GL.initialize(); } + + protected ARBPointParameters() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glPointParameterfARB, caps.glPointParameterfvARB + ); + } + + // --- [ glPointParameterfARB ] --- + + /** + * Sets the float value of a pointer parameter. + * + * @param pname the parameter to set. One of:| {@link #GL_POINT_SIZE_MIN_ARB POINT_SIZE_MIN_ARB} | {@link #GL_POINT_SIZE_MAX_ARB POINT_SIZE_MAX_ARB} | {@link #GL_POINT_FADE_THRESHOLD_SIZE_ARB POINT_FADE_THRESHOLD_SIZE_ARB} |
| {@link #GL_POINT_DISTANCE_ATTENUATION_ARB POINT_DISTANCE_ATTENUATION_ARB} |
Applications such as particle systems have tended to use OpenGL quads rather than points to render their geometry, since they would like to use a + * custom-drawn texture for each particle, rather than the traditional OpenGL round antialiased points, and each fragment in a point has the same texture + * coordinates as every other fragment.
+ * + *Unfortunately, specifying the geometry for these quads can be expensive, since it quadruples the amount of geometry required, and may also require the + * application to do extra processing to compute the location of each vertex.
+ * + *The purpose of this extension is to allow such applications to use points rather than quads. When {@link #GL_POINT_SPRITE_ARB POINT_SPRITE_ARB} is enabled, the state of point + * antialiasing is ignored. For each texture unit, the app can then specify whether to replace the existing texture coordinates with point sprite texture + * coordinates, which are interpolated across the point.
+ * + *Promoted to core in {@link GL20 OpenGL 2.0}.
+ */ +public final class ARBPointSprite { + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev, and by the {@code target} parameter of TexEnvi, TexEnviv, TexEnvf, TexEnvfv, GetTexEnviv, and GetTexEnvfv. + */ + public static final int GL_POINT_SPRITE_ARB = 0x8861; + + /** + * When the {@code target} parameter of TexEnvf, TexEnvfv, TexEnvi, TexEnviv, GetTexEnvfv, or GetTexEnviv is POINT_SPRITE_ARB, then the value of + * {@code pname} may be. + */ + public static final int GL_COORD_REPLACE_ARB = 0x8862; + + private ARBPointSprite() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBPolygonOffsetClamp.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBPolygonOffsetClamp.java new file mode 100644 index 00000000..94bbe7f5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBPolygonOffsetClamp.java @@ -0,0 +1,60 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_polygon_offset_clamp extension. + * + *This extension adds a new parameter to the polygon offset function that clamps the calculated offset to a minimum or maximum value. The clamping + * functionality is useful when polygons are nearly parallel to the view direction because their high slopes can result in arbitrarily large polygon + * offsets. In the particular case of shadow mapping, the lack of clamping can produce the appearance of unwanted holes when the shadow casting polygons + * are offset beyond the shadow receiving polygons, and this problem can be alleviated by enforcing a maximum offset value.
+ * + *Requires {@link GL33 OpenGL 3.3}.
+ */ +public class ARBPolygonOffsetClamp { + + /** Accepted by the {@code pname} parameters of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int GL_POLYGON_OFFSET_CLAMP = 0x8E1B; + + static { GL.initialize(); } + + protected ARBPolygonOffsetClamp() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glPolygonOffsetClamp + ); + } + + // --- [ glPolygonOffsetClamp ] --- + + /** + * The depth values of all fragments generated by the rasterization of a polygon may be offset by a single value that is computed for that polygon. This + * function determines this value. + * + *{@code factor} scales the maximum depth slope of the polygon, and {@code units} scales an implementation-dependent constant that relates to the usable + * resolution of the depth buffer. The resulting values are summed to produce the polygon offset value, which may then be clamped to a minimum or maximum + * value specified by {@code clamp}.
+ * + *The values {@code factor}, {@code units}, and {@code clamp} may each be positive, negative, or zero. Calling the command {@link GL11C#glPolygonOffset PolygonOffset} is equivalent + * to calling the command {@code PolygonOffsetClamp} with clamp equal to zero.
+ * + * @param factor scales the maximum depth slope of the polygon + * @param units scales an implementation-dependent constant that relates to the usable resolution of the depth buffer + * @param clamp the minimum or maximum polygon offset value + */ + public static void glPolygonOffsetClamp(@NativeType("GLfloat") float factor, @NativeType("GLfloat") float units, @NativeType("GLfloat") float clamp) { + GL46C.glPolygonOffsetClamp(factor, units, clamp); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBProgramInterfaceQuery.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBProgramInterfaceQuery.java new file mode 100644 index 00000000..f8b2d918 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBProgramInterfaceQuery.java @@ -0,0 +1,328 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_program_interface_query extension. + * + *This extension provides a single unified set of query commands that can be used by applications to determine properties of various interfaces and + * resources used by program objects to communicate with application code, fixed-function OpenGL pipeline stages, and other programs. In unextended OpenGL + * 4.2, there is a separate set of query commands for each different type of interface or resource used by the program. These different sets of queries are + * structured nearly identically, but the queries for some interfaces have limited capability (e.g., there is no ability to enumerate fragment shader + * outputs).
+ * + *With the single set of query commands provided by this extension, a consistent set of queries is available for all interfaces, and a new interface can + * be added without having to introduce a completely new set of query commands. These queries are intended to provide a superset of the capabilities + * provided by similar queries in OpenGL 4.2, and should allow for the deprecation of the existing queries.
+ * + *This extension defines two terms: interfaces and active resources. Each interface of a program object provides a way for the program to communicate with + * application code, fixed-function OpenGL pipeline stages, and other programs. Examples of interfaces for a program object include inputs (receiving + * values from vertex attributes or outputs of other programs), outputs (sending values to other programs or per-fragment operations), uniforms (receiving + * values from API calls), uniform blocks (receiving values from bound buffer objects), subroutines and subroutine uniforms (receiving API calls to + * indicate functions to call during program execution), and atomic counter buffers (holding values to be manipulated by atomic counter shader functions). + * Each interface of a program has a set of active resources used by the program. For example, the resources of a program's input interface includes all + * active input variables used by the first stage of the program. The resources of a program's uniform block interface consists of the set of uniform + * blocks with at least one member used by any shader in the program.
+ * + *Requires {@link GL20 OpenGL 2.0}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public class ARBProgramInterfaceQuery { + + /** + * Accepted by the {@code programInterface} parameter of GetProgramInterfaceiv, GetProgramResourceIndex, GetProgramResourceName, GetProgramResourceiv, + * GetProgramResourceLocation, and GetProgramResourceLocationIndex. + */ + public static final int + GL_UNIFORM = 0x92E1, + GL_UNIFORM_BLOCK = 0x92E2, + GL_PROGRAM_INPUT = 0x92E3, + GL_PROGRAM_OUTPUT = 0x92E4, + GL_BUFFER_VARIABLE = 0x92E5, + GL_SHADER_STORAGE_BLOCK = 0x92E6, + GL_VERTEX_SUBROUTINE = 0x92E8, + GL_TESS_CONTROL_SUBROUTINE = 0x92E9, + GL_TESS_EVALUATION_SUBROUTINE = 0x92EA, + GL_GEOMETRY_SUBROUTINE = 0x92EB, + GL_FRAGMENT_SUBROUTINE = 0x92EC, + GL_COMPUTE_SUBROUTINE = 0x92ED, + GL_VERTEX_SUBROUTINE_UNIFORM = 0x92EE, + GL_TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF, + GL_TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0, + GL_GEOMETRY_SUBROUTINE_UNIFORM = 0x92F1, + GL_FRAGMENT_SUBROUTINE_UNIFORM = 0x92F2, + GL_COMPUTE_SUBROUTINE_UNIFORM = 0x92F3, + GL_TRANSFORM_FEEDBACK_VARYING = 0x92F4; + + /** Accepted by the {@code pname} parameter of GetProgramInterfaceiv. */ + public static final int + GL_ACTIVE_RESOURCES = 0x92F5, + GL_MAX_NAME_LENGTH = 0x92F6, + GL_MAX_NUM_ACTIVE_VARIABLES = 0x92F7, + GL_MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8; + + /** Accepted in the {@code props} array of GetProgramResourceiv. */ + public static final int + GL_NAME_LENGTH = 0x92F9, + GL_TYPE = 0x92FA, + GL_ARRAY_SIZE = 0x92FB, + GL_OFFSET = 0x92FC, + GL_BLOCK_INDEX = 0x92FD, + GL_ARRAY_STRIDE = 0x92FE, + GL_MATRIX_STRIDE = 0x92FF, + GL_IS_ROW_MAJOR = 0x9300, + GL_ATOMIC_COUNTER_BUFFER_INDEX = 0x9301, + GL_BUFFER_BINDING = 0x9302, + GL_BUFFER_DATA_SIZE = 0x9303, + GL_NUM_ACTIVE_VARIABLES = 0x9304, + GL_ACTIVE_VARIABLES = 0x9305, + GL_REFERENCED_BY_VERTEX_SHADER = 0x9306, + GL_REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307, + GL_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308, + GL_REFERENCED_BY_GEOMETRY_SHADER = 0x9309, + GL_REFERENCED_BY_FRAGMENT_SHADER = 0x930A, + GL_REFERENCED_BY_COMPUTE_SHADER = 0x930B, + GL_TOP_LEVEL_ARRAY_SIZE = 0x930C, + GL_TOP_LEVEL_ARRAY_STRIDE = 0x930D, + GL_LOCATION = 0x930E, + GL_LOCATION_INDEX = 0x930F, + GL_IS_PER_PATCH = 0x92E7; + + static { GL.initialize(); } + + protected ARBProgramInterfaceQuery() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetProgramInterfaceiv, caps.glGetProgramResourceIndex, caps.glGetProgramResourceName, caps.glGetProgramResourceiv, + caps.glGetProgramResourceLocation, caps.glGetProgramResourceLocationIndex + ); + } + + // --- [ glGetProgramInterfaceiv ] --- + + /** Unsafe version of: {@link #glGetProgramInterfaceiv GetProgramInterfaceiv} */ + public static void nglGetProgramInterfaceiv(int program, int programInterface, int pname, long params) { + GL43C.nglGetProgramInterfaceiv(program, programInterface, pname, params); + } + + /** + * Queries a property of an interface in a program. + * + * @param program the name of a program object whose interface to query + * @param programInterface a token identifying the interface within {@code program} to query. One of:| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_ACTIVE_RESOURCES ACTIVE_RESOURCES} | {@link GL43C#GL_MAX_NAME_LENGTH MAX_NAME_LENGTH} | {@link GL43C#GL_MAX_NUM_ACTIVE_VARIABLES MAX_NUM_ACTIVE_VARIABLES} |
| {@link GL43C#GL_MAX_NUM_COMPATIBLE_SUBROUTINES MAX_NUM_COMPATIBLE_SUBROUTINES} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_ACTIVE_RESOURCES ACTIVE_RESOURCES} | {@link GL43C#GL_MAX_NAME_LENGTH MAX_NAME_LENGTH} | {@link GL43C#GL_MAX_NUM_ACTIVE_VARIABLES MAX_NUM_ACTIVE_VARIABLES} |
| {@link GL43C#GL_MAX_NUM_COMPATIBLE_SUBROUTINES MAX_NUM_COMPATIBLE_SUBROUTINES} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} |
This extension provides an alternative provoking vertex convention for rendering lines, triangles, and (optionally depending on the implementation) + * quads.
+ * + *The provoking vertex of a primitive is the vertex that determines the constant primary and secondary colors when flat shading is enabled.
+ * + *In OpenGL, the provoking vertex for triangle, quad, line, and (trivially) point primitives is the last vertex used to assemble the primitive. The + * polygon primitive is an exception in OpenGL where the first vertex of a polygon primitive determines the color of the polygon, even if actually broken + * into triangles and/or quads.
+ * + *Alternatively the provoking vertex could be the first vertex of the primitive. Other APIs with flat-shading functionality such as Reality Lab and + * Direct3D have adopted the "first vertex of the primitive" convention to determine the provoking vertex. However, these APIs lack quads so do not have a + * defined provoking vertex convention for quads.
+ * + *The motivation for this extension is to allow applications developed for APIs with a "first vertex of the primitive" provoking vertex to be easily + * converted to OpenGL.
+ * + *Promoted to core in {@link GL32 OpenGL 3.2}.
+ */ +public class ARBProvokingVertex { + + /** Accepted by the {@code mode} parameter of ProvokingVertex. */ + public static final int + GL_FIRST_VERTEX_CONVENTION = 0x8E4D, + GL_LAST_VERTEX_CONVENTION = 0x8E4E; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_PROVOKING_VERTEX = 0x8E4F, + GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C; + + static { GL.initialize(); } + + protected ARBProvokingVertex() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glProvokingVertex + ); + } + + // --- [ glProvokingVertex ] --- + + /** + * Specifies the vertex to be used as the source of data for flat shaded varyings. + * + * @param mode the provoking vertex mode. One of:| {@link GL32C#GL_FIRST_VERTEX_CONVENTION FIRST_VERTEX_CONVENTION} | {@link GL32C#GL_LAST_VERTEX_CONVENTION LAST_VERTEX_CONVENTION} |
Statistics about the operation of the OpenGL pipeline, such as the number of samples that passed the depth test, the elapsed time between two events or + * the number of vertices written by transform feedback can be retrieved from the GL through query objects. The result of a query object is acquired by the + * application through the OpenGL API into a client provided memory location. Should the result returned by the API be required for use in a shader, it + * must be passed back to the GL via a program uniform or some other mechanism. This requires a round-trip from the GPU to the CPU and back.
+ * + *This extension introduces a mechanism whereby the result of a query object may be retrieved into a buffer object instead of client memory. This allows + * the query rsult to be made available to a shader without a round-trip to the CPU for example by subsequently using the buffer object as a uniform + * buffer, texture buffer or other data store visible to the shader. This functionality may also be used to place the results of many query objects into a + * single, large buffer and then map or otherwise read back the entire buffer at a later point in time, avoiding a per-query object CPU-GPU synchronization + * event.
+ * + *The extension allows acquiring the result of any query object type supported by the GL implementation into a buffer object. The implementation will + * determine the most efficient method of copying the query result to the buffer.
+ * + *Requires {@link GL15 OpenGL 1.5}.
+ */ +public final class ARBQueryBufferObject { + + /** Accepted by the {@code pname} parameter of {@link GL15C#glGetQueryObjectiv GetQueryObjectiv}, {@link GL15C#glGetQueryObjectuiv GetQueryObjectuiv}, {@link GL33C#glGetQueryObjecti64v GetQueryObjecti64v} and {@link GL33C#glGetQueryObjectui64v GetQueryObjectui64v}. */ + public static final int GL_QUERY_RESULT_NO_WAIT = 0x9194; + + /** + * Accepted by the {@code target} parameter of {@link GL15C#glBindBuffer BindBuffer}, {@link GL15C#glBufferData BufferData}, {@link GL15C#glBufferSubData BufferSubData}, {@link GL15C#glMapBuffer MapBuffer}, {@link GL15C#glUnmapBuffer UnmapBuffer}, {@link GL30C#glMapBufferRange MapBufferRange}, + * {@link GL15C#glGetBufferSubData GetBufferSubData}, {@link GL15C#glGetBufferParameteriv GetBufferParameteriv}, {@link GL32C#glGetBufferParameteri64v GetBufferParameteri64v}, {@link GL15C#glGetBufferPointerv GetBufferPointerv}, {@link GL43C#glClearBufferSubData ClearBufferSubData}, and the {@code readtarget} and + * {@code writetarget} parameters of {@link GL31C#glCopyBufferSubData CopyBufferSubData}. + */ + public static final int GL_QUERY_BUFFER = 0x9192; + + /** Accepted by the {@code pname} parameter of {@link GL11C#glGetBooleanv GetBooleanv}, {@link GL11C#glGetIntegerv GetIntegerv}, {@link GL11C#glGetFloatv GetFloatv}, and {@link GL11C#glGetDoublev GetDoublev}. */ + public static final int GL_QUERY_BUFFER_BINDING = 0x9193; + + /** Accepted in the {@code barriers} bitfield in {@link GL42C#glMemoryBarrier MemoryBarrier}. */ + public static final int GL_QUERY_BUFFER_BARRIER_BIT = 0x8000; + + private ARBQueryBufferObject() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBRobustness.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBRobustness.java new file mode 100644 index 00000000..5db139d7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBRobustness.java @@ -0,0 +1,1100 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the ARB_robustness extension. + * + *Several recent trends in how OpenGL integrates into modern computer systems have created new requirements for robustness and security for OpenGL + * rendering contexts.
+ * + *Additionally GPU architectures now support hardware fault detection; for example, video memory supporting ECC (error correcting codes) and error + * detection. OpenGL contexts should be capable of recovering from hardware faults such as uncorrectable memory errors. Along with recovery from such + * hardware faults, the recovery mechanism can also allow recovery from video memory access exceptions and system software failures. System software + * failures can be due to device changes or driver failures.
+ * + *Demands for increased software robustness and concerns about malware exploiting buffer overflows have lead API designers to provide additional "safe" + * APIs that bound the amount of data returned by an API query. For example, the safer "snprintf" or "_snprintf" routines are prefered over "sprintf".
+ * + *The OpenGL API has many such robustness perils. OpenGL queries return (write) some number of bytes to a buffer indicated by a pointer parameter. The + * exact number of bytes written by existing OpenGL queries is not expressed directly by any specific parameter; instead the number of bytes returned is a + * complex function of one or more query arguments, sometimes context state such as pixel store modes or the active texture selector, and the current state + * of an object (such as a texture level's number of total texels). By the standards of modern API design, such queries are not "safe". Making these + * queries safer involves introducing a new query API with an additional parameter that specifies the number of bytes in the buffer and never writing bytes + * beyond that limit.
+ * + *Multi-threaded use of OpenGL contexts in a "share group" allow sharing of objects such as textures and programs. Such sharing in conjunction with + * concurrent OpenGL commands stream execution by two or more contexts introduces hazards whereby one context can change objects in ways that can cause + * buffer overflows for another context's OpenGL queries.
+ * + *The original {@link ARBVertexBufferObject ARB_vertex_buffer_object} extension includes an issue that explicitly states program termination is allowed when out-of-bounds + * vertex buffer object fetches occur. Modern GPUs capable of DirectX 10 enforce the well-defined behavior of always returning zero values for indices or + * non-fixed components in this case. Older GPUs may require extra checks to enforce well-defined (and termination free) behavior, but this expense is + * warranted when processing potentially untrusted content.
+ * + *The intent of this extension is to address some specific robustness goals:
+ * + *In one anticipated usage model, WebGL contexts may make use of these robust features to grant greater stability when using untrusted code. WebGL + * contexts cannot call OpenGL commands directly but rather must route all OpenGL API calls through the web browser. It is then the web browser that + * configures the context, using the commands in this extension, to enforce safe behavior. In this scenario, the WebGL content cannot specify or change the + * use of this extension's features itself; the web browser enforces this policy.
+ * + *There are other well-known robustness issues with the OpenGL API which this extension does not address. For example, selector-based OpenGL commands are + * a well-known source of programming errors. Code to manipulate texture state may assume the active texture selector is set appropriately when an + * intervening function call obscures a change to the active texture state resulting in incorrectly updated or queried state. The + * {@link EXTDirectStateAccess EXT_direct_state_access} extension introduces selector-free OpenGL commands and queries to address that particular issue so this extension does + * not.
+ * + *The intent of this extension is NOT to deprecate any existing API and thereby introduce compatibility issues and coding burdens on existing code, but + * rather to provide new APIs to ensure a level of robustness commensurate with the expectations of modern applications of OpenGL.
+ */ +public class ARBRobustness { + + /** Returned by GetGraphicsResetStatusARB. */ + public static final int + GL_GUILTY_CONTEXT_RESET_ARB = 0x8253, + GL_INNOCENT_CONTEXT_RESET_ARB = 0x8254, + GL_UNKNOWN_CONTEXT_RESET_ARB = 0x8255; + + /** Accepted by the {@code value} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int GL_RESET_NOTIFICATION_STRATEGY_ARB = 0x8256; + + /** Returned by GetIntegerv and related simple queries when {@code value} is RESET_NOTIFICATION_STRATEGY_ARB. */ + public static final int + GL_LOSE_CONTEXT_ON_RESET_ARB = 0x8252, + GL_NO_RESET_NOTIFICATION_ARB = 0x8261; + + /** Returned by GetIntegerv when {@code pname} is CONTEXT_FLAGS. */ + public static final int GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB = 0x4; + + static { GL.initialize(); } + + protected ARBRobustness() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetIf a reset status other than NO_ERROR is returned and subsequent calls return NO_ERROR, the context reset was encountered and completed. If a reset + * status is repeatedly returned, the context may be in the process of resetting.
+ * + *Reset notification behavior is determined at context creation time, and may be queried by calling {@link GL11C#glGetIntegerv GetIntegerv} with the symbolic constant + * {@link #GL_RESET_NOTIFICATION_STRATEGY_ARB RESET_NOTIFICATION_STRATEGY_ARB}.
+ * + *If the reset notification behavior is {@link #GL_NO_RESET_NOTIFICATION_ARB NO_RESET_NOTIFICATION_ARB}, then the implementation will never deliver notification of reset events, and + * {@code GetGraphicsResetStatusARB} will always return NO_ERROR.
+ * + *If the behavior is {@link #GL_LOSE_CONTEXT_ON_RESET_ARB LOSE_CONTEXT_ON_RESET_ARB}, a graphics reset will result in the loss of all context state, requiring the recreation of all associated + * objects. In this case {@code GetGraphicsResetStatusARB}. may return any of the values described above.
+ * + *If a graphics reset notification occurs in a context, a notification must also occur in all other contexts which share objects with that context.
+ */ + @NativeType("GLenum") + public static native int glGetGraphicsResetStatusARB(); + + // --- [ glGetnMapdvARB ] --- + + /** + * Unsafe version of: {@link #glGetnMapdvARB GetnMapdvARB} + * + * @param bufSize the maximum number of bytes to write into {@code data} + */ + public static native void nglGetnMapdvARB(int target, int query, int bufSize, long data); + + /** + * Robust version of {@link GL11#glGetMapdv GetMapdv} + * + * @param target the evaluator map + * @param query the information to query + * @param data a buffer in which to place the returned data + */ + public static void glGetnMapdvARB(@NativeType("GLenum") int target, @NativeType("GLenum") int query, @NativeType("GLdouble *") DoubleBuffer data) { + nglGetnMapdvARB(target, query, data.remaining(), memAddress(data)); + } + + /** + * Robust version of {@link GL11#glGetMapdv GetMapdv} + * + * @param target the evaluator map + * @param query the information to query + */ + @NativeType("void") + public static double glGetnMapdARB(@NativeType("GLenum") int target, @NativeType("GLenum") int query) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + DoubleBuffer data = stack.callocDouble(1); + nglGetnMapdvARB(target, query, 1, memAddress(data)); + return data.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetnMapfvARB ] --- + + /** + * Unsafe version of: {@link #glGetnMapfvARB GetnMapfvARB} + * + * @param bufSize the maximum number of bytes to write into {@code data} + */ + public static native void nglGetnMapfvARB(int target, int query, int bufSize, long data); + + /** + * Robust version of {@link GL11#glGetMapfv GetMapfv} + * + * @param target the evaluator map + * @param query the information to query + * @param data a buffer in which to place the returned data + */ + public static void glGetnMapfvARB(@NativeType("GLenum") int target, @NativeType("GLenum") int query, @NativeType("GLfloat *") FloatBuffer data) { + nglGetnMapfvARB(target, query, data.remaining(), memAddress(data)); + } + + /** + * Robust version of {@link GL11#glGetMapfv GetMapfv} + * + * @param target the evaluator map + * @param query the information to query + */ + @NativeType("void") + public static float glGetnMapfARB(@NativeType("GLenum") int target, @NativeType("GLenum") int query) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + FloatBuffer data = stack.callocFloat(1); + nglGetnMapfvARB(target, query, 1, memAddress(data)); + return data.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetnMapivARB ] --- + + /** + * Unsafe version of: {@link #glGetnMapivARB GetnMapivARB} + * + * @param bufSize the maximum number of bytes to write into {@code data} + */ + public static native void nglGetnMapivARB(int target, int query, int bufSize, long data); + + /** + * Robust version of {@link GL11#glGetMapiv GetMapiv} + * + * @param target the evaluator target. One of:| {@link GL11#GL_MAP1_VERTEX_3 MAP1_VERTEX_3} | {@link GL11#GL_MAP1_VERTEX_4 MAP1_VERTEX_4} | {@link GL11#GL_MAP1_COLOR_4 MAP1_COLOR_4} | {@link GL11#GL_MAP1_NORMAL MAP1_NORMAL} | {@link GL11#GL_MAP1_TEXTURE_COORD_1 MAP1_TEXTURE_COORD_1} |
| {@link GL11#GL_MAP1_TEXTURE_COORD_2 MAP1_TEXTURE_COORD_2} | {@link GL11#GL_MAP1_TEXTURE_COORD_3 MAP1_TEXTURE_COORD_3} | {@link GL11#GL_MAP1_TEXTURE_COORD_4 MAP1_TEXTURE_COORD_4} | {@link GL11#GL_MAP2_VERTEX_3 MAP2_VERTEX_3} | {@link GL11#GL_MAP2_VERTEX_4 MAP2_VERTEX_4} |
| {@link GL11#GL_MAP2_COLOR_4 MAP2_COLOR_4} | {@link GL11#GL_MAP2_NORMAL MAP2_NORMAL} | {@link GL11#GL_MAP2_TEXTURE_COORD_1 MAP2_TEXTURE_COORD_1} | {@link GL11#GL_MAP2_TEXTURE_COORD_2 MAP2_TEXTURE_COORD_2} | {@link GL11#GL_MAP2_TEXTURE_COORD_3 MAP2_TEXTURE_COORD_3} |
| {@link GL11#GL_MAP2_TEXTURE_COORD_4 MAP2_TEXTURE_COORD_4} |
| {@link GL11#GL_ORDER ORDER} | {@link GL11#GL_COEFF COEFF} | {@link GL11#GL_DOMAIN DOMAIN} |
| {@link GL11#GL_MAP1_VERTEX_3 MAP1_VERTEX_3} | {@link GL11#GL_MAP1_VERTEX_4 MAP1_VERTEX_4} | {@link GL11#GL_MAP1_COLOR_4 MAP1_COLOR_4} | {@link GL11#GL_MAP1_NORMAL MAP1_NORMAL} | {@link GL11#GL_MAP1_TEXTURE_COORD_1 MAP1_TEXTURE_COORD_1} |
| {@link GL11#GL_MAP1_TEXTURE_COORD_2 MAP1_TEXTURE_COORD_2} | {@link GL11#GL_MAP1_TEXTURE_COORD_3 MAP1_TEXTURE_COORD_3} | {@link GL11#GL_MAP1_TEXTURE_COORD_4 MAP1_TEXTURE_COORD_4} | {@link GL11#GL_MAP2_VERTEX_3 MAP2_VERTEX_3} | {@link GL11#GL_MAP2_VERTEX_4 MAP2_VERTEX_4} |
| {@link GL11#GL_MAP2_COLOR_4 MAP2_COLOR_4} | {@link GL11#GL_MAP2_NORMAL MAP2_NORMAL} | {@link GL11#GL_MAP2_TEXTURE_COORD_1 MAP2_TEXTURE_COORD_1} | {@link GL11#GL_MAP2_TEXTURE_COORD_2 MAP2_TEXTURE_COORD_2} | {@link GL11#GL_MAP2_TEXTURE_COORD_3 MAP2_TEXTURE_COORD_3} |
| {@link GL11#GL_MAP2_TEXTURE_COORD_4 MAP2_TEXTURE_COORD_4} |
| {@link GL11#GL_ORDER ORDER} | {@link GL11#GL_COEFF COEFF} | {@link GL11#GL_DOMAIN DOMAIN} |
| {@link GL11#GL_PIXEL_MAP_I_TO_I PIXEL_MAP_I_TO_I} | {@link GL11#GL_PIXEL_MAP_S_TO_S PIXEL_MAP_S_TO_S} | {@link GL11#GL_PIXEL_MAP_I_TO_R PIXEL_MAP_I_TO_R} | {@link GL11#GL_PIXEL_MAP_I_TO_G PIXEL_MAP_I_TO_G} | {@link GL11#GL_PIXEL_MAP_I_TO_B PIXEL_MAP_I_TO_B} |
| {@link GL11#GL_PIXEL_MAP_I_TO_A PIXEL_MAP_I_TO_A} | {@link GL11#GL_PIXEL_MAP_R_TO_R PIXEL_MAP_R_TO_R} | {@link GL11#GL_PIXEL_MAP_G_TO_G PIXEL_MAP_G_TO_G} | {@link GL11#GL_PIXEL_MAP_B_TO_B PIXEL_MAP_B_TO_B} | {@link GL11#GL_PIXEL_MAP_A_TO_A PIXEL_MAP_A_TO_A} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link ARBImaging#GL_COLOR_TABLE COLOR_TABLE} | {@link ARBImaging#GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link ARBImaging#GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_COLOR_TABLE COLOR_TABLE} | {@link ARBImaging#GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link ARBImaging#GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_COLOR_TABLE COLOR_TABLE} | {@link ARBImaging#GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link ARBImaging#GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_COLOR_TABLE COLOR_TABLE} | {@link ARBImaging#GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link ARBImaging#GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_COLOR_TABLE COLOR_TABLE} | {@link ARBImaging#GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link ARBImaging#GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_CONVOLUTION_1D CONVOLUTION_1D} | {@link ARBImaging#GL_CONVOLUTION_2D CONVOLUTION_2D} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_CONVOLUTION_1D CONVOLUTION_1D} | {@link ARBImaging#GL_CONVOLUTION_2D CONVOLUTION_2D} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_SEPARABLE_2D SEPARABLE_2D} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_SEPARABLE_2D SEPARABLE_2D} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_HISTOGRAM HISTOGRAM} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_HISTOGRAM HISTOGRAM} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_MINMAX MINMAX} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_MINMAX MINMAX} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
{@code ARB_gl_spirv} added support for using SPIR-V modules in OpenGL. However it only added support for SPIR-V 1.0 concepts that were part of the + * OpenGL 4.5 Core Profile.
+ * + *There are a great number of additional OpenGL ARB and vendor extensions which add shading language concepts and since they were defined prior to the + * existence of SPIR-V support in OpenGL they don't add SPIR-V support for their additional features. Ideally {@code GL_ARB_gl_spirv} would have added + * support for them, but as noted in Issue 27 of that extension, support for them was left as a future exercise.
+ * + *Now that at least some of that functionality has been defined via SPIR-V extensions, there is currently no way for an OpenGL implementation to + * advertise that is supports additional SPIR-V extensions.
+ * + *This extension provides a mechanism for an implementation to advertise which SPIR-V extensions it supports, and further provides a place where the + * SPIR-V environment for those extensions can be documented for OpenGL.
+ * + *It is expected that this document can be extended over time as SPIR-V support for additional extensions is added. The mapping between GLSL and SPIR-V + * concepts and any other pertinent information can be provided here as interactions with the corresponding OpenGL and SPIR-V extensions.
+ * + *Requires {@link ARBGLSPIRV OpenGL B.G}.
+ */ +public final class ARBSPIRVExtensions { + + /** Accepted by the {@code name} parameter of {@link GL30C#glGetStringi GetStringi}. */ + public static final int GL_SPIR_V_EXTENSIONS = 0x9553; + + /** Accepted by the {@code pname} parameter of {@link GL11C#glGetIntegerv GetIntegerv}. */ + public static final int GL_NUM_SPIR_V_EXTENSIONS = 0x9554; + + private ARBSPIRVExtensions() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSampleLocations.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSampleLocations.java new file mode 100644 index 00000000..ea49266d --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSampleLocations.java @@ -0,0 +1,138 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the ARB_sample_locations extension. + * + *This extension allows an application to modify the locations of samples within a pixel used in multisample rasterization. Additionally, it allows + * applications to specify different sample locations for each pixel in a group of adjacent pixels, which may increase antialiasing quality (particularly + * if a custom resolve shader is used that takes advantage of these different locations).
+ * + *It is common for implementations to optimize the storage of depth values by storing values that can be used to reconstruct depth at each sample + * location, rather than storing separate depth values for each sample. For example, the depth values from a single triangle can be represented using + * plane equations. When the depth value for a sample is needed, it is automatically evaluated at the sample location. Modifying the sample locations + * causes the reconstruction to no longer evaluate the same depth values as when the samples were originally generated. This extension provides a command + * to "evaluate" and store per-sample depth values using the currently programmed sample locations, which allows the application to manage this issue + * if/when necessary.
+ * + *The programmable sample locations are used during rasterization and for evaluation of depth functions during normal geometric rendering. The + * programmable locations are associated with a framebuffer object rather than an individual depth buffer, so if the depth buffer is used as a texture the + * texture sampling may be done at the standard sample locations. Additionally, commands that do not render geometric primitives (e.g. ReadPixels, + * BlitFramebuffer, CopyTexSubImage2D, etc.) may use the standard sample locations to evaluate depth functions rather than the programmable locations. If + * a single depth buffer is used at different times with different sample locations, the depth functions may be interpreted using the current sample + * locations.
+ */ +public class ARBSampleLocations { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int + GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB = 0x933D, + GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB = 0x933E, + GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB = 0x933F, + GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB = 0x9340; + + /** + * // Alias of SAMPLE_POSITION. Before NV_expms, the spec used "location". SAMPLE_LOCATION_ARB 0x8E50 PROGRAMMABLE_SAMPLE_LOCATION_ARB 0x9341 Accepted by + * the {@code pname} parameter of FramebufferParameteri, GetFramebufferParameteriv. + */ + public static final int + GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_ARB = 0x9342, + GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_ARB = 0x9343; + + static { GL.initialize(); } + + protected ARBSampleLocations() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glFramebufferSampleLocationsfvARB, caps.glNamedFramebufferSampleLocationsfvARB, caps.glEvaluateDepthValuesARB + ); + } + + // --- [ glFramebufferSampleLocationsfvARB ] --- + + /** + * Unsafe version of: {@link #glFramebufferSampleLocationsfvARB FramebufferSampleLocationsfvARB} + * + * @param count the number of sample locations to update + */ + public static native void nglFramebufferSampleLocationsfvARB(int target, int start, int count, long v); + + /** + * Controls the programmable sample locations for the framebuffer bound to the specified {@code target}. + * + *There are {@code N} pairs of programmable sample locations values in a framebuffer, where {@code N} is the value of + * {@link #GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB}. Each programmable sample location is specified as a pair of floating point values in the range + * {@code [0,1]}, corresponding to the x and y locations respectively in GL pixel space. {@code (0.5, 0.5)} thus corresponds to the pixel center. Sample + * locations outside of {@code [0,1]} result in undefined behavior.
+ * + * @param target the framebuffer target. One of:| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} |
In standard multisample rendering, an implementation is allowed to assign the same color and texture coordinate values to each sample, which then allows + * the optimization where the shader is only evaluated once and then distributed to the samples that have been determined to be covered by the primitive + * currently being rasterized. This can cause aliasing where the input color and texture coordinates are used to generate a result that doesn't antialias + * itself, for example with alpha-tested transparency.
+ * + *This extension adds the ability to explicitly request that an implementation use a minimum number of unique set of fragment computation inputs when + * multisampling a pixel. Specifying such a requirement can reduce aliasing that results from evaluating the fragment computations too few times per pixel.
+ * + *This extension adds new global state that controls the minimum number of samples for which attribute data is independently interpolated. When enabled, + * all operations that were traditionally executed per-fragment operate independently on each sample.
+ * + *This also extends the shading language to allow control over the sample being processed. This includes built-in fragment input variables identifying the + * sample number and position being processed when executing fragment shaders per sample.
+ * + *Requires {@link GL20 OpenGL 2.0} and GLSL 1.30. Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public class ARBSampleShading { + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_SAMPLE_SHADING_ARB = 0x8C36; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int GL_MIN_SAMPLE_SHADING_VALUE_ARB = 0x8C37; + + static { GL.initialize(); } + + protected ARBSampleShading() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glMinSampleShadingARB + ); + } + + // --- [ glMinSampleShadingARB ] --- + + /** + * Sets the minimum sample shading fraction. {@code value} is clamped to [0,1] when specified. + * + * @param value the minimum sample shading fraction + */ + public static native void glMinSampleShadingARB(@NativeType("GLfloat") float value); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSamplerObjects.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSamplerObjects.java new file mode 100644 index 00000000..0ff1c9fe --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSamplerObjects.java @@ -0,0 +1,390 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_sampler_objects extension. + * + *In unextended OpenGL textures are considered to be sets of image data (mip-chains, arrays, cube-map face sets, etc.) and sampling state (sampling mode, + * mip-mapping state, coordinate wrapping and clamping rules, etc.) combined into a single object. It is typical for an application to use many textures + * with a limited set of sampling states that are the same between them. In order to use textures in this way, an application must generate and configure + * many texture names, adding overhead both to applications and to implementations. Furthermore, should an application wish to sample from a texture in + * more than one way (with and without mip-mapping, for example) it must either modify the state of the texture or create two textures, each with a copy of + * the same image data. This can introduce runtime and memory costs to the application.
+ * + *This extension separates sampler state from texture image data. A new object type is introduced, the sampler (representing generic sampling parameters). + * The new sampler objects are represented by a new named type encapsulating the sampling parameters of a traditional texture object. Sampler objects may + * be bound to texture units to supplant the bound texture's sampling state. A single sampler may be bound to more than one texture unit simultaneously, + * allowing different textures to be accessed with a single set of shared sampling parameters. Also, by binding different sampler objects to texture units + * to which the same texture has been bound, the same texture image data may be sampled with different sampling parameters.
+ * + *Promoted to core in {@link GL33 OpenGL 3.3}.
+ */ +public class ARBSamplerObjects { + + /** Accepted by the {@code value} parameter of the GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv and GetDoublev functions. */ + public static final int GL_SAMPLER_BINDING = 0x8919; + + static { GL.initialize(); } + + protected ARBSamplerObjects() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGenSamplers, caps.glDeleteSamplers, caps.glIsSampler, caps.glBindSampler, caps.glSamplerParameteri, caps.glSamplerParameterf, + caps.glSamplerParameteriv, caps.glSamplerParameterfv, caps.glSamplerParameterIiv, caps.glSamplerParameterIuiv, caps.glGetSamplerParameteriv, + caps.glGetSamplerParameterfv, caps.glGetSamplerParameterIiv, caps.glGetSamplerParameterIuiv + ); + } + + // --- [ glGenSamplers ] --- + + /** + * Unsafe version of: {@link #glGenSamplers GenSamplers} + * + * @param count the number of sampler object names to generate + */ + public static void nglGenSamplers(int count, long samplers) { + GL33C.nglGenSamplers(count, samplers); + } + + /** + * Generates sampler object names. + * + * @param samplers a buffer in which the generated sampler object names are stored + */ + public static void glGenSamplers(@NativeType("GLuint *") IntBuffer samplers) { + GL33C.glGenSamplers(samplers); + } + + /** Generates sampler object names. */ + @NativeType("void") + public static int glGenSamplers() { + return GL33C.glGenSamplers(); + } + + // --- [ glDeleteSamplers ] --- + + /** + * Unsafe version of: {@link #glDeleteSamplers DeleteSamplers} + * + * @param count the number of sampler objects to be deleted + */ + public static void nglDeleteSamplers(int count, long samplers) { + GL33C.nglDeleteSamplers(count, samplers); + } + + /** + * Deletes named sampler objects. + * + * @param samplers an array of sampler objects to be deleted + */ + public static void glDeleteSamplers(@NativeType("GLuint const *") IntBuffer samplers) { + GL33C.glDeleteSamplers(samplers); + } + + /** Deletes named sampler objects. */ + public static void glDeleteSamplers(@NativeType("GLuint const *") int sampler) { + GL33C.glDeleteSamplers(sampler); + } + + // --- [ glIsSampler ] --- + + /** + * Determines if a name corresponds to a sampler object. + * + * @param sampler a value that may be the name of a sampler object + */ + @NativeType("GLboolean") + public static boolean glIsSampler(@NativeType("GLuint") int sampler) { + return GL33C.glIsSampler(sampler); + } + + // --- [ glBindSampler ] --- + + /** + * Binds a named sampler to a texturing target. + * + * @param unit the index of the texture unit to which the sampler is bound + * @param sampler the name of a sampler + */ + public static void glBindSampler(@NativeType("GLuint") int unit, @NativeType("GLuint") int sampler) { + GL33C.glBindSampler(unit, sampler); + } + + // --- [ glSamplerParameteri ] --- + + /** + * Set the integer value of a sampler parameter. + * + * @param sampler the sampler object whose parameter to modify + * @param pname the symbolic name of a single-valued sampler parameter. One of:| {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} | {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} |
| {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} | {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} | {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} |
| {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} | {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} |
| {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} | {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| , | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} |
| {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} | {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} |
| {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} | {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| , | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} |
When sampling from cube map textures, a three-dimensional texture coordinate is used to select one of the cube map faces and generate a two dimensional + * texture coordinate ( s t ), at which a texel is sampled from the determined face of the cube map texture. Each face of the texture is treated as an + * independent two-dimensional texture, and the generated ( s t ) coordinate is subjected to the same clamping and wrapping rules as for any other two + * dimensional texture fetch.
+ * + *Although it is unlikely that the generated ( s t ) coordinate lies significantly outside the determined cube map face, it is often the case that the + * locations of the individual elements required during a linear sampling do not lie within the determined face, and their coordinates will therefore be + * modified by the selected clamping and wrapping rules. This often has the effect of producing seams or other discontinuities in the sampled texture.
+ * + *This extension allows implementations to take samples from adjacent cube map faces, providing the ability to create seamless cube maps.
+ * + *Promoted to core in {@link GL32 OpenGL 3.2}.
+ */ +public final class ARBSeamlessCubeMap { + + /** + * Accepted by the {@code cap} parameter of Enable, Disable and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv and + * GetDoublev. + */ + public static final int GL_TEXTURE_CUBE_MAP_SEAMLESS = 0x884F; + + private ARBSeamlessCubeMap() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSeamlessCubemapPerTexture.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSeamlessCubemapPerTexture.java new file mode 100644 index 00000000..b5bcdee4 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSeamlessCubemapPerTexture.java @@ -0,0 +1,37 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_seamless_cubemap_per_texture extension. + * + *In unextended OpenGL, cube maps are treated as sets of six, independent texture images. Once a face is selected from the set, it is treated exactly as + * any other two-dimensional texture would be. When sampling linearly from the texture, all of the individual texels that would be used to to create the + * final, bilinear sample values are taken from the same cube face. The normal, two-dimensional texture coordinate wrapping modes are honored. This + * sometimes causes seams to appear in cube maps.
+ * + *{@link ARBSeamlessCubeMap ARB_seamless_cube_map} (and subsequently, OpenGL 3.2) addresses this issue by providing a mechanism whereby an implementation could take each of + * the taps of a bilinear sample from a different face, spanning face boundaries and providing seamless filtering from cube map textures. However, in + * ARB_seamless_cube_map, this feature was exposed as a global state, affecting all bound cube map textures. It was not possible to mix seamless and + * per-face cube map sampling modes during sampling. Furthermore, if an application included cube maps that were meant to be sampled seamlessly and + * non-seamlessly, it would have to track this state and enable or disable seamless cube map sampling as needed.
+ * + *This extension addresses this issue and provides an orthogonal method for allowing an implementation to provide a per-texture setting for enabling + * seamless sampling from cube maps.
+ * + *Requires {@link GL32 OpenGL 3.2}.
+ */ +public final class ARBSeamlessCubemapPerTexture { + + /** + * Accepted by the {@code pname} parameter of TexParameter{if}, TexParameter{if}v, GetTexParameter{if}v, SamplerParameter{if}, SamplerParameter{if}v, and + * GetSamplerParameter{if}v. + */ + public static final int GL_TEXTURE_CUBE_MAP_SEAMLESS = 0x884F; + + private ARBSeamlessCubemapPerTexture() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSeparateShaderObjects.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSeparateShaderObjects.java new file mode 100644 index 00000000..5aba41cc --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSeparateShaderObjects.java @@ -0,0 +1,1618 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_separate_shader_objects extension. + * + *Conventional GLSL requires multiple shader stages (vertex, fragment, geometry, tessellation control, and tessellation evaluation) to be linked into a + * single monolithic program object to specify a GLSL shader for each stage.
+ * + *While GLSL's monolithic approach has some advantages for optimizing shaders as a unit that span multiple stages, all existing GPU hardware supports the + * more flexible mix-and-match approach.
+ * + *Shaders written for HLSL9, Cg, the prior OpenGL assembly program extensions, and game console favor a more flexible "mix-and-match" approach to + * specifying shaders independently for these different shader stages. Many developers build their shader content around the mix-and-match approach where + * they can use a single vertex shader with multiple fragment shaders (or vice versa).
+ * + *This extension adopts a "mix-and-match" shader stage model for GLSL allowing multiple different GLSL program objects to be bound at once each to an + * individual rendering pipeline stage independently of other stage bindings. This allows program objects to contain only the shader stages that best suit + * the applications needs.
+ * + *This extension introduces the program pipeline object that serves as a container for the program bound to any particular rendering stage. It can be + * bound, unbound, and rebound to simply save and restore the complete shader stage to program object bindings. Like framebuffer and vertex array objects, + * program pipeline objects are "container" objects that are not shared between contexts.
+ * + *To bind a program object to a specific shader stage or set of stages, {@link #glUseProgramStages UseProgramStages} is used. The {@link #GL_VERTEX_SHADER_BIT VERTEX_SHADER_BIT}, {@link #GL_GEOMETRY_SHADER_BIT GEOMETRY_SHADER_BIT}, + * {@link #GL_FRAGMENT_SHADER_BIT FRAGMENT_SHADER_BIT}, {@link #GL_TESS_CONTROL_SHADER_BIT TESS_CONTROL_SHADER_BIT}, and {@link #GL_TESS_EVALUATION_SHADER_BIT TESS_EVALUATION_SHADER_BIT} tokens refer to the conventional vertex, geometry, fragment, + * tessellation control and tessellation evaluation stages respectively. {@link #glActiveShaderProgram ActiveShaderProgram} specifies the program that Uniform* commands will update.
+ * + *While {@link #glActiveShaderProgram ActiveShaderProgram} allows the use of conventional Uniform* commands to update uniform variable values for separable program objects, this + * extension provides a preferrable interface in a set of ProgramUniform* commands that update the same uniform variables but take a parameter indicating + * the program object to be updated, rather than updating the currently active program object. These commands mirror those introduced in + * {@link EXTDirectStateAccess EXT_direct_state_access}.
+ * + *While {@link #glActiveShaderProgram ActiveShaderProgram} provides a selector for setting and querying uniform values of a program object, the glProgramUniform* commands provide a + * selector-free way to modify uniforms of a GLSL program object without an explicit bind. This selector-free model reduces API overhead and provides a + * cleaner interface for applications.
+ * + *Separate linking creates the possibility that certain output varyings of a shader may go unread by the subsequent shader inputting varyings. In this + * case, the output varyings are simply ignored. It is also possible input varyings from a shader may not be written as output varyings of a preceding + * shader. In this case, the unwritten input varying values are undefined.
+ * + *This extension builds on the proof-of-concept provided by {@link EXTSeparateShaderObjects EXT_separate_shader_objects} which demonstrated that separate shader objects can work + * for GLSL. {@code EXT_separate_shader_objects} was a response to repeated requests for this functionality from 3D developers.
+ * + *This ARB version addresses several "loose ends" in the prior EXT extension. In particular, it allows user-defined varyings with explicitly defined + * locations or implicitly assigned locations.
+ * + *This ARB extension extends the GLSL language's use of layout qualifiers to provide cross-stage interfacing.
+ * + *Requires {@link GL20 OpenGL 2.0} or {@link ARBShaderObjects ARB_shader_objects}. Promoted to core in {@link GL41 OpenGL 4.1}.
+ */ +public class ARBSeparateShaderObjects { + + /** Accepted by {@code stages} parameter to UseProgramStages. */ + public static final int + GL_VERTEX_SHADER_BIT = 0x1, + GL_FRAGMENT_SHADER_BIT = 0x2, + GL_GEOMETRY_SHADER_BIT = 0x4, + GL_TESS_CONTROL_SHADER_BIT = 0x8, + GL_TESS_EVALUATION_SHADER_BIT = 0x10, + GL_ALL_SHADER_BITS = 0xFFFFFFFF; + + /** Accepted by the {@code pname} parameter of ProgramParameteri and GetProgramiv. */ + public static final int GL_PROGRAM_SEPARABLE = 0x8258; + + /** Accepted by {@code type} parameter to GetProgramPipelineiv. */ + public static final int GL_ACTIVE_PROGRAM = 0x8259; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int GL_PROGRAM_PIPELINE_BINDING = 0x825A; + + static { GL.initialize(); } + + protected ARBSeparateShaderObjects() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glUseProgramStages, caps.glActiveShaderProgram, caps.glCreateShaderProgramv, caps.glBindProgramPipeline, caps.glDeleteProgramPipelines, + caps.glGenProgramPipelines, caps.glIsProgramPipeline, caps.glProgramParameteri, caps.glGetProgramPipelineiv, caps.glProgramUniform1i, + caps.glProgramUniform2i, caps.glProgramUniform3i, caps.glProgramUniform4i, caps.glProgramUniform1ui, caps.glProgramUniform2ui, + caps.glProgramUniform3ui, caps.glProgramUniform4ui, caps.glProgramUniform1f, caps.glProgramUniform2f, caps.glProgramUniform3f, + caps.glProgramUniform4f, caps.glProgramUniform1d, caps.glProgramUniform2d, caps.glProgramUniform3d, caps.glProgramUniform4d, + caps.glProgramUniform1iv, caps.glProgramUniform2iv, caps.glProgramUniform3iv, caps.glProgramUniform4iv, caps.glProgramUniform1uiv, + caps.glProgramUniform2uiv, caps.glProgramUniform3uiv, caps.glProgramUniform4uiv, caps.glProgramUniform1fv, caps.glProgramUniform2fv, + caps.glProgramUniform3fv, caps.glProgramUniform4fv, caps.glProgramUniform1dv, caps.glProgramUniform2dv, caps.glProgramUniform3dv, + caps.glProgramUniform4dv, caps.glProgramUniformMatrix2fv, caps.glProgramUniformMatrix3fv, caps.glProgramUniformMatrix4fv, + caps.glProgramUniformMatrix2dv, caps.glProgramUniformMatrix3dv, caps.glProgramUniformMatrix4dv, caps.glProgramUniformMatrix2x3fv, + caps.glProgramUniformMatrix3x2fv, caps.glProgramUniformMatrix2x4fv, caps.glProgramUniformMatrix4x2fv, caps.glProgramUniformMatrix3x4fv, + caps.glProgramUniformMatrix4x3fv, caps.glProgramUniformMatrix2x3dv, caps.glProgramUniformMatrix3x2dv, caps.glProgramUniformMatrix2x4dv, + caps.glProgramUniformMatrix4x2dv, caps.glProgramUniformMatrix3x4dv, caps.glProgramUniformMatrix4x3dv, caps.glValidateProgramPipeline, + caps.glGetProgramPipelineInfoLog + ); + } + + // --- [ glUseProgramStages ] --- + + /** + * Binds stages of a program object to a program pipeline. + * + * @param pipeline the program pipeline object to which to bind stages from {@code program} + * @param stages a set of program stages to bind to the program pipeline object + * @param program the program object containing the shader executables to use in {@code pipeline} + */ + public static void glUseProgramStages(@NativeType("GLuint") int pipeline, @NativeType("GLbitfield") int stages, @NativeType("GLuint") int program) { + GL41C.glUseProgramStages(pipeline, stages, program); + } + + // --- [ glActiveShaderProgram ] --- + + /** + * Sets the active program object for a program pipeline object. + * + * @param pipeline the program pipeline object to set the active program object for + * @param program the program object to set as the active program pipeline object {@code pipeline} + */ + public static void glActiveShaderProgram(@NativeType("GLuint") int pipeline, @NativeType("GLuint") int program) { + GL41C.glActiveShaderProgram(pipeline, program); + } + + // --- [ glCreateShaderProgramv ] --- + + /** + * Unsafe version of: {@link #glCreateShaderProgramv CreateShaderProgramv} + * + * @param count the number of source code strings in the array {@code strings} + */ + public static int nglCreateShaderProgramv(int type, int count, long strings) { + return GL41C.nglCreateShaderProgramv(type, count, strings); + } + + /** + * Creates a stand-alone program from an array of null-terminated source code strings. + * + *{@code glCreateShaderProgram} is equivalent (assuming no errors are generated) to:
+ * + *
+ * const GLuint shader = glCreateShader(type);
+ * if (shader) {
+ * glShaderSource(shader, count, strings, NULL);
+ * glCompileShader(shader);
+ * const GLuint program = glCreateProgram();
+ * if (program) {
+ * GLint compiled = GL_FALSE;
+ * glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+ * glProgramParameteri(program, GL_PROGRAM_SEPARABLE, GL_TRUE);
+ * if (compiled) {
+ * glAttachShader(program, shader);
+ * glLinkProgram(program);
+ * glDetachShader(program, shader);
+ * }
+ * // append-shader-info-log-to-program-info-log
+ * }
+ * glDeleteShader(shader);
+ * return program;
+ * } else {
+ * return 0;
+ * }The program object created by glCreateShaderProgram has its GL_PROGRAM_SEPARABLE status set to GL_TRUE.
+ * + * @param type the type of shader to create + * @param strings an array of pointers to source code strings from which to create the program object + */ + @NativeType("GLuint") + public static int glCreateShaderProgramv(@NativeType("GLenum") int type, @NativeType("GLchar const **") PointerBuffer strings) { + return GL41C.glCreateShaderProgramv(type, strings); + } + + /** + * Creates a stand-alone program from an array of null-terminated source code strings. + * + *{@code glCreateShaderProgram} is equivalent (assuming no errors are generated) to:
+ * + *
+ * const GLuint shader = glCreateShader(type);
+ * if (shader) {
+ * glShaderSource(shader, count, strings, NULL);
+ * glCompileShader(shader);
+ * const GLuint program = glCreateProgram();
+ * if (program) {
+ * GLint compiled = GL_FALSE;
+ * glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+ * glProgramParameteri(program, GL_PROGRAM_SEPARABLE, GL_TRUE);
+ * if (compiled) {
+ * glAttachShader(program, shader);
+ * glLinkProgram(program);
+ * glDetachShader(program, shader);
+ * }
+ * // append-shader-info-log-to-program-info-log
+ * }
+ * glDeleteShader(shader);
+ * return program;
+ * } else {
+ * return 0;
+ * }The program object created by glCreateShaderProgram has its GL_PROGRAM_SEPARABLE status set to GL_TRUE.
+ * + * @param type the type of shader to create + * @param strings an array of pointers to source code strings from which to create the program object + */ + @NativeType("GLuint") + public static int glCreateShaderProgramv(@NativeType("GLenum") int type, @NativeType("GLchar const **") CharSequence... strings) { + return GL41C.glCreateShaderProgramv(type, strings); + } + + /** + * Creates a stand-alone program from an array of null-terminated source code strings. + * + *{@code glCreateShaderProgram} is equivalent (assuming no errors are generated) to:
+ * + *
+ * const GLuint shader = glCreateShader(type);
+ * if (shader) {
+ * glShaderSource(shader, count, strings, NULL);
+ * glCompileShader(shader);
+ * const GLuint program = glCreateProgram();
+ * if (program) {
+ * GLint compiled = GL_FALSE;
+ * glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+ * glProgramParameteri(program, GL_PROGRAM_SEPARABLE, GL_TRUE);
+ * if (compiled) {
+ * glAttachShader(program, shader);
+ * glLinkProgram(program);
+ * glDetachShader(program, shader);
+ * }
+ * // append-shader-info-log-to-program-info-log
+ * }
+ * glDeleteShader(shader);
+ * return program;
+ * } else {
+ * return 0;
+ * }The program object created by glCreateShaderProgram has its GL_PROGRAM_SEPARABLE status set to GL_TRUE.
+ * + * @param type the type of shader to create + */ + @NativeType("GLuint") + public static int glCreateShaderProgramv(@NativeType("GLenum") int type, @NativeType("GLchar const **") CharSequence string) { + return GL41C.glCreateShaderProgramv(type, string); + } + + // --- [ glBindProgramPipeline ] --- + + /** + * Binds a program pipeline to the current context. + * + * @param pipeline the name of the pipeline object to bind to the context + */ + public static void glBindProgramPipeline(@NativeType("GLuint") int pipeline) { + GL41C.glBindProgramPipeline(pipeline); + } + + // --- [ glDeleteProgramPipelines ] --- + + /** + * Unsafe version of: {@link #glDeleteProgramPipelines DeleteProgramPipelines} + * + * @param n the number of program pipeline objects to delete + */ + public static void nglDeleteProgramPipelines(int n, long pipelines) { + GL41C.nglDeleteProgramPipelines(n, pipelines); + } + + /** + * Deletes program pipeline objects. + * + * @param pipelines an array of names of program pipeline objects to delete + */ + public static void glDeleteProgramPipelines(@NativeType("GLuint const *") IntBuffer pipelines) { + GL41C.glDeleteProgramPipelines(pipelines); + } + + /** Deletes program pipeline objects. */ + public static void glDeleteProgramPipelines(@NativeType("GLuint const *") int pipeline) { + GL41C.glDeleteProgramPipelines(pipeline); + } + + // --- [ glGenProgramPipelines ] --- + + /** + * Unsafe version of: {@link #glGenProgramPipelines GenProgramPipelines} + * + * @param n the number of program pipeline object names to reserve + */ + public static void nglGenProgramPipelines(int n, long pipelines) { + GL41C.nglGenProgramPipelines(n, pipelines); + } + + /** + * Reserves program pipeline object names. + * + * @param pipelines an array of into which the reserved names will be written + */ + public static void glGenProgramPipelines(@NativeType("GLuint *") IntBuffer pipelines) { + GL41C.glGenProgramPipelines(pipelines); + } + + /** Reserves program pipeline object names. */ + @NativeType("void") + public static int glGenProgramPipelines() { + return GL41C.glGenProgramPipelines(); + } + + // --- [ glIsProgramPipeline ] --- + + /** + * Determines if a name corresponds to a program pipeline object. + * + * @param pipeline a value that may be the name of a program pipeline object + */ + @NativeType("GLboolean") + public static boolean glIsProgramPipeline(@NativeType("GLuint") int pipeline) { + return GL41C.glIsProgramPipeline(pipeline); + } + + // --- [ glProgramParameteri ] --- + + /** + * Specifies the integer value of a program object parameter. + * + * @param program the name of a program object whose parameter to modify + * @param pname the name of the parameter to modify. One of:| {@link GL41C#GL_PROGRAM_BINARY_RETRIEVABLE_HINT PROGRAM_BINARY_RETRIEVABLE_HINT} | {@link GL41C#GL_PROGRAM_SEPARABLE PROGRAM_SEPARABLE} |
| {@link GL41C#GL_ACTIVE_PROGRAM ACTIVE_PROGRAM} | {@link GL20#GL_INFO_LOG_LENGTH INFO_LOG_LENGTH} | {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} |
| {@link GL40#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} | {@link GL40#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL41C#GL_ACTIVE_PROGRAM ACTIVE_PROGRAM} | {@link GL20#GL_INFO_LOG_LENGTH INFO_LOG_LENGTH} | {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} |
| {@link GL40#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} | {@link GL40#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
This extension provides a set of atomic counters.
+ * + *This extension provides GLSL built-in functions to query and increment/decrement these atomic counters.
+ * + *This enables a shader to write to unique offsets (append to a buffer object) or read from unique offsets (consume from a buffer object).
+ * + *Opaque handles to atomic counters are declared at global scope and are qualified with the uniform qualifier.
+ * + *Unlike other user-defined uniforms declared at global scope, they take NO storage from the default partition, they have NO location, and they may NOT be + * set with the Uniform* commands. Atomic counters may also NOT be grouped into uniform blocks.
+ * + *Active atomic counters can be discovered by the commands {@link GL31C#glGetUniformIndices GetUniformIndices}, {@link GL31C#glGetActiveUniformName GetActiveUniformName}, {@link GL20C#glGetActiveUniform GetActiveUniform} and + * {@link GL31C#glGetActiveUniformsiv GetActiveUniformsiv}.
+ * + *Like samplers, the opaque handles of the atomic counters and are ONLY used in some GLSL built-in functions.
+ * + *The atomic counters pointed to by the opaque handles are bound to buffer binding points and buffer offsets through the layout qualifiers in the shading + * language, or they are implicitly assigned by the compiler.
+ * + *Through the OpenGL API, buffer objects may be bound to these binding points with {@link GL30C#glBindBufferBase BindBufferBase} or {@link GL30C#glBindBufferRange BindBufferRange}.
+ * + *The contents of the atomic counters are stored in the buffer objects. The contents of atomic counters may be set and queried with buffer object + * manipulation functions (e.g. BufferData, BufferSubData, MapBuffer or MapBufferRange).
+ * + *Requires {@link GL30 OpenGL 3.0}. Promoted to core in {@link GL42 OpenGL 4.2}.
+ */ +public class ARBShaderAtomicCounters { + + /** Accepted by the {@code target} parameter of BindBufferBase and BindBufferRange. */ + public static final int GL_ATOMIC_COUNTER_BUFFER = 0x92C0; + + /** + * Accepted by the {@code pname} parameter of GetBooleani_v, GetIntegeri_v, GetFloati_v, GetDoublei_v, GetInteger64i_v, GetBooleanv, GetIntegerv, + * GetInteger64v, GetFloatv, GetDoublev, and GetActiveAtomicCounterBufferiv. + */ + public static final int GL_ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1; + + /** Accepted by the {@code pname} parameter of GetIntegeri_64v. */ + public static final int + GL_ATOMIC_COUNTER_BUFFER_START = 0x92C2, + GL_ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3; + + /** Accepted by the {@code pname} parameter of GetActiveAtomicCounterBufferiv. */ + public static final int + GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4, + GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5, + GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6, + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7, + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8, + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9, + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA, + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int + GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC, + GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD, + GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE, + GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF, + GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0, + GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1, + GL_MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2, + GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3, + GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4, + GL_MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5, + GL_MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6, + GL_MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7, + GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8, + GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC; + + /** Accepted by the {@code pname} parameter of GetProgramiv. */ + public static final int GL_ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9; + + /** Accepted by the {@code pname} parameter of GetActiveUniformsiv. */ + public static final int GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA; + + /** Returned in {@code params} by GetActiveUniform and GetActiveUniformsiv. */ + public static final int GL_UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB; + + static { GL.initialize(); } + + protected ARBShaderAtomicCounters() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetActiveAtomicCounterBufferiv + ); + } + + // --- [ glGetActiveAtomicCounterBufferiv ] --- + + /** Unsafe version of: {@link #glGetActiveAtomicCounterBufferiv GetActiveAtomicCounterBufferiv} */ + public static void nglGetActiveAtomicCounterBufferiv(int program, int bufferIndex, int pname, long params) { + GL42C.nglGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params); + } + + /** + * Obtains information about the set of active atomic counter buffers for a program. + * + * @param program the name of a program object for which the command {@link GL20C#glLinkProgram LinkProgram} has been issued in the past + * @param bufferIndex the index of an active atomic counter buffer + * @param pname the parameter to query. One of:| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE ATOMIC_COUNTER_BUFFER_DATA_SIZE} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE ATOMIC_COUNTER_BUFFER_DATA_SIZE} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER} |
This extension provides GLSL built-in functions allowing shaders to load from, store to, and perform atomic read-modify-write operations to a single + * level of a texture object from any shader stage. These built-in functions are named imageLoad(), imageStore(), and imageAtomic*(), respectively, and + * accept integer texel coordinates to identify the texel accessed. The extension adds the notion of "image units" to the OpenGL API, to which texture + * levels are bound for access by the GLSL built-in functions. To allow shaders to specify the image unit to access, GLSL provides a new set of data types + * ("image*") similar to samplers. Each image variable is assigned an integer value to identify an image unit to access, which is specified using + * Uniform*() APIs in a manner similar to samplers.
+ * + *This extension also provides the capability to explicitly enable "early" per-fragment tests, where operations like depth and stencil testing are + * performed prior to fragment shader execution. In unextended OpenGL, fragment shaders never have any side effects and implementations can sometimes + * perform per-fragment tests and discard some fragments prior to executing the fragment shader. Since this extension allows fragment shaders to write to + * texture and buffer object memory using the built-in image functions, such optimizations could lead to non-deterministic results. To avoid this, + * implementations supporting this extension may not perform such optimizations on shaders having such side effects. However, enabling early per-fragment + * tests guarantees that such tests will be performed prior to fragment shader execution, and ensures that image stores and atomics will not be performed + * by fragment shader invocations where these per-fragment tests fail.
+ * + *Finally, this extension provides both a GLSL built-in function and an OpenGL API function allowing applications some control over the ordering of image + * loads, stores, and atomics relative to other OpenGL pipeline operations accessing the same memory. Because the extension provides the ability to perform + * random accesses to texture or buffer object memory, such accesses are not easily tracked by the OpenGL driver. To avoid the need for heavy-handed + * synchronization at the driver level, this extension requires manual synchronization. The MemoryBarrier() OpenGL API function allows applications to + * specify a bitfield indicating the set of OpenGL API operations to synchronize relative to shader memory access. The memoryBarrier() GLSL built-in + * function provides a synchronization point within a given shader invocation to ensure that all memory accesses performed prior to the synchronization + * point complete prior to any started after the synchronization point.
+ * + *Requires {@link GL30 OpenGL 3.0} and GLSL 1.30. Promoted to core in {@link GL42 OpenGL 4.2}.
+ */ +public class ARBShaderImageLoadStore { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, GetDoublev, and GetInteger64v. */ + public static final int + GL_MAX_IMAGE_UNITS = 0x8F38, + GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39, + GL_MAX_IMAGE_SAMPLES = 0x906D, + GL_MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA, + GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB, + GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC, + GL_MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD, + GL_MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE, + GL_MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF; + + /** Accepted by the {@code target} parameter of GetIntegeri_v and GetBooleani_v. */ + public static final int + GL_IMAGE_BINDING_NAME = 0x8F3A, + GL_IMAGE_BINDING_LEVEL = 0x8F3B, + GL_IMAGE_BINDING_LAYERED = 0x8F3C, + GL_IMAGE_BINDING_LAYER = 0x8F3D, + GL_IMAGE_BINDING_ACCESS = 0x8F3E, + GL_IMAGE_BINDING_FORMAT = 0x906E; + + /** Accepted by the {@code barriers} parameter of MemoryBarrier. */ + public static final int + GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x1, + GL_ELEMENT_ARRAY_BARRIER_BIT = 0x2, + GL_UNIFORM_BARRIER_BIT = 0x4, + GL_TEXTURE_FETCH_BARRIER_BIT = 0x8, + GL_SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x20, + GL_COMMAND_BARRIER_BIT = 0x40, + GL_PIXEL_BUFFER_BARRIER_BIT = 0x80, + GL_TEXTURE_UPDATE_BARRIER_BIT = 0x100, + GL_BUFFER_UPDATE_BARRIER_BIT = 0x200, + GL_FRAMEBUFFER_BARRIER_BIT = 0x400, + GL_TRANSFORM_FEEDBACK_BARRIER_BIT = 0x800, + GL_ATOMIC_COUNTER_BARRIER_BIT = 0x1000, + GL_ALL_BARRIER_BITS = 0xFFFFFFFF; + + /** Returned by the {@code type} parameter of GetActiveUniform. */ + public static final int + GL_IMAGE_1D = 0x904C, + GL_IMAGE_2D = 0x904D, + GL_IMAGE_3D = 0x904E, + GL_IMAGE_2D_RECT = 0x904F, + GL_IMAGE_CUBE = 0x9050, + GL_IMAGE_BUFFER = 0x9051, + GL_IMAGE_1D_ARRAY = 0x9052, + GL_IMAGE_2D_ARRAY = 0x9053, + GL_IMAGE_CUBE_MAP_ARRAY = 0x9054, + GL_IMAGE_2D_MULTISAMPLE = 0x9055, + GL_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056, + GL_INT_IMAGE_1D = 0x9057, + GL_INT_IMAGE_2D = 0x9058, + GL_INT_IMAGE_3D = 0x9059, + GL_INT_IMAGE_2D_RECT = 0x905A, + GL_INT_IMAGE_CUBE = 0x905B, + GL_INT_IMAGE_BUFFER = 0x905C, + GL_INT_IMAGE_1D_ARRAY = 0x905D, + GL_INT_IMAGE_2D_ARRAY = 0x905E, + GL_INT_IMAGE_CUBE_MAP_ARRAY = 0x905F, + GL_INT_IMAGE_2D_MULTISAMPLE = 0x9060, + GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061, + GL_UNSIGNED_INT_IMAGE_1D = 0x9062, + GL_UNSIGNED_INT_IMAGE_2D = 0x9063, + GL_UNSIGNED_INT_IMAGE_3D = 0x9064, + GL_UNSIGNED_INT_IMAGE_2D_RECT = 0x9065, + GL_UNSIGNED_INT_IMAGE_CUBE = 0x9066, + GL_UNSIGNED_INT_IMAGE_BUFFER = 0x9067, + GL_UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068, + GL_UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069, + GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A, + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B, + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C; + + /** Accepted by the {@code value} parameter of GetTexParameteriv, GetTexParameterfv, GetTexParameterIiv, and GetTexParameterIuiv. */ + public static final int GL_IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7; + + /** + * Returned in the {@code data} parameter of GetTexParameteriv, GetTexParameterfv, GetTexParameterIiv, and GetTexParameterIuiv when {@code value} is + * IMAGE_FORMAT_COMPATIBILITY_TYPE. + */ + public static final int + GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8, + GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9; + + static { GL.initialize(); } + + protected ARBShaderImageLoadStore() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBindImageTexture, caps.glMemoryBarrier + ); + } + + // --- [ glBindImageTexture ] --- + + /** + * Binds a level of a texture to an image unit. + * + * @param unit the index of the image unit to which to bind the texture + * @param texture the name of the texture to bind to the image unit + * @param level the level of the texture that is to be bound + * @param layered whether a layered texture binding is to be established + * @param layer if {@code layered} is false, specifies the layer of texture to be bound to the image unit. Ignored otherwise. + * @param access a token indicating the type of access that will be performed on the image + * @param format the format that the elements of the image will be treated as for the purposes of formatted stores + */ + public static void glBindImageTexture(@NativeType("GLuint") int unit, @NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLboolean") boolean layered, @NativeType("GLint") int layer, @NativeType("GLenum") int access, @NativeType("GLenum") int format) { + GL42C.glBindImageTexture(unit, texture, level, layered, layer, access, format); + } + + // --- [ glMemoryBarrier ] --- + + /** + * Defines a barrier ordering memory transactions. + * + * @param barriers the barriers to insert (bitwise combination). One or more of:| {@link GL42C#GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT VERTEX_ATTRIB_ARRAY_BARRIER_BIT} | {@link GL42C#GL_ELEMENT_ARRAY_BARRIER_BIT ELEMENT_ARRAY_BARRIER_BIT} | {@link GL42C#GL_UNIFORM_BARRIER_BIT UNIFORM_BARRIER_BIT} |
| {@link GL42C#GL_TEXTURE_FETCH_BARRIER_BIT TEXTURE_FETCH_BARRIER_BIT} | {@link GL42C#GL_SHADER_IMAGE_ACCESS_BARRIER_BIT SHADER_IMAGE_ACCESS_BARRIER_BIT} | {@link GL42C#GL_COMMAND_BARRIER_BIT COMMAND_BARRIER_BIT} |
| {@link GL42C#GL_PIXEL_BUFFER_BARRIER_BIT PIXEL_BUFFER_BARRIER_BIT} | {@link GL42C#GL_TEXTURE_UPDATE_BARRIER_BIT TEXTURE_UPDATE_BARRIER_BIT} | {@link GL42C#GL_BUFFER_UPDATE_BARRIER_BIT BUFFER_UPDATE_BARRIER_BIT} |
| {@link GL42C#GL_FRAMEBUFFER_BARRIER_BIT FRAMEBUFFER_BARRIER_BIT} | {@link GL42C#GL_TRANSFORM_FEEDBACK_BARRIER_BIT TRANSFORM_FEEDBACK_BARRIER_BIT} | {@link GL42C#GL_ATOMIC_COUNTER_BARRIER_BIT ATOMIC_COUNTER_BARRIER_BIT} |
| {@link GL42C#GL_ALL_BARRIER_BITS ALL_BARRIER_BITS} | {@link GL43#GL_SHADER_STORAGE_BARRIER_BIT SHADER_STORAGE_BARRIER_BIT} |
This extension adds API calls that are necessary to manage shader objects and program objects as defined in the OpenGL 2.0 white papers by 3Dlabs.
+ * + *The generation of an executable that runs on one of OpenGL's programmable units is modeled to that of developing a typical C/C++ application. There are + * one or more source files, each of which are stored by OpenGL in a shader object. Each shader object (source file) needs to be compiled and attached to a + * program object. Once all shader objects are compiled successfully, the program object needs to be linked to produce an executable. This executable is + * part of the program object, and can now be loaded onto the programmable units to make it part of the current OpenGL state. Both the compile and link + * stages generate a text string that can be queried to get more information. This information could be, but is not limited to, compile errors, link errors, + * optimization hints, etc. Values for uniform variables, declared in a shader, can be set by the application and used to control a shader's behavior.
+ * + *This extension defines functions for creating shader objects and program objects, for compiling shader objects, for linking program objects, for + * attaching shader objects to program objects, and for using a program object as part of current state. Functions to load uniform values are also defined. + * Some house keeping functions, like deleting an object and querying object state, are also provided.
+ * + *Although this extension defines the API for creating shader objects, it does not define any specific types of shader objects. It is assumed that this + * extension will be implemented along with at least one such additional extension for creating a specific type of OpenGL 2.0 shader (e.g., the + * {@link ARBFragmentShader ARB_fragment_shader} extension or the {@link ARBVertexShader ARB_vertex_shader} extension).
+ * + *Promoted to core in {@link GL20 OpenGL 2.0}.
+ */ +public class ARBShaderObjects { + + /** Accepted by the {@code pname} argument of GetHandleARB. */ + public static final int GL_PROGRAM_OBJECT_ARB = 0x8B40; + + /** Accepted by the {@code pname} parameter of GetObjectParameter{fi}vARB. */ + public static final int + GL_OBJECT_TYPE_ARB = 0x8B4E, + GL_OBJECT_SUBTYPE_ARB = 0x8B4F, + GL_OBJECT_DELETE_STATUS_ARB = 0x8B80, + GL_OBJECT_COMPILE_STATUS_ARB = 0x8B81, + GL_OBJECT_LINK_STATUS_ARB = 0x8B82, + GL_OBJECT_VALIDATE_STATUS_ARB = 0x8B83, + GL_OBJECT_INFO_LOG_LENGTH_ARB = 0x8B84, + GL_OBJECT_ATTACHED_OBJECTS_ARB = 0x8B85, + GL_OBJECT_ACTIVE_UNIFORMS_ARB = 0x8B86, + GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 0x8B87, + GL_OBJECT_SHADER_SOURCE_LENGTH_ARB = 0x8B88; + + /** Returned by the {@code params} parameter of GetObjectParameter{fi}vARB. */ + public static final int GL_SHADER_OBJECT_ARB = 0x8B48; + + /** Returned by the {@code type} parameter of GetActiveUniformARB. */ + public static final int + GL_FLOAT_VEC2_ARB = 0x8B50, + GL_FLOAT_VEC3_ARB = 0x8B51, + GL_FLOAT_VEC4_ARB = 0x8B52, + GL_INT_VEC2_ARB = 0x8B53, + GL_INT_VEC3_ARB = 0x8B54, + GL_INT_VEC4_ARB = 0x8B55, + GL_BOOL_ARB = 0x8B56, + GL_BOOL_VEC2_ARB = 0x8B57, + GL_BOOL_VEC3_ARB = 0x8B58, + GL_BOOL_VEC4_ARB = 0x8B59, + GL_FLOAT_MAT2_ARB = 0x8B5A, + GL_FLOAT_MAT3_ARB = 0x8B5B, + GL_FLOAT_MAT4_ARB = 0x8B5C, + GL_SAMPLER_1D_ARB = 0x8B5D, + GL_SAMPLER_2D_ARB = 0x8B5E, + GL_SAMPLER_3D_ARB = 0x8B5F, + GL_SAMPLER_CUBE_ARB = 0x8B60, + GL_SAMPLER_1D_SHADOW_ARB = 0x8B61, + GL_SAMPLER_2D_SHADOW_ARB = 0x8B62, + GL_SAMPLER_2D_RECT_ARB = 0x8B63, + GL_SAMPLER_2D_RECT_SHADOW_ARB = 0x8B64; + + static { GL.initialize(); } + + protected ARBShaderObjects() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDeleteObjectARB, caps.glGetHandleARB, caps.glDetachObjectARB, caps.glCreateShaderObjectARB, caps.glShaderSourceARB, caps.glCompileShaderARB, + caps.glCreateProgramObjectARB, caps.glAttachObjectARB, caps.glLinkProgramARB, caps.glUseProgramObjectARB, caps.glValidateProgramARB, + caps.glUniform1fARB, caps.glUniform2fARB, caps.glUniform3fARB, caps.glUniform4fARB, caps.glUniform1iARB, caps.glUniform2iARB, caps.glUniform3iARB, + caps.glUniform4iARB, caps.glUniform1fvARB, caps.glUniform2fvARB, caps.glUniform3fvARB, caps.glUniform4fvARB, caps.glUniform1ivARB, + caps.glUniform2ivARB, caps.glUniform3ivARB, caps.glUniform4ivARB, caps.glUniformMatrix2fvARB, caps.glUniformMatrix3fvARB, + caps.glUniformMatrix4fvARB, caps.glGetObjectParameterfvARB, caps.glGetObjectParameterivARB, caps.glGetInfoLogARB, caps.glGetAttachedObjectsARB, + caps.glGetUniformLocationARB, caps.glGetActiveUniformARB, caps.glGetUniformfvARB, caps.glGetUniformivARB, caps.glGetShaderSourceARB + ); + } + + // --- [ glDeleteObjectARB ] --- + + /** + * Either deletes the object, or flags it for deletion. An object that is attached to a container object is not deleted until it is no longer attached to + * any container object, for any context. If it is still attached to at least one container object, the object is flagged for deletion. If the object is + * part of the current rendering state, it is not deleted until it is no longer part of the current rendering state for any context. If the object is still + * part of the rendering state of at least one context, it is flagged for deletion. + * + *If an object is flagged for deletion, its Boolean status bit {@link #GL_OBJECT_DELETE_STATUS_ARB OBJECT_DELETE_STATUS_ARB} is set to true.
+ * + *DeleteObjectARB will silently ignore the value zero.
+ * + *When a container object is deleted, it will detach each attached object as part of the deletion process. When an object is deleted, all information for + * the object referenced is lost. The data for the object is also deleted.
+ * + * @param obj the shader object to delete + */ + public static native void glDeleteObjectARB(@NativeType("GLhandleARB") int obj); + + // --- [ glGetHandleARB ] --- + + /** + * Returns the handle to an object that is in use as part of current state. + * + * @param pname the state item for which the current object is to be returned. Must be:| {@link #GL_PROGRAM_OBJECT_ARB PROGRAM_OBJECT_ARB} |
| {@link ARBVertexShader#GL_VERTEX_SHADER_ARB VERTEX_SHADER_ARB} | {@link ARBFragmentShader#GL_FRAGMENT_SHADER_ARB FRAGMENT_SHADER_ARB} |
The strings that are loaded into a shader object are expected to form the source code for a valid shader as defined in the OpenGL Shading Language + * Specification.
+ * + * @param shaderObj the shader object + * @param string an array of pointers to one or more, optionally null terminated, character strings that make up the source code + * @param length an array with the number of charARBs in each string (the string length). Each element in this array can be set to negative one (or smaller), + * indicating that its accompanying string is null terminated. If {@code length} is set to {@code NULL}, all strings in the {@code string} argument are + * considered null terminated. + */ + public static void glShaderSourceARB(@NativeType("GLhandleARB") int shaderObj, @NativeType("GLcharARB const **") PointerBuffer string, @Nullable @NativeType("GLint const *") IntBuffer length) { + if (CHECKS) { + checkSafe(length, string.remaining()); + } + nglShaderSourceARB(shaderObj, string.remaining(), memAddress(string), memAddressSafe(length)); + } + + /** + * Sets the source code for the specified shader object {@code shaderObj} to the text strings in the {@code string} array. If the object previously had + * source code loaded into it, it is completely replaced. + * + *The strings that are loaded into a shader object are expected to form the source code for a valid shader as defined in the OpenGL Shading Language + * Specification.
+ * + * @param shaderObj the shader object + * @param string an array of pointers to one or more, optionally null terminated, character strings that make up the source code + */ + public static void glShaderSourceARB(@NativeType("GLhandleARB") int shaderObj, @NativeType("GLcharARB const **") CharSequence... string) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + long stringAddress = org.lwjgl.system.APIUtil.apiArrayi(stack, MemoryUtil::memUTF8, string); + nglShaderSourceARB(shaderObj, string.length, stringAddress, stringAddress - (string.length << 2)); + org.lwjgl.system.APIUtil.apiArrayFree(stringAddress, string.length); + } finally { + stack.setPointer(stackPointer); + } + } + + /** + * Sets the source code for the specified shader object {@code shaderObj} to the text strings in the {@code string} array. If the object previously had + * source code loaded into it, it is completely replaced. + * + *The strings that are loaded into a shader object are expected to form the source code for a valid shader as defined in the OpenGL Shading Language + * Specification.
+ * + * @param shaderObj the shader object + * @param string an array of pointers to one or more, optionally null terminated, character strings that make up the source code + */ + public static void glShaderSourceARB(@NativeType("GLhandleARB") int shaderObj, @NativeType("GLcharARB const **") CharSequence string) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + long stringAddress = org.lwjgl.system.APIUtil.apiArrayi(stack, MemoryUtil::memUTF8, string); + nglShaderSourceARB(shaderObj, 1, stringAddress, stringAddress - 4); + org.lwjgl.system.APIUtil.apiArrayFree(stringAddress, 1); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glCompileShaderARB ] --- + + /** + * Compiles a shader object. Each shader object has a Boolean status, {@link #GL_OBJECT_COMPILE_STATUS_ARB OBJECT_COMPILE_STATUS_ARB}, that is modified as a result of compilation. This status + * can be queried with {@link #glGetObjectParameterivARB GetObjectParameterivARB}. This status will be set to {@link GL11#GL_TRUE TRUE} if the shader {@code shaderObj} was compiled without errors and is + * ready for use, and {@link GL11#GL_FALSE FALSE} otherwise. Compilation can fail for a variety of reasons as listed in the OpenGL Shading Language Specification. If + * CompileShaderARB failed, any information about a previous compile is lost and is not restored. Thus a failed compile does not restore the old state of + * {@code shaderObj}. If {@code shaderObj} does not reference a shader object, the error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated. + * + *Note that changing the source code of a shader object, through ShaderSourceARB, does not change its compile status {@link #GL_OBJECT_COMPILE_STATUS_ARB OBJECT_COMPILE_STATUS_ARB}.
+ * + *Each shader object has an information log that is modified as a result of compilation. This information log can be queried with {@link #glGetInfoLogARB GetInfoLogARB} to + * obtain more information about the compilation attempt.
+ * + * @param shaderObj the shader object to compile + */ + public static native void glCompileShaderARB(@NativeType("GLhandleARB") int shaderObj); + + // --- [ glCreateProgramObjectARB ] --- + + /** + * Creates a program object. + * + *A program object is a container object. Shader objects are attached to a program object with the command AttachObjectARB. It is permissible to attach + * shader objects to program objects before source code has been loaded into the shader object, or before the shader object has been compiled. It is + * permissible to attach multiple shader objects of the same type to a single program object, and it is permissible to attach a shader object to more than + * one program object.
+ */ + @NativeType("GLhandleARB") + public static native int glCreateProgramObjectARB(); + + // --- [ glAttachObjectARB ] --- + + /** + * Attaches an object to a container object. + * + * @param containerObj the container object + * @param obj the object to attach + */ + public static native void glAttachObjectARB(@NativeType("GLhandleARB") int containerObj, @NativeType("GLhandleARB") int obj); + + // --- [ glLinkProgramARB ] --- + + /** + * Links a program object. + * + *Each program object has a Boolean status, {@link #GL_OBJECT_LINK_STATUS_ARB OBJECT_LINK_STATUS_ARB}, that is modified as a result of linking. This status can be queried with + * {@link #glGetObjectParameterivARB GetObjectParameterivARB}. This status will be set to {@link GL11#GL_TRUE TRUE} if a valid executable is created, and {@link GL11#GL_FALSE FALSE} otherwise. Linking can fail for a + * variety of reasons as specified in the OpenGL Shading Language Specification. Linking will also fail if one or more of the shader objects, attached to + * {@code programObj}, are not compiled successfully, or if more active uniform or active sampler variables are used in {@code programObj} than allowed. + * If LinkProgramARB failed, any information about a previous link is lost and is not restored. Thus a failed link does not restore the old state of + * {@code programObj}. If {@code programObj} is not of type {@link #GL_PROGRAM_OBJECT_ARB PROGRAM_OBJECT_ARB}, the error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated.
+ * + *Each program object has an information log that is modified as a result of a link operation. This information log can be queried with {@link #glGetInfoLogARB GetInfoLogARB} + * to obtain more information about the link operation.
+ * + * @param programObj the program object to link + */ + public static native void glLinkProgramARB(@NativeType("GLhandleARB") int programObj); + + // --- [ glUseProgramObjectARB ] --- + + /** + * Installs the executable code as part of current rendering state if the program object {@code programObj} contains valid executable code, i.e. has been + * linked successfully. If UseProgramObjectARB is called with the handle set to 0, it is as if the GL had no programmable stages and the fixed + * functionality paths will be used instead. If {@code programObj} cannot be made part of the current rendering state, an {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error will + * be generated and the current rendering state left unmodified. This error will be set, for example, if {@code programObj} has not been linked + * successfully. If {@code programObj} is not of type {@link #GL_PROGRAM_OBJECT_ARB PROGRAM_OBJECT_ARB}, the error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated. + * + *While a program object is in use, applications are free to modify attached shader objects, compile attached shader objects, attach additional shader + * objects, and detach shader objects. This does not affect the link status {@link #GL_OBJECT_LINK_STATUS_ARB OBJECT_LINK_STATUS_ARB} of the program object. This does not affect the + * executable code that is part of the current state either. That executable code is only affected when the program object has been re-linked successfully. + * After such a successful re-link, the {@link #glLinkProgramARB LinkProgramARB} command will install the generated executable code as part of the current rendering state if the + * specified program object was already in use as a result of a previous call to UseProgramObjectARB. If this re-link failed, then the executable code part + * of the current state does not change.
+ * + * @param programObj the program object to use + */ + public static native void glUseProgramObjectARB(@NativeType("GLhandleARB") int programObj); + + // --- [ glValidateProgramARB ] --- + + /** + * Validates the program object {@code programObj} against the GL state at that moment. Each program object has a Boolean status, + * {@link #GL_OBJECT_VALIDATE_STATUS_ARB OBJECT_VALIDATE_STATUS_ARB}, that is modified as a result of validation. This status can be queried with {@link #glGetObjectParameterivARB GetObjectParameterivARB}. If validation + * succeeded this status will be set to {@link GL11#GL_TRUE TRUE}, otherwise it will be set to {@link GL11#GL_FALSE FALSE}. If validation succeeded the program object is guaranteed to + * execute, given the current GL state. If validation failed, the program object is guaranteed to not execute, given the current GL state. If + * {@code programObj} is not of type {@link #GL_PROGRAM_OBJECT_ARB PROGRAM_OBJECT_ARB}, the error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated. + * + *ValidateProgramARB will validate at least as much as is done when a rendering command is issued, and it could validate more. For example, it could give + * a hint on how to optimize some piece of shader code.
+ * + *ValidateProgramARB will store its information in the info log. This information will either be an empty string or it will contain validation information.
+ * + *ValidateProgramARB is typically only useful during application development. An application should not expect different OpenGL implementations to produce + * identical information.
+ * + * @param programObj the program object to validate + */ + public static native void glValidateProgramARB(@NativeType("GLhandleARB") int programObj); + + // --- [ glUniform1fARB ] --- + + /** + * float version of {@link #glUniform4fARB Uniform4fARB}. + * + * @param location the uniform variable location + * @param v0 the uniform x value + */ + public static native void glUniform1fARB(@NativeType("GLint") int location, @NativeType("GLfloat") float v0); + + // --- [ glUniform2fARB ] --- + + /** + * vec2 version of {@link #glUniform4fARB Uniform4fARB}. + * + * @param location the uniform variable location + * @param v0 the uniform x value + * @param v1 the uniform y value + */ + public static native void glUniform2fARB(@NativeType("GLint") int location, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1); + + // --- [ glUniform3fARB ] --- + + /** + * vec3 version of {@link #glUniform4fARB Uniform4fARB}. + * + * @param location the uniform variable location + * @param v0 the uniform x value + * @param v1 the uniform y value + * @param v2 the uniform z value + */ + public static native void glUniform3fARB(@NativeType("GLint") int location, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1, @NativeType("GLfloat") float v2); + + // --- [ glUniform4fARB ] --- + + /** + * Loads a vec4 value into a uniform variable of the program object that is currently in use. + * + * @param location the uniform variable location + * @param v0 the uniform x value + * @param v1 the uniform y value + * @param v2 the uniform z value + * @param v3 the uniform w value + */ + public static native void glUniform4fARB(@NativeType("GLint") int location, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1, @NativeType("GLfloat") float v2, @NativeType("GLfloat") float v3); + + // --- [ glUniform1iARB ] --- + + /** + * int version of {@link #glUniform1fARB Uniform1fARB}. + * + * @param location the uniform variable location + * @param v0 the uniform x value + */ + public static native void glUniform1iARB(@NativeType("GLint") int location, @NativeType("GLint") int v0); + + // --- [ glUniform2iARB ] --- + + /** + * ivec2 version of {@link #glUniform2fARB Uniform2fARB}. + * + * @param location the uniform variable location + * @param v0 the uniform x value + * @param v1 the uniform y value + */ + public static native void glUniform2iARB(@NativeType("GLint") int location, @NativeType("GLint") int v0, @NativeType("GLint") int v1); + + // --- [ glUniform3iARB ] --- + + /** + * ivec3 version of {@link #glUniform3fARB Uniform3fARB}. + * + * @param location the uniform variable location + * @param v0 the uniform x value + * @param v1 the uniform y value + * @param v2 the uniform z value + */ + public static native void glUniform3iARB(@NativeType("GLint") int location, @NativeType("GLint") int v0, @NativeType("GLint") int v1, @NativeType("GLint") int v2); + + // --- [ glUniform4iARB ] --- + + /** + * ivec4 version of {@link #glUniform4fARB Uniform4fARB}. + * + * @param location the uniform variable location + * @param v0 the uniform x value + * @param v1 the uniform y value + * @param v2 the uniform z value + * @param v3 the uniform w value + */ + public static native void glUniform4iARB(@NativeType("GLint") int location, @NativeType("GLint") int v0, @NativeType("GLint") int v1, @NativeType("GLint") int v2, @NativeType("GLint") int v3); + + // --- [ glUniform1fvARB ] --- + + /** + * Unsafe version of: {@link #glUniform1fvARB Uniform1fvARB} + * + * @param count the number of float values to load + */ + public static native void nglUniform1fvARB(int location, int count, long value); + + /** + * Loads floating-point values {@code count} times into a uniform location defined as an array of float values. + * + * @param location the uniform variable location + * @param value the values to load + */ + public static void glUniform1fvARB(@NativeType("GLint") int location, @NativeType("GLfloat const *") FloatBuffer value) { + nglUniform1fvARB(location, value.remaining(), memAddress(value)); + } + + // --- [ glUniform2fvARB ] --- + + /** + * Unsafe version of: {@link #glUniform2fvARB Uniform2fvARB} + * + * @param count the number of vec2 vectors to load + */ + public static native void nglUniform2fvARB(int location, int count, long value); + + /** + * Loads floating-point values {@code count} times into a uniform location defined as an array of vec2 vectors. + * + * @param location the uniform variable location + * @param value the values to load + */ + public static void glUniform2fvARB(@NativeType("GLint") int location, @NativeType("GLfloat const *") FloatBuffer value) { + nglUniform2fvARB(location, value.remaining() >> 1, memAddress(value)); + } + + // --- [ glUniform3fvARB ] --- + + /** + * Unsafe version of: {@link #glUniform3fvARB Uniform3fvARB} + * + * @param count the number of vec3 vectors to load + */ + public static native void nglUniform3fvARB(int location, int count, long value); + + /** + * Loads floating-point values {@code count} times into a uniform location defined as an array of vec3 vectors. + * + * @param location the uniform variable location + * @param value the values to load + */ + public static void glUniform3fvARB(@NativeType("GLint") int location, @NativeType("GLfloat const *") FloatBuffer value) { + nglUniform3fvARB(location, value.remaining() / 3, memAddress(value)); + } + + // --- [ glUniform4fvARB ] --- + + /** + * Unsafe version of: {@link #glUniform4fvARB Uniform4fvARB} + * + * @param count the number of vec4 vectors to load + */ + public static native void nglUniform4fvARB(int location, int count, long value); + + /** + * Loads floating-point values {@code count} times into a uniform location defined as an array of vec4 vectors. + * + * @param location the uniform variable location + * @param value the values to load + */ + public static void glUniform4fvARB(@NativeType("GLint") int location, @NativeType("GLfloat const *") FloatBuffer value) { + nglUniform4fvARB(location, value.remaining() >> 2, memAddress(value)); + } + + // --- [ glUniform1ivARB ] --- + + /** + * Unsafe version of: {@link #glUniform1ivARB Uniform1ivARB} + * + * @param count the number of integer values to load + */ + public static native void nglUniform1ivARB(int location, int count, long value); + + /** + * Loads integer values {@code count} times into a uniform location defined as an array of integer values. + * + * @param location the uniform variable location + * @param value the values to load + */ + public static void glUniform1ivARB(@NativeType("GLint") int location, @NativeType("GLint const *") IntBuffer value) { + nglUniform1ivARB(location, value.remaining(), memAddress(value)); + } + + // --- [ glUniform2ivARB ] --- + + /** + * Unsafe version of: {@link #glUniform2ivARB Uniform2ivARB} + * + * @param count the number of ivec2 vectors to load + */ + public static native void nglUniform2ivARB(int location, int count, long value); + + /** + * Loads integer values {@code count} times into a uniform location defined as an array of ivec2 vectors. + * + * @param location the uniform variable location + * @param value the values to load + */ + public static void glUniform2ivARB(@NativeType("GLint") int location, @NativeType("GLint const *") IntBuffer value) { + nglUniform2ivARB(location, value.remaining() >> 1, memAddress(value)); + } + + // --- [ glUniform3ivARB ] --- + + /** + * Unsafe version of: {@link #glUniform3ivARB Uniform3ivARB} + * + * @param count the number of ivec3 vectors to load + */ + public static native void nglUniform3ivARB(int location, int count, long value); + + /** + * Loads integer values {@code count} times into a uniform location defined as an array of ivec3 vectors. + * + * @param location the uniform variable location + * @param value the values to load + */ + public static void glUniform3ivARB(@NativeType("GLint") int location, @NativeType("GLint const *") IntBuffer value) { + nglUniform3ivARB(location, value.remaining() / 3, memAddress(value)); + } + + // --- [ glUniform4ivARB ] --- + + /** + * Unsafe version of: {@link #glUniform4ivARB Uniform4ivARB} + * + * @param count the number of ivec4 vectors to load + */ + public static native void nglUniform4ivARB(int location, int count, long value); + + /** + * Loads integer values {@code count} times into a uniform location defined as an array of ivec4 vectors. + * + * @param location the uniform variable location + * @param value the values to load + */ + public static void glUniform4ivARB(@NativeType("GLint") int location, @NativeType("GLint const *") IntBuffer value) { + nglUniform4ivARB(location, value.remaining() >> 2, memAddress(value)); + } + + // --- [ glUniformMatrix2fvARB ] --- + + /** + * Unsafe version of: {@link #glUniformMatrix2fvARB UniformMatrix2fvARB} + * + * @param count the number of 2x2 matrices to load + */ + public static native void nglUniformMatrix2fvARB(int location, int count, boolean transpose, long value); + + /** + * Loads a 2x2 matrix of floating-point values {@code count} times into a uniform location defined as a matrix or an array of matrices. + * + * @param location the uniform variable location + * @param transpose if {@link GL11#GL_FALSE FALSE}, the matrix is specified in column major order, otherwise in row major order + * @param value the matrix values to load + */ + public static void glUniformMatrix2fvARB(@NativeType("GLint") int location, @NativeType("GLboolean") boolean transpose, @NativeType("GLfloat const *") FloatBuffer value) { + nglUniformMatrix2fvARB(location, value.remaining() >> 2, transpose, memAddress(value)); + } + + // --- [ glUniformMatrix3fvARB ] --- + + /** + * Unsafe version of: {@link #glUniformMatrix3fvARB UniformMatrix3fvARB} + * + * @param count the number of 3x3 matrices to load + */ + public static native void nglUniformMatrix3fvARB(int location, int count, boolean transpose, long value); + + /** + * Loads a 3x3 matrix of floating-point values {@code count} times into a uniform location defined as a matrix or an array of matrices. + * + * @param location the uniform variable location + * @param transpose if {@link GL11#GL_FALSE FALSE}, the matrix is specified in column major order, otherwise in row major order + * @param value the matrix values to load + */ + public static void glUniformMatrix3fvARB(@NativeType("GLint") int location, @NativeType("GLboolean") boolean transpose, @NativeType("GLfloat const *") FloatBuffer value) { + nglUniformMatrix3fvARB(location, value.remaining() / 9, transpose, memAddress(value)); + } + + // --- [ glUniformMatrix4fvARB ] --- + + /** + * Unsafe version of: {@link #glUniformMatrix4fvARB UniformMatrix4fvARB} + * + * @param count the number of 4x4 matrices to load + */ + public static native void nglUniformMatrix4fvARB(int location, int count, boolean transpose, long value); + + /** + * Loads a 4x4 matrix of floating-point values {@code count} times into a uniform location defined as a matrix or an array of matrices. + * + * @param location the uniform variable location + * @param transpose if {@link GL11#GL_FALSE FALSE}, the matrix is specified in column major order, otherwise in row major order + * @param value the matrix values to load + */ + public static void glUniformMatrix4fvARB(@NativeType("GLint") int location, @NativeType("GLboolean") boolean transpose, @NativeType("GLfloat const *") FloatBuffer value) { + nglUniformMatrix4fvARB(location, value.remaining() >> 4, transpose, memAddress(value)); + } + + // --- [ glGetObjectParameterfvARB ] --- + + /** Unsafe version of: {@link #glGetObjectParameterfvARB GetObjectParameterfvARB} */ + public static native void nglGetObjectParameterfvARB(int obj, int pname, long params); + + /** + * Returns object specific parameter values. + * + * @param obj the object to query + * @param pname the parameter to query + * @param params a buffer in which to return the parameter value + */ + public static void glGetObjectParameterfvARB(@NativeType("GLhandleARB") int obj, @NativeType("GLenum") int pname, @NativeType("GLfloat *") FloatBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetObjectParameterfvARB(obj, pname, memAddress(params)); + } + + // --- [ glGetObjectParameterivARB ] --- + + /** Unsafe version of: {@link #glGetObjectParameterivARB GetObjectParameterivARB} */ + public static native void nglGetObjectParameterivARB(int obj, int pname, long params); + + /** + * Returns object specific parameter values. + * + * @param obj the object to query + * @param pname the parameter to query. One of:| {@link #GL_OBJECT_TYPE_ARB OBJECT_TYPE_ARB} | {@link #GL_OBJECT_SUBTYPE_ARB OBJECT_SUBTYPE_ARB} | {@link #GL_OBJECT_DELETE_STATUS_ARB OBJECT_DELETE_STATUS_ARB} |
| {@link #GL_OBJECT_COMPILE_STATUS_ARB OBJECT_COMPILE_STATUS_ARB} | {@link #GL_OBJECT_LINK_STATUS_ARB OBJECT_LINK_STATUS_ARB} | {@link #GL_OBJECT_VALIDATE_STATUS_ARB OBJECT_VALIDATE_STATUS_ARB} |
| {@link #GL_OBJECT_INFO_LOG_LENGTH_ARB OBJECT_INFO_LOG_LENGTH_ARB} | {@link #GL_OBJECT_ATTACHED_OBJECTS_ARB OBJECT_ATTACHED_OBJECTS_ARB} | {@link #GL_OBJECT_ACTIVE_UNIFORMS_ARB OBJECT_ACTIVE_UNIFORMS_ARB} |
| {@link #GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB} | {@link #GL_OBJECT_SHADER_SOURCE_LENGTH_ARB OBJECT_SHADER_SOURCE_LENGTH_ARB} |
| {@link #GL_OBJECT_TYPE_ARB OBJECT_TYPE_ARB} | {@link #GL_OBJECT_SUBTYPE_ARB OBJECT_SUBTYPE_ARB} | {@link #GL_OBJECT_DELETE_STATUS_ARB OBJECT_DELETE_STATUS_ARB} |
| {@link #GL_OBJECT_COMPILE_STATUS_ARB OBJECT_COMPILE_STATUS_ARB} | {@link #GL_OBJECT_LINK_STATUS_ARB OBJECT_LINK_STATUS_ARB} | {@link #GL_OBJECT_VALIDATE_STATUS_ARB OBJECT_VALIDATE_STATUS_ARB} |
| {@link #GL_OBJECT_INFO_LOG_LENGTH_ARB OBJECT_INFO_LOG_LENGTH_ARB} | {@link #GL_OBJECT_ATTACHED_OBJECTS_ARB OBJECT_ATTACHED_OBJECTS_ARB} | {@link #GL_OBJECT_ACTIVE_UNIFORMS_ARB OBJECT_ACTIVE_UNIFORMS_ARB} |
| {@link #GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB} | {@link #GL_OBJECT_SHADER_SOURCE_LENGTH_ARB OBJECT_SHADER_SOURCE_LENGTH_ARB} |
This string will be null terminated. The number of characters in the info log is given by {@link #GL_OBJECT_INFO_LOG_LENGTH_ARB OBJECT_INFO_LOG_LENGTH_ARB}, which can be queried with + * {@link #glGetObjectParameterivARB GetObjectParameterivARB}. If {@code obj} is a shader object, the returned info log will either be an empty string or it will contain + * information about the last compilation attempt for that object. If {@code obj} is a program object, the returned info log will either be an empty string + * or it will contain information about the last link attempt or last validation attempt for that object. If {@code obj} is not of type {@link #GL_PROGRAM_OBJECT_ARB PROGRAM_OBJECT_ARB} + * or {@link #GL_SHADER_OBJECT_ARB SHADER_OBJECT_ARB}, the error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated. If an error occurred, the return parameters {@code length} and {@code infoLog} + * will be unmodified.
+ * + *The info log is typically only useful during application development and an application should not expect different OpenGL implementations to produce + * identical info logs.
+ * + * @param obj the shader object to query + * @param length the actual number of characters written by the GL into {@code infoLog} is returned in {@code length}, excluding the null termination. If + * {@code length} is {@code NULL} then the GL ignores this parameter. + * @param infoLog a buffer in which to return the info log + */ + public static void glGetInfoLogARB(@NativeType("GLhandleARB") int obj, @Nullable @NativeType("GLsizei *") IntBuffer length, @NativeType("GLcharARB *") ByteBuffer infoLog) { + if (CHECKS) { + checkSafe(length, 1); + } + nglGetInfoLogARB(obj, infoLog.remaining(), memAddressSafe(length), memAddress(infoLog)); + } + + /** + * A string that contains information about the last link or validation attempt and last compilation attempt are kept per program or shader object. This + * string is called the info log and can be obtained with this command. + * + *This string will be null terminated. The number of characters in the info log is given by {@link #GL_OBJECT_INFO_LOG_LENGTH_ARB OBJECT_INFO_LOG_LENGTH_ARB}, which can be queried with + * {@link #glGetObjectParameterivARB GetObjectParameterivARB}. If {@code obj} is a shader object, the returned info log will either be an empty string or it will contain + * information about the last compilation attempt for that object. If {@code obj} is a program object, the returned info log will either be an empty string + * or it will contain information about the last link attempt or last validation attempt for that object. If {@code obj} is not of type {@link #GL_PROGRAM_OBJECT_ARB PROGRAM_OBJECT_ARB} + * or {@link #GL_SHADER_OBJECT_ARB SHADER_OBJECT_ARB}, the error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated. If an error occurred, the return parameters {@code length} and {@code infoLog} + * will be unmodified.
+ * + *The info log is typically only useful during application development and an application should not expect different OpenGL implementations to produce + * identical info logs.
+ * + * @param obj the shader object to query + * @param maxLength the maximum number of characters the GL is allowed to write into {@code infoLog} + */ + @NativeType("void") + public static String glGetInfoLogARB(@NativeType("GLhandleARB") int obj, @NativeType("GLsizei") int maxLength) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + ByteBuffer infoLog = memAlloc(maxLength); + try { + IntBuffer length = stack.ints(0); + nglGetInfoLogARB(obj, maxLength, memAddress(length), memAddress(infoLog)); + return memUTF8(infoLog, length.get(0)); + } finally { + memFree(infoLog); + stack.setPointer(stackPointer); + } + } + + /** + * A string that contains information about the last link or validation attempt and last compilation attempt are kept per program or shader object. This + * string is called the info log and can be obtained with this command. + * + *This string will be null terminated. The number of characters in the info log is given by {@link #GL_OBJECT_INFO_LOG_LENGTH_ARB OBJECT_INFO_LOG_LENGTH_ARB}, which can be queried with + * {@link #glGetObjectParameterivARB GetObjectParameterivARB}. If {@code obj} is a shader object, the returned info log will either be an empty string or it will contain + * information about the last compilation attempt for that object. If {@code obj} is a program object, the returned info log will either be an empty string + * or it will contain information about the last link attempt or last validation attempt for that object. If {@code obj} is not of type {@link #GL_PROGRAM_OBJECT_ARB PROGRAM_OBJECT_ARB} + * or {@link #GL_SHADER_OBJECT_ARB SHADER_OBJECT_ARB}, the error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated. If an error occurred, the return parameters {@code length} and {@code infoLog} + * will be unmodified.
+ * + *The info log is typically only useful during application development and an application should not expect different OpenGL implementations to produce + * identical info logs.
+ * + * @param obj the shader object to query + */ + @NativeType("void") + public static String glGetInfoLogARB(@NativeType("GLhandleARB") int obj) { + return glGetInfoLogARB(obj, glGetObjectParameteriARB(obj, GL_OBJECT_INFO_LOG_LENGTH_ARB)); + } + + // --- [ glGetAttachedObjectsARB ] --- + + /** + * Unsafe version of: {@link #glGetAttachedObjectsARB GetAttachedObjectsARB} + * + * @param maxCount the maximum number of handles the GL is allowed to write into {@code obj} + */ + public static native void nglGetAttachedObjectsARB(int containerObj, int maxCount, long count, long obj); + + /** + * Returns the handles of objects attached to {@code containerObj} in {@code obj}. . The number of objects attached to {@code containerObj} is given by + * {@link #GL_OBJECT_ATTACHED_OBJECTS_ARB OBJECT_ATTACHED_OBJECTS_ARB}, which can be queried with {@link #glGetObjectParameterivARB GetObjectParameterivARB}. If {@code containerObj} is not of type {@link #GL_PROGRAM_OBJECT_ARB PROGRAM_OBJECT_ARB}, the + * error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated. If an error occurred, the return parameters {@code count} and {@code obj} will be unmodified. + * + * @param containerObj the container object to query + * @param count a buffer in which to return the actual number of object handles written by the GL into {@code obj}. If {@code NULL} then the GL ignores this parameter. + * @param obj a buffer in which to return the attached object handles + */ + public static void glGetAttachedObjectsARB(@NativeType("GLhandleARB") int containerObj, @Nullable @NativeType("GLsizei *") IntBuffer count, @NativeType("GLhandleARB *") IntBuffer obj) { + if (CHECKS) { + checkSafe(count, 1); + } + nglGetAttachedObjectsARB(containerObj, obj.remaining(), memAddressSafe(count), memAddress(obj)); + } + + // --- [ glGetUniformLocationARB ] --- + + /** Unsafe version of: {@link #glGetUniformLocationARB GetUniformLocationARB} */ + public static native int nglGetUniformLocationARB(int programObj, long name); + + /** + * Returns the location of uniform variable {@code name}. {@code name} has to be a null terminated string, without white space. The value of -1 will be + * returned if {@code name} does not correspond to an active uniform variable name in {@code programObj} or if {@code name} starts with the reserved prefix + * "gl_". If {@code programObj} has not been successfully linked, or if {@code programObj} is not of type {@link #GL_PROGRAM_OBJECT_ARB PROGRAM_OBJECT_ARB}, the error + * {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated. The location of a uniform variable does not change until the next link command is issued. + * + *A valid {@code name} cannot be a structure, an array of structures, or a subcomponent of a vector or a matrix. In order to identify a valid {@code name}, + * the "." (dot) and "[]" operators can be used in {@code name} to operate on a structure or to operate on an array.
+ * + *The first element of a uniform array is identified using the name of the uniform array appended with "[0]". Except if the last part of the string + * {@code name} indicates a uniform array, then the location of the first element of that array can be retrieved by either using the name of the uniform + * array, or the name of the uniform array appended with "[0]".
+ * + * @param programObj the program object to query + * @param name the name of the uniform variable whose location is to be queried + */ + @NativeType("GLint") + public static int glGetUniformLocationARB(@NativeType("GLhandleARB") int programObj, @NativeType("GLcharARB const *") ByteBuffer name) { + if (CHECKS) { + checkNT1(name); + } + return nglGetUniformLocationARB(programObj, memAddress(name)); + } + + /** + * Returns the location of uniform variable {@code name}. {@code name} has to be a null terminated string, without white space. The value of -1 will be + * returned if {@code name} does not correspond to an active uniform variable name in {@code programObj} or if {@code name} starts with the reserved prefix + * "gl_". If {@code programObj} has not been successfully linked, or if {@code programObj} is not of type {@link #GL_PROGRAM_OBJECT_ARB PROGRAM_OBJECT_ARB}, the error + * {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated. The location of a uniform variable does not change until the next link command is issued. + * + *A valid {@code name} cannot be a structure, an array of structures, or a subcomponent of a vector or a matrix. In order to identify a valid {@code name}, + * the "." (dot) and "[]" operators can be used in {@code name} to operate on a structure or to operate on an array.
+ * + *The first element of a uniform array is identified using the name of the uniform array appended with "[0]". Except if the last part of the string + * {@code name} indicates a uniform array, then the location of the first element of that array can be retrieved by either using the name of the uniform + * array, or the name of the uniform array appended with "[0]".
+ * + * @param programObj the program object to query + * @param name the name of the uniform variable whose location is to be queried + */ + @NativeType("GLint") + public static int glGetUniformLocationARB(@NativeType("GLhandleARB") int programObj, @NativeType("GLcharARB const *") CharSequence name) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8(name, true); + long nameEncoded = stack.getPointerAddress(); + return nglGetUniformLocationARB(programObj, nameEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetActiveUniformARB ] --- + + /** + * Unsafe version of: {@link #glGetActiveUniformARB GetActiveUniformARB} + * + * @param maxLength the maximum number of characters the GL is allowed to write into {@code name}. + */ + public static native void nglGetActiveUniformARB(int programObj, int index, int maxLength, long length, long size, long type, long name); + + /** + * Determines which of the declared uniform variables are active and their sizes and types. + * + *This command provides information about the uniform selected by {@code index}. The {@code index} of 0 selects the first active uniform, and + * {@code index} of {@link #GL_OBJECT_ACTIVE_UNIFORMS_ARB OBJECT_ACTIVE_UNIFORMS_ARB} - 1 selects the last active uniform. The value of {@link #GL_OBJECT_ACTIVE_UNIFORMS_ARB OBJECT_ACTIVE_UNIFORMS_ARB} can be queried with + * {@link #glGetObjectParameterivARB GetObjectParameterivARB}. If {@code index} is greater than or equal to {@link #GL_OBJECT_ACTIVE_UNIFORMS_ARB OBJECT_ACTIVE_UNIFORMS_ARB}, the error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated.
+ * + *If an error occurred, the return parameters {@code length}, {@code size}, {@code type} and {@code name} will be unmodified.
+ * + *The returned uniform name can be the name of built-in uniform state as well. The length of the longest uniform name in {@code programObj} is given by + * {@link #GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB}, which can be queried with {@link #glGetObjectParameterivARB GetObjectParameterivARB}.
+ * + *Each uniform variable, declared in a shader, is broken down into one or more strings using the "." (dot) and "[]" operators, if necessary, to the point + * that it is legal to pass each string back into {@link #glGetUniformLocationARB GetUniformLocationARB}. Each of these strings constitutes one active uniform, and each string is + * assigned an index.
+ * + *If one or more elements of an array are active, GetActiveUniformARB will return the name of the array in {@code name}, subject to the restrictions + * listed above. The type of the array is returned in {@code type}. The {@code size} parameter contains the highest array element index used, plus one. The + * compiler or linker determines the highest index used. There will be only one active uniform reported by the GL per uniform array.
+ * + *This command will return as much information about active uniforms as possible. If no information is available, {@code length} will be set to zero and + * {@code name} will be an empty string. This situation could arise if GetActiveUniformARB is issued after a failed link.
+ * + * @param programObj a handle to a program object for which the command {@link #glLinkProgramARB LinkProgramARB} has been issued in the past. It is not necessary for {@code programObj} to have + * been linked successfully. The link could have failed because the number of active uniforms exceeded the limit. + * @param index the uniform index + * @param length a buffer in which to return the actual number of characters written by the GL into {@code name}. This count excludes the null termination. If + * {@code length} is {@code NULL} then the GL ignores this parameter. + * @param size a buffer in which to return the uniform size. The size is in units of the type returned in {@code type}. + * @param type a buffer in which to return the uniform type + * @param name a buffer in which to return the uniform name + */ + public static void glGetActiveUniformARB(@NativeType("GLhandleARB") int programObj, @NativeType("GLuint") int index, @Nullable @NativeType("GLsizei *") IntBuffer length, @NativeType("GLint *") IntBuffer size, @NativeType("GLenum *") IntBuffer type, @NativeType("GLcharARB *") ByteBuffer name) { + if (CHECKS) { + checkSafe(length, 1); + check(size, 1); + check(type, 1); + } + nglGetActiveUniformARB(programObj, index, name.remaining(), memAddressSafe(length), memAddress(size), memAddress(type), memAddress(name)); + } + + /** + * Determines which of the declared uniform variables are active and their sizes and types. + * + *This command provides information about the uniform selected by {@code index}. The {@code index} of 0 selects the first active uniform, and + * {@code index} of {@link #GL_OBJECT_ACTIVE_UNIFORMS_ARB OBJECT_ACTIVE_UNIFORMS_ARB} - 1 selects the last active uniform. The value of {@link #GL_OBJECT_ACTIVE_UNIFORMS_ARB OBJECT_ACTIVE_UNIFORMS_ARB} can be queried with + * {@link #glGetObjectParameterivARB GetObjectParameterivARB}. If {@code index} is greater than or equal to {@link #GL_OBJECT_ACTIVE_UNIFORMS_ARB OBJECT_ACTIVE_UNIFORMS_ARB}, the error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated.
+ * + *If an error occurred, the return parameters {@code length}, {@code size}, {@code type} and {@code name} will be unmodified.
+ * + *The returned uniform name can be the name of built-in uniform state as well. The length of the longest uniform name in {@code programObj} is given by + * {@link #GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB}, which can be queried with {@link #glGetObjectParameterivARB GetObjectParameterivARB}.
+ * + *Each uniform variable, declared in a shader, is broken down into one or more strings using the "." (dot) and "[]" operators, if necessary, to the point + * that it is legal to pass each string back into {@link #glGetUniformLocationARB GetUniformLocationARB}. Each of these strings constitutes one active uniform, and each string is + * assigned an index.
+ * + *If one or more elements of an array are active, GetActiveUniformARB will return the name of the array in {@code name}, subject to the restrictions + * listed above. The type of the array is returned in {@code type}. The {@code size} parameter contains the highest array element index used, plus one. The + * compiler or linker determines the highest index used. There will be only one active uniform reported by the GL per uniform array.
+ * + *This command will return as much information about active uniforms as possible. If no information is available, {@code length} will be set to zero and + * {@code name} will be an empty string. This situation could arise if GetActiveUniformARB is issued after a failed link.
+ * + * @param programObj a handle to a program object for which the command {@link #glLinkProgramARB LinkProgramARB} has been issued in the past. It is not necessary for {@code programObj} to have + * been linked successfully. The link could have failed because the number of active uniforms exceeded the limit. + * @param index the uniform index + * @param maxLength the maximum number of characters the GL is allowed to write into {@code name}. + * @param size a buffer in which to return the uniform size. The size is in units of the type returned in {@code type}. + * @param type a buffer in which to return the uniform type + */ + @NativeType("void") + public static String glGetActiveUniformARB(@NativeType("GLhandleARB") int programObj, @NativeType("GLuint") int index, @NativeType("GLsizei") int maxLength, @NativeType("GLint *") IntBuffer size, @NativeType("GLenum *") IntBuffer type) { + if (CHECKS) { + check(size, 1); + check(type, 1); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer length = stack.ints(0); + ByteBuffer name = stack.malloc(maxLength); + nglGetActiveUniformARB(programObj, index, maxLength, memAddress(length), memAddress(size), memAddress(type), memAddress(name)); + return memUTF8(name, length.get(0)); + } finally { + stack.setPointer(stackPointer); + } + } + + /** + * Determines which of the declared uniform variables are active and their sizes and types. + * + *This command provides information about the uniform selected by {@code index}. The {@code index} of 0 selects the first active uniform, and + * {@code index} of {@link #GL_OBJECT_ACTIVE_UNIFORMS_ARB OBJECT_ACTIVE_UNIFORMS_ARB} - 1 selects the last active uniform. The value of {@link #GL_OBJECT_ACTIVE_UNIFORMS_ARB OBJECT_ACTIVE_UNIFORMS_ARB} can be queried with + * {@link #glGetObjectParameterivARB GetObjectParameterivARB}. If {@code index} is greater than or equal to {@link #GL_OBJECT_ACTIVE_UNIFORMS_ARB OBJECT_ACTIVE_UNIFORMS_ARB}, the error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated.
+ * + *If an error occurred, the return parameters {@code length}, {@code size}, {@code type} and {@code name} will be unmodified.
+ * + *The returned uniform name can be the name of built-in uniform state as well. The length of the longest uniform name in {@code programObj} is given by + * {@link #GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB}, which can be queried with {@link #glGetObjectParameterivARB GetObjectParameterivARB}.
+ * + *Each uniform variable, declared in a shader, is broken down into one or more strings using the "." (dot) and "[]" operators, if necessary, to the point + * that it is legal to pass each string back into {@link #glGetUniformLocationARB GetUniformLocationARB}. Each of these strings constitutes one active uniform, and each string is + * assigned an index.
+ * + *If one or more elements of an array are active, GetActiveUniformARB will return the name of the array in {@code name}, subject to the restrictions + * listed above. The type of the array is returned in {@code type}. The {@code size} parameter contains the highest array element index used, plus one. The + * compiler or linker determines the highest index used. There will be only one active uniform reported by the GL per uniform array.
+ * + *This command will return as much information about active uniforms as possible. If no information is available, {@code length} will be set to zero and + * {@code name} will be an empty string. This situation could arise if GetActiveUniformARB is issued after a failed link.
+ * + * @param programObj a handle to a program object for which the command {@link #glLinkProgramARB LinkProgramARB} has been issued in the past. It is not necessary for {@code programObj} to have + * been linked successfully. The link could have failed because the number of active uniforms exceeded the limit. + * @param index the uniform index + * @param size a buffer in which to return the uniform size. The size is in units of the type returned in {@code type}. + * @param type a buffer in which to return the uniform type + */ + @NativeType("void") + public static String glGetActiveUniformARB(@NativeType("GLhandleARB") int programObj, @NativeType("GLuint") int index, @NativeType("GLint *") IntBuffer size, @NativeType("GLenum *") IntBuffer type) { + return glGetActiveUniformARB(programObj, index, glGetObjectParameteriARB(programObj, GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB), size, type); + } + + // --- [ glGetUniformfvARB ] --- + + /** Unsafe version of: {@link #glGetUniformfvARB GetUniformfvARB} */ + public static native void nglGetUniformfvARB(int programObj, int location, long params); + + /** + * Returns the floating-point value or values of a uniform. + * + * @param programObj the program object to query + * @param location the uniform variable location + * @param params a buffer in which to return the uniform values + */ + public static void glGetUniformfvARB(@NativeType("GLhandleARB") int programObj, @NativeType("GLint") int location, @NativeType("GLfloat *") FloatBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetUniformfvARB(programObj, location, memAddress(params)); + } + + /** + * Returns the floating-point value or values of a uniform. + * + * @param programObj the program object to query + * @param location the uniform variable location + */ + @NativeType("void") + public static float glGetUniformfARB(@NativeType("GLhandleARB") int programObj, @NativeType("GLint") int location) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + FloatBuffer params = stack.callocFloat(1); + nglGetUniformfvARB(programObj, location, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetUniformivARB ] --- + + /** Unsafe version of: {@link #glGetUniformivARB GetUniformivARB} */ + public static native void nglGetUniformivARB(int programObj, int location, long params); + + /** + * Returns the integer value or values of a uniform. + * + * @param programObj the program object to query + * @param location the uniform variable location + * @param params a buffer in which to return the uniform values + */ + public static void glGetUniformivARB(@NativeType("GLhandleARB") int programObj, @NativeType("GLint") int location, @NativeType("GLint *") IntBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetUniformivARB(programObj, location, memAddress(params)); + } + + /** + * Returns the integer value or values of a uniform. + * + * @param programObj the program object to query + * @param location the uniform variable location + */ + @NativeType("void") + public static int glGetUniformiARB(@NativeType("GLhandleARB") int programObj, @NativeType("GLint") int location) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer params = stack.callocInt(1); + nglGetUniformivARB(programObj, location, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetShaderSourceARB ] --- + + /** + * Unsafe version of: {@link #glGetShaderSourceARB GetShaderSourceARB} + * + * @param maxLength the maximum number of characters the GL is allowed to write into {@code source} + */ + public static native void nglGetShaderSourceARB(int obj, int maxLength, long length, long source); + + /** + * Returns the string making up the source code for a shader object. + * + *The string {@code source} is a concatenation of the strings passed to OpenGL using {@link #glShaderSourceARB ShaderSourceARB}. The length of this concatenation is given by + * {@link #GL_OBJECT_SHADER_SOURCE_LENGTH_ARB OBJECT_SHADER_SOURCE_LENGTH_ARB}, which can be queried with {@link #glGetObjectParameterivARB GetObjectParameterivARB}. If {@code obj} is not of type {@link #GL_SHADER_OBJECT_ARB SHADER_OBJECT_ARB}, the error + * {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated. If an error occurred, the return parameters {@code length} and {@code source} will be unmodified.
+ * + * @param obj the shader object to query + * @param length a buffer in which to return the actual number of characters written by the GL into {@code source}, excluding the null termination. If + * {@code length} is {@code NULL} then the GL ignores this parameter. + * @param source a buffer in which to return the shader object source + */ + public static void glGetShaderSourceARB(@NativeType("GLhandleARB") int obj, @Nullable @NativeType("GLsizei *") IntBuffer length, @NativeType("GLcharARB *") ByteBuffer source) { + if (CHECKS) { + checkSafe(length, 1); + } + nglGetShaderSourceARB(obj, source.remaining(), memAddressSafe(length), memAddress(source)); + } + + /** + * Returns the string making up the source code for a shader object. + * + *The string {@code source} is a concatenation of the strings passed to OpenGL using {@link #glShaderSourceARB ShaderSourceARB}. The length of this concatenation is given by + * {@link #GL_OBJECT_SHADER_SOURCE_LENGTH_ARB OBJECT_SHADER_SOURCE_LENGTH_ARB}, which can be queried with {@link #glGetObjectParameterivARB GetObjectParameterivARB}. If {@code obj} is not of type {@link #GL_SHADER_OBJECT_ARB SHADER_OBJECT_ARB}, the error + * {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated. If an error occurred, the return parameters {@code length} and {@code source} will be unmodified.
+ * + * @param obj the shader object to query + * @param maxLength the maximum number of characters the GL is allowed to write into {@code source} + */ + @NativeType("void") + public static String glGetShaderSourceARB(@NativeType("GLhandleARB") int obj, @NativeType("GLsizei") int maxLength) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + ByteBuffer source = memAlloc(maxLength); + try { + IntBuffer length = stack.ints(0); + nglGetShaderSourceARB(obj, maxLength, memAddress(length), memAddress(source)); + return memUTF8(source, length.get(0)); + } finally { + memFree(source); + stack.setPointer(stackPointer); + } + } + + /** + * Returns the string making up the source code for a shader object. + * + *The string {@code source} is a concatenation of the strings passed to OpenGL using {@link #glShaderSourceARB ShaderSourceARB}. The length of this concatenation is given by + * {@link #GL_OBJECT_SHADER_SOURCE_LENGTH_ARB OBJECT_SHADER_SOURCE_LENGTH_ARB}, which can be queried with {@link #glGetObjectParameterivARB GetObjectParameterivARB}. If {@code obj} is not of type {@link #GL_SHADER_OBJECT_ARB SHADER_OBJECT_ARB}, the error + * {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated. If an error occurred, the return parameters {@code length} and {@code source} will be unmodified.
+ * + * @param obj the shader object to query + */ + @NativeType("void") + public static String glGetShaderSourceARB(@NativeType("GLhandleARB") int obj) { + return glGetShaderSourceARB(obj, glGetObjectParameteriARB(obj, GL_OBJECT_SHADER_SOURCE_LENGTH_ARB)); + } + + /** Array version of: {@link #glShaderSourceARB ShaderSourceARB} */ + public static void glShaderSourceARB(@NativeType("GLhandleARB") int shaderObj, @NativeType("GLcharARB const **") PointerBuffer string, @Nullable @NativeType("GLint const *") int[] length) { + long __functionAddress = GL.getICD().glShaderSourceARB; + if (CHECKS) { + check(__functionAddress); + checkSafe(length, string.remaining()); + } + callPPV(shaderObj, string.remaining(), memAddress(string), length, __functionAddress); + } + + /** Array version of: {@link #glUniform1fvARB Uniform1fvARB} */ + public static void glUniform1fvARB(@NativeType("GLint") int location, @NativeType("GLfloat const *") float[] value) { + long __functionAddress = GL.getICD().glUniform1fvARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length, value, __functionAddress); + } + + /** Array version of: {@link #glUniform2fvARB Uniform2fvARB} */ + public static void glUniform2fvARB(@NativeType("GLint") int location, @NativeType("GLfloat const *") float[] value) { + long __functionAddress = GL.getICD().glUniform2fvARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length >> 1, value, __functionAddress); + } + + /** Array version of: {@link #glUniform3fvARB Uniform3fvARB} */ + public static void glUniform3fvARB(@NativeType("GLint") int location, @NativeType("GLfloat const *") float[] value) { + long __functionAddress = GL.getICD().glUniform3fvARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length / 3, value, __functionAddress); + } + + /** Array version of: {@link #glUniform4fvARB Uniform4fvARB} */ + public static void glUniform4fvARB(@NativeType("GLint") int location, @NativeType("GLfloat const *") float[] value) { + long __functionAddress = GL.getICD().glUniform4fvARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length >> 2, value, __functionAddress); + } + + /** Array version of: {@link #glUniform1ivARB Uniform1ivARB} */ + public static void glUniform1ivARB(@NativeType("GLint") int location, @NativeType("GLint const *") int[] value) { + long __functionAddress = GL.getICD().glUniform1ivARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length, value, __functionAddress); + } + + /** Array version of: {@link #glUniform2ivARB Uniform2ivARB} */ + public static void glUniform2ivARB(@NativeType("GLint") int location, @NativeType("GLint const *") int[] value) { + long __functionAddress = GL.getICD().glUniform2ivARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length >> 1, value, __functionAddress); + } + + /** Array version of: {@link #glUniform3ivARB Uniform3ivARB} */ + public static void glUniform3ivARB(@NativeType("GLint") int location, @NativeType("GLint const *") int[] value) { + long __functionAddress = GL.getICD().glUniform3ivARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length / 3, value, __functionAddress); + } + + /** Array version of: {@link #glUniform4ivARB Uniform4ivARB} */ + public static void glUniform4ivARB(@NativeType("GLint") int location, @NativeType("GLint const *") int[] value) { + long __functionAddress = GL.getICD().glUniform4ivARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length >> 2, value, __functionAddress); + } + + /** Array version of: {@link #glUniformMatrix2fvARB UniformMatrix2fvARB} */ + public static void glUniformMatrix2fvARB(@NativeType("GLint") int location, @NativeType("GLboolean") boolean transpose, @NativeType("GLfloat const *") float[] value) { + long __functionAddress = GL.getICD().glUniformMatrix2fvARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length >> 2, transpose, value, __functionAddress); + } + + /** Array version of: {@link #glUniformMatrix3fvARB UniformMatrix3fvARB} */ + public static void glUniformMatrix3fvARB(@NativeType("GLint") int location, @NativeType("GLboolean") boolean transpose, @NativeType("GLfloat const *") float[] value) { + long __functionAddress = GL.getICD().glUniformMatrix3fvARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length / 9, transpose, value, __functionAddress); + } + + /** Array version of: {@link #glUniformMatrix4fvARB UniformMatrix4fvARB} */ + public static void glUniformMatrix4fvARB(@NativeType("GLint") int location, @NativeType("GLboolean") boolean transpose, @NativeType("GLfloat const *") float[] value) { + long __functionAddress = GL.getICD().glUniformMatrix4fvARB; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length >> 4, transpose, value, __functionAddress); + } + + /** Array version of: {@link #glGetObjectParameterfvARB GetObjectParameterfvARB} */ + public static void glGetObjectParameterfvARB(@NativeType("GLhandleARB") int obj, @NativeType("GLenum") int pname, @NativeType("GLfloat *") float[] params) { + long __functionAddress = GL.getICD().glGetObjectParameterfvARB; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(obj, pname, params, __functionAddress); + } + + /** Array version of: {@link #glGetObjectParameterivARB GetObjectParameterivARB} */ + public static void glGetObjectParameterivARB(@NativeType("GLhandleARB") int obj, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] params) { + long __functionAddress = GL.getICD().glGetObjectParameterivARB; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(obj, pname, params, __functionAddress); + } + + /** Array version of: {@link #glGetInfoLogARB GetInfoLogARB} */ + public static void glGetInfoLogARB(@NativeType("GLhandleARB") int obj, @Nullable @NativeType("GLsizei *") int[] length, @NativeType("GLcharARB *") ByteBuffer infoLog) { + long __functionAddress = GL.getICD().glGetInfoLogARB; + if (CHECKS) { + check(__functionAddress); + checkSafe(length, 1); + } + callPPV(obj, infoLog.remaining(), length, memAddress(infoLog), __functionAddress); + } + + /** Array version of: {@link #glGetAttachedObjectsARB GetAttachedObjectsARB} */ + public static void glGetAttachedObjectsARB(@NativeType("GLhandleARB") int containerObj, @Nullable @NativeType("GLsizei *") int[] count, @NativeType("GLhandleARB *") int[] obj) { + long __functionAddress = GL.getICD().glGetAttachedObjectsARB; + if (CHECKS) { + check(__functionAddress); + checkSafe(count, 1); + } + callPPV(containerObj, obj.length, count, obj, __functionAddress); + } + + /** Array version of: {@link #glGetActiveUniformARB GetActiveUniformARB} */ + public static void glGetActiveUniformARB(@NativeType("GLhandleARB") int programObj, @NativeType("GLuint") int index, @Nullable @NativeType("GLsizei *") int[] length, @NativeType("GLint *") int[] size, @NativeType("GLenum *") int[] type, @NativeType("GLcharARB *") ByteBuffer name) { + long __functionAddress = GL.getICD().glGetActiveUniformARB; + if (CHECKS) { + check(__functionAddress); + checkSafe(length, 1); + check(size, 1); + check(type, 1); + } + callPPPPV(programObj, index, name.remaining(), length, size, type, memAddress(name), __functionAddress); + } + + /** Array version of: {@link #glGetUniformfvARB GetUniformfvARB} */ + public static void glGetUniformfvARB(@NativeType("GLhandleARB") int programObj, @NativeType("GLint") int location, @NativeType("GLfloat *") float[] params) { + long __functionAddress = GL.getICD().glGetUniformfvARB; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(programObj, location, params, __functionAddress); + } + + /** Array version of: {@link #glGetUniformivARB GetUniformivARB} */ + public static void glGetUniformivARB(@NativeType("GLhandleARB") int programObj, @NativeType("GLint") int location, @NativeType("GLint *") int[] params) { + long __functionAddress = GL.getICD().glGetUniformivARB; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(programObj, location, params, __functionAddress); + } + + /** Array version of: {@link #glGetShaderSourceARB GetShaderSourceARB} */ + public static void glGetShaderSourceARB(@NativeType("GLhandleARB") int obj, @Nullable @NativeType("GLsizei *") int[] length, @NativeType("GLcharARB *") ByteBuffer source) { + long __functionAddress = GL.getICD().glGetShaderSourceARB; + if (CHECKS) { + check(__functionAddress); + checkSafe(length, 1); + } + callPPV(obj, source.remaining(), length, memAddress(source), __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBShaderStorageBufferObject.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBShaderStorageBufferObject.java new file mode 100644 index 00000000..9990a51d --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBShaderStorageBufferObject.java @@ -0,0 +1,96 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_shader_storage_buffer_object extension. + * + *This extension provides the ability for OpenGL shaders to perform random access reads, writes, and atomic memory operations on variables stored in a + * buffer object. Application shader code can declare sets of variables (referred to as "buffer variables") arranged into interface blocks in a manner + * similar to that done with uniform blocks in OpenGL 3.1. In both cases, the values of the variables declared in a given interface block are taken from a + * buffer object bound to a binding point associated with the block. Buffer objects used in this extension are referred to as "shader storage buffers".
+ * + *While the capability provided by this extension is similar to that provided by OpenGL 3.1 and {@link ARBUniformBufferObject ARB_uniform_buffer_object}, there are several + * significant differences. Most importantly, shader code is allowed to write to shader storage buffers, while uniform buffers are always read-only. Shader + * storage buffers have a separate set of binding points, with different counts and size limits. The maximum usable size for shader storage buffers is + * implementation-dependent, but its minimum value is substantially larger than the minimum for uniform buffers.
+ * + *The ability to write to buffer objects creates the potential for multiple independent shader invocations to read and write the same underlying memory. + * The same issue exists with the {@link ARBShaderImageLoadStore ARB_shader_image_load_store} extension provided in OpenGL 4.2, which can write to texture objects and buffers. In + * both cases, the specification makes few guarantees related to the relative order of memory reads and writes performed by the shader invocations. For + * ARB_shader_image_load_store, the OpenGL API and shading language do provide some control over memory transactions; those mechanisms also affect reads + * and writes of shader storage buffers. In the OpenGL API, the {@link GL42C#glMemoryBarrier MemoryBarrier} call can be used to ensure that certain memory operations related to + * commands issued prior the barrier complete before other operations related to commands issued after the barrier. Additionally, the shading language + * provides the {@code memoryBarrier()} function to control the relative order of memory accesses within individual shader invocations and provides + * various memory qualifiers controlling how the memory corresponding to individual variables is accessed.
+ * + *Requires {@link GL40 OpenGL 4.0} and {@link GL43 OpenGL 4.3} or {@link ARBProgramInterfaceQuery ARB_program_interface_query}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public class ARBShaderStorageBufferObject { + + /** Accepted by the {@code target} parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, and GetBufferPointerv. */ + public static final int GL_SHADER_STORAGE_BUFFER = 0x90D2; + + /** + * Accepted by the {@code pname} parameter of GetIntegerv, GetIntegeri_v, GetBooleanv, GetInteger64v, GetFloatv, GetDoublev, GetBooleani_v, GetIntegeri_v, + * GetFloati_v, GetDoublei_v, and GetInteger64i_v. + */ + public static final int GL_SHADER_STORAGE_BUFFER_BINDING = 0x90D3; + + /** Accepted by the {@code pname} parameter of GetIntegeri_v, GetBooleani_v, GetIntegeri_v, GetFloati_v, GetDoublei_v, and GetInteger64i_v. */ + public static final int + GL_SHADER_STORAGE_BUFFER_START = 0x90D4, + GL_SHADER_STORAGE_BUFFER_SIZE = 0x90D5; + + /** Accepted by the {@code pname} parameter of GetIntegerv, GetBooleanv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int + GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6, + GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7, + GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8, + GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9, + GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA, + GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB, + GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC, + GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD, + GL_MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE, + GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF; + + /** Accepted in the {@code barriers} bitfield in glMemoryBarrier. */ + public static final int GL_SHADER_STORAGE_BARRIER_BIT = 0x2000; + + /** Also, add a new alias for the existing token MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS. */ + public static final int GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39; + + static { GL.initialize(); } + + protected ARBShaderStorageBufferObject() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glShaderStorageBlockBinding + ); + } + + // --- [ glShaderStorageBlockBinding ] --- + + /** + * Changes an active shader storage block binding. + * + * @param program the name of the program containing the block whose binding to change + * @param storageBlockIndex the index storage block within the program + * @param storageBlockBinding the index storage block binding to associate with the specified storage block + */ + public static void glShaderStorageBlockBinding(@NativeType("GLuint") int program, @NativeType("GLuint") int storageBlockIndex, @NativeType("GLuint") int storageBlockBinding) { + GL43C.glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBShaderSubroutine.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBShaderSubroutine.java new file mode 100644 index 00000000..37cf3f52 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBShaderSubroutine.java @@ -0,0 +1,371 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_shader_subroutine extension. + * + *This extension adds support to shaders for "indirect subroutine calls", where a single shader can include many subroutines and dynamically select + * through the API which subroutine is called from each call site. Switching subroutines dynamically in this fashion can avoid the cost of recompiling and + * managing multiple shaders, while still retaining most of the performance of specialized shaders.
+ * + *Requires {@link ARBGPUShader5 ARB_gpu_shader5}. Promoted to core in {@link GL40 OpenGL 4.0}.
+ */ +public class ARBShaderSubroutine { + + /** Accepted by the {@code pname} parameter of GetProgramStageiv. */ + public static final int + GL_ACTIVE_SUBROUTINES = 0x8DE5, + GL_ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6, + GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47, + GL_ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48, + GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, GetDoublev, and GetInteger64v. */ + public static final int + GL_MAX_SUBROUTINES = 0x8DE7, + GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8; + + /** Accepted by the {@code pname} parameter of GetActiveSubroutineUniformiv. */ + public static final int + GL_NUM_COMPATIBLE_SUBROUTINES = 0x8E4A, + GL_COMPATIBLE_SUBROUTINES = 0x8E4B; + + static { GL.initialize(); } + + protected ARBShaderSubroutine() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetSubroutineUniformLocation, caps.glGetSubroutineIndex, caps.glGetActiveSubroutineUniformiv, caps.glGetActiveSubroutineUniformName, + caps.glGetActiveSubroutineName, caps.glUniformSubroutinesuiv, caps.glGetUniformSubroutineuiv, caps.glGetProgramStageiv + ); + } + + // --- [ glGetSubroutineUniformLocation ] --- + + /** Unsafe version of: {@link #glGetSubroutineUniformLocation GetSubroutineUniformLocation} */ + public static int nglGetSubroutineUniformLocation(int program, int shadertype, long name) { + return GL40C.nglGetSubroutineUniformLocation(program, shadertype, name); + } + + /** + * Retrieves the location of a subroutine uniform of a given shader stage within a program. + * + * @param program the name of the program containing shader stage + * @param shadertype the shader stage from which to query for subroutine uniform index. One of:| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL40C#GL_NUM_COMPATIBLE_SUBROUTINES NUM_COMPATIBLE_SUBROUTINES} | {@link GL40C#GL_COMPATIBLE_SUBROUTINES COMPATIBLE_SUBROUTINES} | {@link GL31#GL_UNIFORM_SIZE UNIFORM_SIZE} | {@link GL31#GL_UNIFORM_NAME_LENGTH UNIFORM_NAME_LENGTH} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL40C#GL_NUM_COMPATIBLE_SUBROUTINES NUM_COMPATIBLE_SUBROUTINES} | {@link GL40C#GL_COMPATIBLE_SUBROUTINES COMPATIBLE_SUBROUTINES} | {@link GL31#GL_UNIFORM_SIZE UNIFORM_SIZE} | {@link GL31#GL_UNIFORM_NAME_LENGTH UNIFORM_NAME_LENGTH} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL40C#GL_ACTIVE_SUBROUTINES ACTIVE_SUBROUTINES} | {@link GL40C#GL_ACTIVE_SUBROUTINE_UNIFORMS ACTIVE_SUBROUTINE_UNIFORMS} |
| {@link GL40C#GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS} | {@link GL40C#GL_ACTIVE_SUBROUTINE_MAX_LENGTH ACTIVE_SUBROUTINE_MAX_LENGTH} |
| {@link GL40C#GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL40C#GL_ACTIVE_SUBROUTINES ACTIVE_SUBROUTINES} | {@link GL40C#GL_ACTIVE_SUBROUTINE_UNIFORMS ACTIVE_SUBROUTINE_UNIFORMS} |
| {@link GL40C#GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS} | {@link GL40C#GL_ACTIVE_SUBROUTINE_MAX_LENGTH ACTIVE_SUBROUTINE_MAX_LENGTH} |
| {@link GL40C#GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH} |
This extension indicates that the OpenGL Shading Language is supported.
+ * + *Requires {@link ARBShaderObjects ARB_shader_objects}, {@link ARBFragmentShader ARB_fragment_shader} and {@link ARBVertexShader ARB_vertex_shader}. Promoted to core in {@link GL20 OpenGL 2.0}.
+ */ +public final class ARBShadingLanguage100 { + + /** Accepted by the {@code name} parameter of GetString. */ + public static final int GL_SHADING_LANGUAGE_VERSION_ARB = 0x8B8C; + + private ARBShadingLanguage100() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBShadingLanguageInclude.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBShadingLanguageInclude.java new file mode 100644 index 00000000..babedfb7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBShadingLanguageInclude.java @@ -0,0 +1,446 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the ARB_shading_language_include extension. + * + *This extension introduces a {@code #include} GLSL directive to allow reusing the same shader text in multiple shaders and defines the semantics and syntax of + * the names allowed in {@code #include} directives. It also defines API mechanisms to define the named string backing a {@code #include}.
+ * + *The GLSL {@code #include} mechanism looks up paths in a tree built through the OpenGL API. This appendix describes the syntax and semantic model of the tree and + * paths into the tree. How the tree is used is up to users of the tree, like the OpenGL API or GLSL.
+ * + *The tree is a singly rooted hierarchy of tree locations. The root may have one or more child locations, and any location may in turn have its own + * children. Except for the root, each location has exactly one parent; the root has no parent.
+ * + *The locations in the tree are created or looked up by path strings. The path string "/" locates the root of the tree. The path "/foo" locates the child + * "foo" of the root. Formally, a valid path is a sequence of tokens delimited by the beginning of the string, by the path-separator forward slash ( / ), + * and by the end of the string. The string "foo/bar" has two tokens; "foo" and "bar". The string "/foo/./bar" has 3 tokens; "foo", ".", and "bar". The + * string "/foo/.." has two tokens; "foo" and "..". The string "/foo/.bar" has two tokens; "foo" and ".bar". A path is invalid if
+ * + *There are no path escape characters, so there is no way to get the forward slash delimiter within a single token.
+ * + *When using a path to lookup a tree location, the path tokens are used to walk the tree. The initial location to start the walk is specified by the user + * of the tree and is updated as follows by the tokens in the path. (Paths starting with "/" will start at the root.) Taken left to right:
+ * + *The token ".." walks to the parent. Or, if already at the root, then the location remains at the root.
+ * + *The token "." leaves the location unchanged.
+ * + *Any other token is considered the name of a child of the current location, and walks to that child. (If there is no child of that name, this may result + * in a failed lookup or in the child being created, as specified by the user of the tree for the operation being performed.)
+ * + *Each location in the tree can have an additional string associated with it (that a user like the {@code #include} mechanism can use as an included string). This + * is true even for locations that have children: "/foo/bar" can exist in the tree at the same time that "/foo" has an additional string associated with + * it. Typically, when a path is used to find a location in the tree, it is for the purpose of returning this associated string.
+ * + *Hence, the tree can be built from a collection of (path,string) pairs, where path is a string establishing the existence of a location in the tree and + * string is the string associated with the node. Details of how to do this are specified by the user of the tree.
+ * + *Requires GLSL 1.10.
+ */ +public class ARBShadingLanguageInclude { + + /** Accepted by the {@code type} parameter of NamedStringARB. */ + public static final int GL_SHADER_INCLUDE_ARB = 0x8DAE; + + /** Accepted by the {@code pname} parameter of GetNamedStringivARB. */ + public static final int + GL_NAMED_STRING_LENGTH_ARB = 0x8DE9, + GL_NAMED_STRING_TYPE_ARB = 0x8DEA; + + static { GL.initialize(); } + + protected ARBShadingLanguageInclude() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glNamedStringARB, caps.glDeleteNamedStringARB, caps.glCompileShaderIncludeARB, caps.glIsNamedStringARB, caps.glGetNamedStringARB, + caps.glGetNamedStringivARB + ); + } + + // --- [ glNamedStringARB ] --- + + /** + * Unsafe version of: {@link #glNamedStringARB NamedStringARB} + * + * @param namelen the number of characters in {@code name}. If negative, {@code name} is considered to be a null-terminated string. + * @param stringlen the number of characters in {@code string}. If negative, {@code string} is considered to be a null-terminated string. + */ + public static native void nglNamedStringARB(int type, int namelen, long name, int stringlen, long string); + + /** + * Specifies a string and its name. Such strings can be included by name in shaders during compilation, allowing reuse of the same code segments. + * + *After calling NamedStringARB, the contents of {@code string} are associated with the tree location corresponding to {@code name}. If a string is already + * associated with that tree location, it will be replaced with the new {@code string}.
+ * + * @param type the string type. Must be:| {@link #GL_SHADER_INCLUDE_ARB SHADER_INCLUDE_ARB} |
After calling NamedStringARB, the contents of {@code string} are associated with the tree location corresponding to {@code name}. If a string is already + * associated with that tree location, it will be replaced with the new {@code string}.
+ * + * @param type the string type. Must be:| {@link #GL_SHADER_INCLUDE_ARB SHADER_INCLUDE_ARB} |
The ordered list of {@code path}s is used during compilation, together with the arguments of {@code #include} directives in the shader source, to search for + * named strings corresponding to the {@code #include} directives. If a {@code #include} directive does not correspond to a valid named string, compilation will fail.
+ * + * @param shader the shader object compile + * @param path an ordered array of {@code count} pointers to optionally null-terminated character strings defining search paths + * @param length an array {@code count} values with the number of characters in each string (the string length). If an element in {@code length} is negative, its + * accompanying string is null-terminated. If {@code length} is {@code NULL}, all strings in the {@code path} argument are considered null-terminated. + */ + public static void glCompileShaderIncludeARB(@NativeType("GLuint") int shader, @NativeType("GLchar const * const *") PointerBuffer path, @Nullable @NativeType("GLint const *") IntBuffer length) { + if (CHECKS) { + checkSafe(length, path.remaining()); + } + nglCompileShaderIncludeARB(shader, path.remaining(), memAddress(path), memAddressSafe(length)); + } + + // --- [ glIsNamedStringARB ] --- + + /** + * Unsafe version of: {@link #glIsNamedStringARB IsNamedStringARB} + * + * @param namelen the number of characters in {@code name}. If negative, {@code name} is considered to be a null-terminated string. + */ + public static native boolean nglIsNamedStringARB(int namelen, long name); + + /** + * Returns {@link GL11#GL_TRUE TRUE} if the tree location corresponding to {@code name} has a string associated with it, and {@link GL11#GL_FALSE FALSE} if the tree location has no string + * associated with it. + * + * @param name the name associated with the string + */ + @NativeType("GLboolean") + public static boolean glIsNamedStringARB(@NativeType("GLchar const *") ByteBuffer name) { + return nglIsNamedStringARB(name.remaining(), memAddress(name)); + } + + /** + * Returns {@link GL11#GL_TRUE TRUE} if the tree location corresponding to {@code name} has a string associated with it, and {@link GL11#GL_FALSE FALSE} if the tree location has no string + * associated with it. + * + * @param name the name associated with the string + */ + @NativeType("GLboolean") + public static boolean glIsNamedStringARB(@NativeType("GLchar const *") CharSequence name) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + int nameEncodedLength = stack.nASCII(name, false); + long nameEncoded = stack.getPointerAddress(); + return nglIsNamedStringARB(nameEncodedLength, nameEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetNamedStringARB ] --- + + /** + * Unsafe version of: {@link #glGetNamedStringARB GetNamedStringARB} + * + * @param namelen the number of characters in {@code name}. If negative, {@code name} is considered to be a null-terminated string. + * @param bufSize the maximum number of characters that may be written into {@code string}, including the null terminator + */ + public static native void nglGetNamedStringARB(int namelen, long name, int bufSize, long stringlen, long string); + + /** + * Returns in {@code string} the string corresponding to the specified {@code name}. The returned string will be null-terminated. + * + * @param name the name associated with the string + * @param stringlen a buffer in which to place the actual number of characters written into {@code string}, excluding the null terminator. If {@code NULL}, no length is + * returned. + * @param string a buffer in which to place the returned string + */ + public static void glGetNamedStringARB(@NativeType("GLchar const *") ByteBuffer name, @Nullable @NativeType("GLint *") IntBuffer stringlen, @NativeType("GLchar *") ByteBuffer string) { + if (CHECKS) { + checkSafe(stringlen, 1); + } + nglGetNamedStringARB(name.remaining(), memAddress(name), string.remaining(), memAddressSafe(stringlen), memAddress(string)); + } + + /** + * Returns in {@code string} the string corresponding to the specified {@code name}. The returned string will be null-terminated. + * + * @param name the name associated with the string + * @param stringlen a buffer in which to place the actual number of characters written into {@code string}, excluding the null terminator. If {@code NULL}, no length is + * returned. + * @param string a buffer in which to place the returned string + */ + public static void glGetNamedStringARB(@NativeType("GLchar const *") CharSequence name, @Nullable @NativeType("GLint *") IntBuffer stringlen, @NativeType("GLchar *") ByteBuffer string) { + if (CHECKS) { + checkSafe(stringlen, 1); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + int nameEncodedLength = stack.nASCII(name, false); + long nameEncoded = stack.getPointerAddress(); + nglGetNamedStringARB(nameEncodedLength, nameEncoded, string.remaining(), memAddressSafe(stringlen), memAddress(string)); + } finally { + stack.setPointer(stackPointer); + } + } + + /** + * Returns in {@code string} the string corresponding to the specified {@code name}. The returned string will be null-terminated. + * + * @param name the name associated with the string + * @param bufSize the maximum number of characters that may be written into {@code string}, including the null terminator + */ + @NativeType("void") + public static String glGetNamedStringARB(@NativeType("GLchar const *") CharSequence name, @NativeType("GLsizei") int bufSize) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + int nameEncodedLength = stack.nASCII(name, false); + long nameEncoded = stack.getPointerAddress(); + IntBuffer stringlen = stack.ints(0); + ByteBuffer string = stack.malloc(bufSize); + nglGetNamedStringARB(nameEncodedLength, nameEncoded, bufSize, memAddress(stringlen), memAddress(string)); + return memUTF8(string, stringlen.get(0)); + } finally { + stack.setPointer(stackPointer); + } + } + + /** + * Returns in {@code string} the string corresponding to the specified {@code name}. The returned string will be null-terminated. + * + * @param name the name associated with the string + */ + @NativeType("void") + public static String glGetNamedStringARB(@NativeType("GLchar const *") CharSequence name) { + return glGetNamedStringARB(name, glGetNamedStringiARB(name, GL_NAMED_STRING_LENGTH_ARB)); + } + + // --- [ glGetNamedStringivARB ] --- + + /** + * Unsafe version of: {@link #glGetNamedStringivARB GetNamedStringivARB} + * + * @param namelen the number of characters in {@code name}. If negative, {@code name} is considered to be a null-terminated string. + */ + public static native void nglGetNamedStringivARB(int namelen, long name, int pname, long params); + + /** + * Returns properties of the named string whose tree location corresponds to {@code name}. + * + * @param name the name associated with the string + * @param pname the parameter to query. One of:| {@link #GL_NAMED_STRING_LENGTH_ARB NAMED_STRING_LENGTH_ARB} | {@link #GL_NAMED_STRING_TYPE_ARB NAMED_STRING_TYPE_ARB} |
| {@link #GL_NAMED_STRING_LENGTH_ARB NAMED_STRING_LENGTH_ARB} | {@link #GL_NAMED_STRING_TYPE_ARB NAMED_STRING_TYPE_ARB} |
| {@link #GL_NAMED_STRING_LENGTH_ARB NAMED_STRING_LENGTH_ARB} | {@link #GL_NAMED_STRING_TYPE_ARB NAMED_STRING_TYPE_ARB} |
This extension supports comparing the texture R coordinate to a depth texture value in order to produce a boolean texture value. This can be used to + * implement shadow maps.
+ * + *The extension is written in generic terms such that other texture comparison modes can be accommodated in the future.
+ * + *Requires {@link ARBDepthTexture ARB_depth_texture}. Promoted to core in {@link GL14 OpenGL 1.4}.
+ */ +public final class ARBShadow { + + /** Accepted by the {@code pname} parameter of TexParameterf, TexParameteri, TexParameterfv, TexParameteriv, GetTexParameterfv, and GetTexParameteriv. */ + public static final int + GL_TEXTURE_COMPARE_MODE_ARB = 0x884C, + GL_TEXTURE_COMPARE_FUNC_ARB = 0x884D; + + /** + * Accepted by the {@code param} parameter of TexParameterf, TexParameteri, TexParameterfv, and TexParameteriv when the {@code pname} parameter is + * TEXTURE_COMPARE_MODE_ARB. + */ + public static final int GL_COMPARE_R_TO_TEXTURE_ARB = 0x884E; + + private ARBShadow() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBShadowAmbient.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBShadowAmbient.java new file mode 100644 index 00000000..4c97165a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBShadowAmbient.java @@ -0,0 +1,24 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_shadow_ambient extension. + * + *This extension allows the user to specify the texture value to use when the texture compare function fails. Normally this value is zero. By allowing an + * arbitrary value we can get functionality which otherwise requires an advanced texture combine extension (such as + * NV_register_combiners) and multiple texture units.
+ * + *Requires {@link ARBShadow ARB_shadow} and {@link ARBDepthTexture ARB_depth_texture}.
+ */ +public final class ARBShadowAmbient { + + /** Accepted by the {@code pname} parameter of TexParameterf, TexParameteri, TexParameterfv, TexParameteriv, GetTexParameterfv, and GetTexParameteriv. */ + public static final int GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = 0x80BF; + + private ARBShadowAmbient() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSparseBuffer.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSparseBuffer.java new file mode 100644 index 00000000..249c5f78 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSparseBuffer.java @@ -0,0 +1,79 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_sparse_buffer extension. + * + *This extension adds to GL a mechanism to decouple the virtual and physical storage requirements of textures and allows an application + * to create partially populated textures that would over-subscribe available graphics memory if made fully resident. This extension provides like + * functionality for buffer objects, allowing applications to manage buffer object storage in a similar manner.
+ * + *Requires {@link GL15 OpenGL 1.5} or {@link ARBVertexBufferObject ARB_vertex_buffer_object}.
+ */ +public class ARBSparseBuffer { + + /** Accepted as part of the {@code flags} parameter to {@link GL44C#glBufferStorage BufferStorage}. */ + public static final int GL_SPARSE_STORAGE_BIT_ARB = 0x400; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetFloatv, GetIntegerv, and GetInteger64v. */ + public static final int GL_SPARSE_BUFFER_PAGE_SIZE_ARB = 0x82F8; + + static { GL.initialize(); } + + protected ARBSparseBuffer() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.Set| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
Recent advances in application complexity and a desire for higher resolutions have pushed texture sizes up considerably. Often, the amount of physical + * memory available to a graphics processor is a limiting factor in the performance of texture-heavy applications. Once the available physical memory is + * exhausted, paging may occur bringing performance down considerably - or worse, the application may fail. Nevertheless, the amount of address space + * available to the graphics processor has increased to the point where many gigabytes - or even terabytes of address space may be usable even though that + * amount of physical memory is not present.
+ * + *This extension allows the separation of the graphics processor's address space (reservation) from the requirement that all textures must be physically + * backed (commitment). This exposes a limited form of virtualization for textures. Use cases include sparse (or partially resident) textures, texture + * paging, on-demand and delayed loading of texture assets and application controlled level of detail.
+ */ +public class ARBSparseTexture { + + /** Accepted by the {@code pname} parameter to TexParameter{i f}{v}, TexParameterI{u}v, GetTexParameter{if}v and GetTexParameterIi{u}v. */ + public static final int + GL_TEXTURE_SPARSE_ARB = 0x91A6, + GL_VIRTUAL_PAGE_SIZE_INDEX_ARB = 0x91A7; + + /** Accepted by the {@code pname} parameter of GetTexParameter{if}v and GetTexParameterIi{u}v. */ + public static final int GL_NUM_SPARSE_LEVELS_ARB = 0x91AA; + + /** Accepted by the {@code pname} parameter to GetInternalformativ. */ + public static final int + GL_NUM_VIRTUAL_PAGE_SIZES_ARB = 0x91A8, + GL_VIRTUAL_PAGE_SIZE_X_ARB = 0x9195, + GL_VIRTUAL_PAGE_SIZE_Y_ARB = 0x9196, + GL_VIRTUAL_PAGE_SIZE_Z_ARB = 0x9197; + + /** Accepted by the {@code pname} parameter to GetIntegerv, GetFloatv, GetDoublev, GetInteger64v, and GetBooleanv. */ + public static final int + GL_MAX_SPARSE_TEXTURE_SIZE_ARB = 0x9198, + GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB = 0x9199, + GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB = 0x919A, + GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB = 0x91A9; + + static { GL.initialize(); } + + protected ARBSparseTexture() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetIf the value of {@code commit} is {@link GL11#GL_TRUE TRUE}, then the texture pages contained in the region defined by the values of {@code xoffset}, {@code yoffset}, + * {@code zoffset}, {@code width}, {@code height} and {@code depth} are committed. If they were not committed before the call, then new physical backing + * store is allocated and associated with the sparse pages and their initial content is undefined. If the pages were already committed, then they remain + * committed, no error is generated, and the content of those pages remains unmodified. If the value of {@code committed} is {@link GL11#GL_FALSE FALSE}, then the texture + * pages contained in the region are made de-committed. Their physical store is de-allocated, and their contents again become undefined.
+ * + *For the purposes of commitment, a cube map texture is treated as a 2D array texture with a depth of six and cube map array textures are treated as 2D + * array textures with a depth equal to six times the number of layers in the cube map array.
+ * + *For levels of a sparse texture where each dimension is a multiple of the virtual page size, the residency of individual page-size regions is controlled + * by TexPageCommitmentARB and such levels may be partially populated. When the mipmap chain reaches a level that is not an integer multiple of the virtual + * page size in any dimension, padding and memory layout considerations may make it impossible to treat that level and subsequent smaller ones as partially + * populated. The set of levels that can be partially populated is implementation-dependent. The total number of levels that may be partially populated may + * be queried by calling {@link GL11C#glGetTexParameteriv GetTexParameteriv} with the {@code pname} {@link #GL_NUM_SPARSE_LEVELS_ARB NUM_SPARSE_LEVELS_ARB}.
+ * + *The collection of texture levels that may not be partially populated, if any, consists of levels {@link #GL_NUM_SPARSE_LEVELS_ARB NUM_SPARSE_LEVELS_ARB} and higher, and is referred to + * as the mipmap 'tail'. The levels comprising the tail are made resident or non-resident as a unit. The tail is resident if and only if + * TexPageCommitmentARB has been called successfully with {@code level} greater than or equal to {@link #GL_NUM_SPARSE_LEVELS_ARB NUM_SPARSE_LEVELS_ARB} and the value of {@code commit} was + * {@link GL11#GL_TRUE TRUE} for the last such call.
+ * + *Views of sparse textures are also considered sparse. Modifications to commitment of a texture via a view of it affect the parent texture and any other + * views containing the modified pages. If a view of a sparse texture references its tail (or is entirely contained within it), modifications to commitment + * of the tail via the view will affect the entire tail of the parent, even for parts of the tail that are not referenced by the view. Furthermore, + * modifications to tail commitment may affect views referencing other parts of the tail.
+ * + *An {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error is generated if {@code xoffset} + {@code width} or {@code yoffset} + {@code height} is greater than the width or height, + * respectively, of level {@code level} of the texture bound to {@code target}.
+ * + *An {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error is generated if {@code zoffset} + {@code depth} is greater than
+ * + *An {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if {@code xoffset}, {@code yoffset}, or {@code zoffset} is not a multiple of {@link #GL_VIRTUAL_PAGE_SIZE_X_ARB VIRTUAL_PAGE_SIZE_X_ARB}, + * {@link #GL_VIRTUAL_PAGE_SIZE_Y_ARB VIRTUAL_PAGE_SIZE_Y_ARB}, or {@link #GL_VIRTUAL_PAGE_SIZE_Z_ARB VIRTUAL_PAGE_SIZE_Z_ARB}, respectively, of the texture bound to {@code target}.
+ * + *An {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error is generated if {@code width} is not an integer multiple of {@link #GL_VIRTUAL_PAGE_SIZE_X_ARB VIRTUAL_PAGE_SIZE_X_ARB} and {@code width} plus + * {@code xoffset} is not equal to the width of level {@code level} of the texture bound to {@code target}.
+ * + *An {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error is generated if {@code height} is not an integer multiple of {@link #GL_VIRTUAL_PAGE_SIZE_Y_ARB VIRTUAL_PAGE_SIZE_Y_ARB} and {@code height} plus + * {@code yoffset} is not equal to the height of level {@code level} of the texture bound to {@code target}.
+ * + *An {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error is generated if {@code depth} is not an integer multiple of {@link #GL_VIRTUAL_PAGE_SIZE_Z_ARB VIRTUAL_PAGE_SIZE_Z_ARB} and {@code depth} plus + * {@code zoffset} is not equal to
+ * + *An {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error is generated if the value of {@link GL42#GL_TEXTURE_IMMUTABLE_FORMAT TEXTURE_IMMUTABLE_FORMAT} or {@link #GL_TEXTURE_SPARSE_ARB TEXTURE_SPARSE_ARB} for the texture bound to + * {@code target} is {@link GL11#GL_FALSE FALSE}.
+ * + * @param target the texture target. One of:| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
This extension allows texturing of the stencil component of a packed depth stencil texture. Stencil values are returned as unsigned integers. It is not + * possible to sample both depth and stencil values from the same texture, and this extension allows the app to select which is sampled for the bound + * texture.
+ * + *Requires {@link ARBDepthTexture ARB_depth_texture} and {@link EXTPackedDepthStencil EXT_packed_depth_stencil}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public final class ARBStencilTexturing { + + /** Accepted by the {@code pname} parameter of TexParameter and GetTexParameter*. */ + public static final int GL_DEPTH_STENCIL_TEXTURE_MODE = 0x90EA; + + private ARBStencilTexturing() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSync.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSync.java new file mode 100644 index 00000000..e69adb1b --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBSync.java @@ -0,0 +1,253 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_sync extension. + * + *This extension introduces the concept of "sync objects". Sync objects are a synchronization primitive - a representation of events whose completion + * status can be tested or waited upon. One specific type of sync object, the "fence sync object", is supported in this extension, and additional types can + * easily be added in the future.
+ * + *Fence sync objects have corresponding fences, which are inserted into the OpenGL command stream at the time the sync object is created. A sync object + * can be queried for a given condition. The only condition supported for fence sync objects is completion of the corresponding fence command. Fence + * completion allows applications to request a partial Finish, wherein all commands prior to the fence will be forced to complete before control is + * returned to the calling process.
+ * + *These new mechanisms allow for synchronization between the host CPU and the GPU, which may be accessing the same resources (typically memory), as well + * as between multiple GL contexts bound to multiple threads in the host CPU.
+ * + *Requires {@link GL31 OpenGL 3.1}. Promoted to core in {@link GL32 OpenGL 3.2}.
+ */ +public class ARBSync { + + /** Accepted as the {@code pname} parameter of GetInteger64v. */ + public static final int GL_MAX_SERVER_WAIT_TIMEOUT = 0x9111; + + /** Accepted as the {@code pname} parameter of GetSynciv. */ + public static final int + GL_OBJECT_TYPE = 0x9112, + GL_SYNC_CONDITION = 0x9113, + GL_SYNC_STATUS = 0x9114, + GL_SYNC_FLAGS = 0x9115; + + /** Returned in {@code values} for GetSynciv {@code pname} OBJECT_TYPE. */ + public static final int GL_SYNC_FENCE = 0x9116; + + /** Returned in {@code values} for GetSynciv {@code pname} SYNC_CONDITION. */ + public static final int GL_SYNC_GPU_COMMANDS_COMPLETE = 0x9117; + + /** Returned in {@code values} for GetSynciv {@code pname} SYNC_STATUS. */ + public static final int + GL_UNSIGNALED = 0x9118, + GL_SIGNALED = 0x9119; + + /** Accepted in the {@code flags} parameter of ClientWaitSync. */ + public static final int GL_SYNC_FLUSH_COMMANDS_BIT = 0x1; + + /** Accepted in the {@code timeout} parameter of WaitSync. */ + public static final long GL_TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFFL; + + /** Returned by ClientWaitSync. */ + public static final int + GL_ALREADY_SIGNALED = 0x911A, + GL_TIMEOUT_EXPIRED = 0x911B, + GL_CONDITION_SATISFIED = 0x911C, + GL_WAIT_FAILED = 0x911D; + + static { GL.initialize(); } + + protected ARBSync() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glFenceSync, caps.glIsSync, caps.glDeleteSync, caps.glClientWaitSync, caps.glWaitSync, caps.glGetInteger64v, caps.glGetSynciv + ); + } + + // --- [ glFenceSync ] --- + + /** + * Creates a new sync object and inserts it into the GL command stream. + * + * @param condition the condition that must be met to set the sync object's state to signaled. Must be:| {@link GL32C#GL_SYNC_GPU_COMMANDS_COMPLETE SYNC_GPU_COMMANDS_COMPLETE} |
The return value is one of four status values:
+ * + *| 0 | {@link GL32C#GL_SYNC_FLUSH_COMMANDS_BIT SYNC_FLUSH_COMMANDS_BIT} |
{@code glWaitSync} will always wait no longer than an implementation-dependent timeout. The duration of this timeout in nanoseconds may be queried by + * with {@link GL32C#GL_MAX_SERVER_WAIT_TIMEOUT MAX_SERVER_WAIT_TIMEOUT}. There is currently no way to determine whether glWaitSync unblocked because the timeout expired or because the + * sync object being waited on was signaled.
+ * + *If an error occurs, {@code glWaitSync} does not cause the GL server to block.
+ * + * @param sync the sync object whose status to wait on + * @param flags a bitfield controlling the command flushing behavior. Must be:| 0 |
| {@link GL32C#GL_TIMEOUT_IGNORED TIMEOUT_IGNORED} |
| {@link GL32C#GL_OBJECT_TYPE OBJECT_TYPE} | {@link GL32C#GL_SYNC_CONDITION SYNC_CONDITION} | {@link GL32C#GL_SYNC_STATUS SYNC_STATUS} | {@link GL32C#GL_SYNC_FLAGS SYNC_FLAGS} |
| {@link GL32C#GL_OBJECT_TYPE OBJECT_TYPE} | {@link GL32C#GL_SYNC_CONDITION SYNC_CONDITION} | {@link GL32C#GL_SYNC_STATUS SYNC_STATUS} | {@link GL32C#GL_SYNC_FLAGS SYNC_FLAGS} |
This extension introduces new tessellation stages and two new shader types to the OpenGL primitive processing pipeline. These pipeline stages operate on + * a new basic primitive type, called a patch. A patch consists of a fixed-size collection of vertices, each with per-vertex attributes, plus a number of + * associated per-patch attributes. Tessellation control shaders transform an input patch specified by the application, computing per-vertex and per-patch + * attributes for a new output patch. A fixed-function tessellation primitive generator subdivides the patch, and tessellation evaluation shaders are used + * to compute the position and attributes of each vertex produced by the tessellator.
+ * + *When tessellation is active, it begins by running the optional tessellation control shader. This shader consumes an input patch and produces a new + * fixed-size output patch. The output patch consists of an array of vertices, and a set of per-patch attributes. The per-patch attributes include + * tessellation levels that control how finely the patch will be tessellated. For each patch processed, multiple tessellation control shader invocations + * are performed -- one per output patch vertex. Each tessellation control shader invocation writes all the attributes of its corresponding output patch + * vertex. A tessellation control shader may also read the per-vertex outputs of other tessellation control shader invocations, as well as read and write + * shared per-patch outputs. The tessellation control shader invocations for a single patch effectively run as a group. A built-in {@code barrier()} + * function is provided to allow synchronization points where no shader invocation will continue until all shader invocations have reached the barrier.
+ * + *The tessellation primitive generator then decomposes a patch into a new set of primitives using the tessellation levels to determine how finely + * tessellated the output should be. The primitive generator begins with either a triangle or a quad, and splits each outer edge of the primitive into a + * number of segments approximately equal to the corresponding element of the outer tessellation level array. The interior of the primitive is tessellated + * according to elements of the inner tessellation level array. The primitive generator has three modes: "triangles" and "quads" split a triangular or + * quad-shaped patch into a set of triangles that cover the original patch; "isolines" splits a quad-shaped patch into a set of line strips running across + * the patch horizontally. Each vertex generated by the tessellation primitive generator is assigned a (u,v) or (u,v,w) coordinate indicating its relative + * location in the subdivided triangle or quad.
+ * + *For each vertex produced by the tessellation primitive generator, the tessellation evaluation shader is run to compute its position and other attributes + * of the vertex, using its (u,v) or (u,v,w) coordinate. When computing final vertex attributes, the tessellation evaluation shader can also read the + * attributes of any of the vertices of the patch written by the tessellation control shader. Tessellation evaluation shader invocations are completely + * independent, although all invocations for a single patch share the same collection of input vertices and per-patch attributes.
+ * + *The tessellator operates on vertices after they have been transformed by a vertex shader. The primitives generated by the tessellator are passed further + * down the OpenGL pipeline, where they can be used as inputs to geometry shaders, transform feedback, and the rasterizer.
+ * + *The tessellation control and evaluation shaders are both optional. If neither shader type is present, the tessellation stage has no effect. If no + * tessellation control shader is present, the input patch provided by the application is passed directly to the tessellation primitive generator, and a + * set of default tessellation level parameters is used to control primitive generation. In this extension, patches may not be passed beyond the + * tessellation evaluation shader, and an error is generated if an application provides patches and the current program object contains no tessellation + * evaluation shader.
+ * + *Requires {@link GL32 GL32} and GLSL 1.50. Promoted to core in {@link GL40 OpenGL 4.0}.
+ */ +public class ARBTessellationShader { + + /** Accepted by the {@code mode} parameter of Begin and all vertex array functions that implicitly call Begin. */ + public static final int GL_PATCHES = 0xE; + + /** Accepted by the {@code pname} parameter of PatchParameteri, GetBooleanv, GetDoublev, GetFloatv, GetIntegerv, and GetInteger64v. */ + public static final int GL_PATCH_VERTICES = 0x8E72; + + /** Accepted by the {@code pname} parameter of PatchParameterfv, GetBooleanv, GetDoublev, GetFloatv, and GetIntegerv, and GetInteger64v. */ + public static final int + GL_PATCH_DEFAULT_INNER_LEVEL = 0x8E73, + GL_PATCH_DEFAULT_OUTER_LEVEL = 0x8E74; + + /** Accepted by the {@code pname} parameter of GetProgramiv. */ + public static final int + GL_TESS_CONTROL_OUTPUT_VERTICES = 0x8E75, + GL_TESS_GEN_MODE = 0x8E76, + GL_TESS_GEN_SPACING = 0x8E77, + GL_TESS_GEN_VERTEX_ORDER = 0x8E78, + GL_TESS_GEN_POINT_MODE = 0x8E79; + + /** Returned by GetProgramiv when {@code pname} is TESS_GEN_MODE. */ + public static final int GL_ISOLINES = 0x8E7A; + + /** Returned by GetProgramiv when {@code pname} is TESS_GEN_SPACING. */ + public static final int + GL_FRACTIONAL_ODD = 0x8E7B, + GL_FRACTIONAL_EVEN = 0x8E7C; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetFloatv, GetIntegerv, and GetInteger64v. */ + public static final int + GL_MAX_PATCH_VERTICES = 0x8E7D, + GL_MAX_TESS_GEN_LEVEL = 0x8E7E, + GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F, + GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80, + GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81, + GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82, + GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83, + GL_MAX_TESS_PATCH_COMPONENTS = 0x8E84, + GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85, + GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86, + GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89, + GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A, + GL_MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C, + GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D, + GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E, + GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F; + + /** Accepted by the {@code pname} parameter of GetActiveUniformBlockiv. */ + public static final int + GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0, + GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1; + + /** Accepted by the {@code type} parameter of CreateShader and returned by the {@code params} parameter of GetShaderiv. */ + public static final int + GL_TESS_EVALUATION_SHADER = 0x8E87, + GL_TESS_CONTROL_SHADER = 0x8E88; + + static { GL.initialize(); } + + protected ARBTessellationShader() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glPatchParameteri, caps.glPatchParameterfv + ); + } + + // --- [ glPatchParameteri ] --- + + /** + * Specifies the integer value of the specified parameter for patch primitives. + * + * @param pname the name of the parameter to set. Must be:| {@link GL40C#GL_PATCH_VERTICES PATCH_VERTICES} |
| {@link GL40C#GL_PATCH_DEFAULT_OUTER_LEVEL PATCH_DEFAULT_OUTER_LEVEL} | {@link GL40C#GL_PATCH_DEFAULT_INNER_LEVEL PATCH_DEFAULT_INNER_LEVEL} |
This extension relaxes the restrictions on rendering to a currently bound texture and provides a mechanism to avoid read-after-write hazards.
+ * + *Promoted to core in {@link GL45 OpenGL 4.5}.
+ */ +public class ARBTextureBarrier { + + static { GL.initialize(); } + + protected ARBTextureBarrier() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glTextureBarrier + ); + } + + // --- [ glTextureBarrier ] --- + + /** Guarantees that writes have completed and caches have been invalidated before subsequent Draws are executed. */ + public static void glTextureBarrier() { + GL45C.glTextureBarrier(); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureBorderClamp.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureBorderClamp.java new file mode 100644 index 00000000..e5c1ec5d --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureBorderClamp.java @@ -0,0 +1,31 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_texture_border_clamp extension. + * + *The base OpenGL provides clamping such that the texture coordinates are limited to exactly the range [0,1]. When a texture coordinate is clamped using + * this algorithm, the texture sampling filter straddles the edge of the texture image, taking 1/2 its sample values from within the texture image, and the + * other 1/2 from the texture border. It is sometimes desirable for a texture to be clamped to the border color, rather than to an average of the border + * and edge colors.
+ * + *This extension defines an additional texture clamping algorithm. {@link #GL_CLAMP_TO_BORDER_ARB CLAMP_TO_BORDER_ARB} clamps texture coordinates at all mipmap levels such that + * {@link GL11#GL_NEAREST NEAREST} and {@link GL11#GL_LINEAR LINEAR} filters return only the color of the border texels.
+ * + *Promoted to core in {@link GL13 OpenGL 1.3}.
+ */ +public final class ARBTextureBorderClamp { + + /** + * Accepted by the {@code param} parameter of {@link GL11C#glTexParameteri TexParameteri} and {@link GL11C#glTexParameterf TexParameterf}, and by the {@code params} parameter of {@link GL11C#glTexParameteriv TexParameteriv} + * and {@link GL11C#glTexParameterfv TexParameterfv}, when their {@code pname} parameter is {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S}, {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T}, or {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R}. + */ + public static final int GL_CLAMP_TO_BORDER_ARB = 0x812D; + + private ARBTextureBorderClamp() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureBufferObject.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureBufferObject.java new file mode 100644 index 00000000..f4ee6c8c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureBufferObject.java @@ -0,0 +1,94 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_texture_buffer_object extension. + * + *This extension provides a new texture type, called a buffer texture. Buffer textures are one-dimensional arrays of texels whose storage comes from an + * attached buffer object. When a buffer object is bound to a buffer texture, a format is specified, and the data in the buffer object is treated as an + * array of texels of the specified format.
+ * + *The use of a buffer object to provide storage allows the texture data to be specified in a number of different ways: via buffer object loads + * ({@link GL15C#glBufferData BufferData}), direct CPU writes ({@link GL15C#glMapBuffer MapBuffer}), framebuffer readbacks (EXT_pixel_buffer_object extension). A buffer object can also be loaded + * by transform feedback (NV_transform_feedback extension), which captures selected transformed attributes of vertices processed by the GL. Several of + * these mechanisms do not require an extra data copy, which would be required when using conventional TexImage-like entry points.
+ * + *Buffer textures do not support mipmapping, texture lookups with normalized floating-point texture coordinates, and texture filtering of any sort, and + * may not be used in fixed-function fragment processing. They can be accessed via single texel fetch operations in programmable shaders. For assembly + * shaders (NV_gpu_program4), the TXF instruction is used. For GLSL (EXT_gpu_shader4), a new sampler type and texel fetch function are used.
+ * + *While buffer textures can be substantially larger than equivalent one-dimensional textures; the maximum texture size supported for buffer textures in + * the initial implementation of this extension is 2^27 texels, versus 2^13 (8192) texels for otherwise equivalent one-dimensional textures. When a buffer + * object is attached to a buffer texture, a size is not specified; rather, the number of texels in the texture is taken by dividing the size of the buffer + * object by the size of each texel.
+ * + *Requires {@link GL20 OpenGL 2.0} and NV_gpu_program4 or {@link EXTGPUShader4 EXT_gpu_shader4}. Promoted to core in {@link GL31 OpenGL 3.1}.
+ */ +public class ARBTextureBufferObject { + + /** + * Accepted by the {@code target} parameter of BindBuffer, BufferData, BufferSubData, MapBuffer, MapBufferRangeARB, BindTexture, UnmapBuffer, + * GetBufferSubData, GetBufferParameteriv, GetBufferPointerv, and TexBufferARB, and the {@code pname} parameter of GetBooleanv, GetDoublev, GetFloatv, and + * GetIntegerv. + */ + public static final int GL_TEXTURE_BUFFER_ARB = 0x8C2A; + + /** Accepted by the {@code pname} parameters of GetBooleanv, GetDoublev, GetFloatv, and GetIntegerv. */ + public static final int + GL_MAX_TEXTURE_BUFFER_SIZE_ARB = 0x8C2B, + GL_TEXTURE_BINDING_BUFFER_ARB = 0x8C2C, + GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = 0x8C2D, + GL_TEXTURE_BUFFER_FORMAT_ARB = 0x8C2E; + + static { GL.initialize(); } + + protected ARBTextureBufferObject() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glTexBufferARB + ); + } + + // --- [ glTexBufferARB ] --- + + /** + * Attaches the storage for the buffer object named {@code buffer} to the active buffer texture, and specifies an internal format for the texel array found + * in the attached buffer object. If {@code buffer} is zero, any buffer object attached to the buffer texture is detached, and no new buffer object is + * attached. If {@code buffer} is non-zero, but is not the name of an existing buffer object, the error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated. + * + *When a buffer object is attached to a buffer texture, the buffer object's data store is taken as the texture's texel array. The number of texels in the + * buffer texture's texel array is given by
+ * + *{@code floor(buffer_size / (components * sizeof(base_type))},
+ * + *where {@code buffer_size} is the size of the buffer object, in basic machine units and {@code components} and {@code base_type} are the element count + * and base data type for elements. The number of texels in the texel array is then clamped to the implementation-dependent limit + * {@link #GL_MAX_TEXTURE_BUFFER_SIZE_ARB MAX_TEXTURE_BUFFER_SIZE_ARB}. When a buffer texture is accessed in a shader, the results of a texel fetch are undefined if the specified texel number is + * greater than or equal to the clamped number of texels in the texel array.
+ * + *When a buffer texture is accessed in a shader, an integer is provided to indicate the texel number being accessed. If no buffer object is bound to the + * buffer texture, the results of the texel access are undefined. Otherwise, the attached buffer object's data store is interpreted as an array of elements + * of the GL data type corresponding to {@code internalformat}. Each texel consists of one to four elements that are mapped to texture components + * (R, G, B, A, L, and I). Element {@code m} of the texel numbered {@code n} is taken from element {@code n} * {@code components} + {@code m} of the + * attached buffer object's data store. Elements and texels are both numbered starting with zero. For texture formats with normalized components, the + * extracted values are converted to floating-point values. The components of the texture are then converted to an (R,G,B,A) vector, and returned to the + * shader as a four-component result vector with components of the appropriate data type for the texture's internal format.
+ * + * @param target the target of the operation. Must be:| {@link #GL_TEXTURE_BUFFER_ARB TEXTURE_BUFFER_ARB} |
{@link ARBTextureBufferObject ARB_texture_buffer_object} (which was promoted to core in OpenGL 3.1) introduced the ability to attach the data store of a buffer object to a buffer + * texture and access it from shaders. The extension only allows the entire store of the buffer object to the texture. This extension expands on this and + * allows a sub-range of the buffer's data store to be attached to a texture. This can be used, for example, to allow multiple buffer textures to be backed + * by independent sub-ranges of the same buffer object, or for different sub-ranges of a single buffer object to be used for different purposes.
+ * + *Requires {@link GL15 OpenGL 1.5}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public class ARBTextureBufferRange { + + /** Accepted by the {@code pname} parameter of GetTexLevelParameter. */ + public static final int + GL_TEXTURE_BUFFER_OFFSET = 0x919D, + GL_TEXTURE_BUFFER_SIZE = 0x919E; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F; + + static { GL.initialize(); } + + protected ARBTextureBufferRange() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.Set| {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
Compressing texture images can reduce texture memory utilization and improve performance when rendering textured primitives. This extension allows + * OpenGL applications to use compressed texture images by providing:
+ * + *An application can define compressed texture images by providing a texture image stored in a specific compressed image format. This extension does not + * define any specific compressed image formats, but it does provide the mechanisms necessary to enable other extensions that do.
+ * + *An application can also define compressed texture images by providing an uncompressed texture image but specifying a compressed internal format. In this + * case, the GL will automatically compress the texture image using the appropriate image format. Compressed internal formats can either be specific (as + * above) or generic. Generic compressed internal formats are not actual image formats, but are instead mapped into one of the specific compressed formats + * provided by the GL (or to an uncompressed base internal format if no appropriate compressed format is available). Generic compressed internal formats + * allow applications to use texture compression without needing to code to any particular compression algorithm. Generic compressed formats allow the use + * of texture compression across a wide range of platforms with differing compression algorithms and also allow future GL implementations to substitute + * improved compression methods transparently.
+ * + *Promoted to core in {@link GL13 OpenGL 1.3}.
+ */ +public class ARBTextureCompression { + + /** Accepted by the {@code internalformat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, and CopyTexImage2D. */ + public static final int + GL_COMPRESSED_ALPHA_ARB = 0x84E9, + GL_COMPRESSED_LUMINANCE_ARB = 0x84EA, + GL_COMPRESSED_LUMINANCE_ALPHA_ARB = 0x84EB, + GL_COMPRESSED_INTENSITY_ARB = 0x84EC, + GL_COMPRESSED_RGB_ARB = 0x84ED, + GL_COMPRESSED_RGBA_ARB = 0x84EE; + + /** Accepted by the {@code target} parameter of Hint and the {@code value} parameter of GetIntegerv, GetBooleanv, GetFloatv, and GetDoublev. */ + public static final int GL_TEXTURE_COMPRESSION_HINT_ARB = 0x84EF; + + /** Accepted by the {@code value} parameter of GetTexLevelParameter. */ + public static final int + GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 0x86A0, + GL_TEXTURE_COMPRESSED_ARB = 0x86A1; + + /** Accepted by the {@code value} parameter of GetIntegerv, GetBooleanv, GetFloatv, and GetDoublev. */ + public static final int + GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A2, + GL_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A3; + + static { GL.initialize(); } + + protected ARBTextureCompression() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glCompressedTexImage3DARB, caps.glCompressedTexImage2DARB, caps.glCompressedTexImage1DARB, caps.glCompressedTexSubImage3DARB, + caps.glCompressedTexSubImage2DARB, caps.glCompressedTexSubImage1DARB, caps.glGetCompressedTexImageARB + ); + } + + // --- [ glCompressedTexImage3DARB ] --- + + /** + * Unsafe version of: {@link #glCompressedTexImage3DARB CompressedTexImage3DARB} + * + * @param imageSize the number of unsigned bytes of image data starting at the address specified by {@code data} + */ + public static native void nglCompressedTexImage3DARB(int target, int level, int internalformat, int width, int height, int depth, int border, int imageSize, long data); + + /** + * Specifies a three-dimensional texture image in a compressed format. + * + * @param target the target texture. One of:| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
This extension provides additional texture compression functionality specific to the BPTC and BPTC_FLOAT compressed texture formats (called BC7 and BC6H + * respectively in Microsoft's DirectX API), subject to all the requirements and limitations described by the extension {@link ARBTextureCompression ARB_texture_compression}.
+ * + *Traditional block compression methods as typified by s3tc and latc compress a block of pixels into indicies along a gradient. This works well for smooth + * images, but can have quality issues along sharp edges and strong chrominance transitions. To improve quality in these problematic cases, the BPTC + * formats can divide each block into multiple partitions, each of which are compressed using an independent gradient.
+ * + *In addition, it is desirable to directly support high dynamic range imagery in compressed formats, which is accomplished by the BPTC_FLOAT formats.
+ * + *Requires {@link GL31 OpenGL 3.1} and {@link ARBTextureCompression ARB_texture_compression}.
+ */ +public final class ARBTextureCompressionBPTC { + + /** + * Accepted by the {@code internalformat} parameter of TexImage2D, TexImage3D, CopyTexImage2D, CopyTexImage3D, CompressedTexImage2DARB, and + * CompressedTexImage3DARB and the {@code format} parameter of CompressedTexSubImage2DARB and CompressedTexSubImage3DARB. + */ + public static final int + GL_COMPRESSED_RGBA_BPTC_UNORM_ARB = 0x8E8C, + GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB = 0x8E8D, + GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB = 0x8E8E, + GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB = 0x8E8F; + + private ARBTextureCompressionBPTC() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureCompressionRGTC.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureCompressionRGTC.java new file mode 100644 index 00000000..8e8aea8c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureCompressionRGTC.java @@ -0,0 +1,39 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_texture_compression_rgtc extension. + * + *This extension introduces four new block-based texture compression formats suited for unsigned and signed red and red-green textures (hence the name + * "rgtc" for Red-Green Texture Compression).
+ * + *These formats are designed to reduce the storage requirements and memory bandwidth required for red and red-green textures by a factor of 2-to-1 over + * conventional uncompressed luminance and luminance-alpha textures with 8-bit components ({@link GL11#GL_LUMINANCE8 LUMINANCE8} and {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8}).
+ * + *The compressed signed red-green format is reasonably suited for storing compressed normal maps.
+ * + *This extension uses the same compression format as the {@link EXTTextureCompressionLATC EXT_texture_compression_latc} extension except the color data is stored in the red and + * green components rather than luminance and alpha. Representing compressed red and green components is consistent with the BC4 and BC5 compressed + * formats supported by DirectX 10.
+ * + *Requires {@link GL13 OpenGL 1.3} or {@link ARBTextureCompression ARB_texture_compression}. Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public final class ARBTextureCompressionRGTC { + + /** + * Accepted by the {@code internalformat} parameter of TexImage2D, CopyTexImage2D, and CompressedTexImage2D and the {@code format} parameter of + * CompressedTexSubImage2D. + */ + public static final int + GL_COMPRESSED_RED_RGTC1 = 0x8DBB, + GL_COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC, + GL_COMPRESSED_RG_RGTC2 = 0x8DBD, + GL_COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE; + + private ARBTextureCompressionRGTC() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureCubeMap.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureCubeMap.java new file mode 100644 index 00000000..8fa0430c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureCubeMap.java @@ -0,0 +1,68 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_texture_cube_map extension. + * + *This extension provides a new texture generation scheme for cube map textures. Instead of the current texture providing a 1D, 2D, or 3D lookup into a + * 1D, 2D, or 3D texture image, the texture is a set of six 2D images representing the faces of a cube. The (s,t,r) texture coordinates are treated as a + * direction vector emanating from the center of a cube. At texture generation time, the interpolated per-fragment (s,t,r) selects one cube face 2D image + * based on the largest magnitude coordinate (the major axis). A new 2D (s,t) is calculated by dividing the two other coordinates (the minor axes values) + * by the major axis value. Then the new (s,t) is used to lookup into the selected 2D texture image face of the cube map.
+ * + *Unlike a standard 1D, 2D, or 3D texture that have just one target, a cube map texture has six targets, one for each of its six 2D texture image cube + * faces. All these targets must be consistent, complete, and have equal width and height (ie, square dimensions).
+ * + *This extension also provides two new texture coordinate generation modes for use in conjunction with cube map texturing. The reflection map mode + * generates texture coordinates (s,t,r) matching the vertex's eye-space reflection vector. The reflection map mode is useful for environment mapping + * without the singularity inherent in sphere mapping. The normal map mode generates texture coordinates (s,t,r) matching the vertex's transformed + * eye-space normal. The normal map mode is useful for sophisticated cube map texturing-based diffuse lighting models.
+ * + *The intent of the new texgen functionality is that an application using cube map texturing can use the new texgen modes to automatically generate the + * reflection or normal vectors used to look up into the cube map texture.
+ * + *Promoted to core in {@link GL13 OpenGL 1.3}.
+ */ +public final class ARBTextureCubeMap { + + /** Accepted by the {@code param} parameters of TexGend, TexGenf, and TexGeni when {@code pname} parameter is TEXTURE_GEN_MODE. */ + public static final int + GL_NORMAL_MAP_ARB = 0x8511, + GL_REFLECTION_MAP_ARB = 0x8512; + + /** + * When the {@code pname} parameter of TexGendv, TexGenfv, and TexGeniv is TEXTURE_GEN_MODE, then the array {@code params} may also contain NORMAL_MAP_ARB + * or REFLECTION_MAP_ARB. Accepted by the {@code cap} parameter of Enable, Disable, IsEnabled, and by the {@code pname} parameter of GetBooleanv, + * GetIntegerv, GetFloatv, and GetDoublev, and by the {@code target} parameter of BindTexture, GetTexParameterfv, GetTexParameteriv, TexParameterf, + * TexParameteri, TexParameterfv, and TexParameteriv. + */ + public static final int GL_TEXTURE_CUBE_MAP_ARB = 0x8513; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_TEXTURE_BINDING_CUBE_MAP_ARB = 0x8514; + + /** + * Accepted by the {@code target} parameter of GetTexImage, GetTexLevelParameteriv, GetTexLevelParameterfv, TexImage2D, CopyTexImage2D, TexSubImage2D, and + * CopySubTexImage2D. + */ + public static final int + GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x8515, + GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x8516, + GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x8517, + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x8518, + GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x8519, + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x851A; + + /** Accepted by the {@code target} parameter of GetTexLevelParameteriv, GetTexLevelParameterfv, GetTexParameteriv, and TexImage2D. */ + public static final int GL_PROXY_TEXTURE_CUBE_MAP_ARB = 0x851B; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 0x851C; + + private ARBTextureCubeMap() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureCubeMapArray.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureCubeMapArray.java new file mode 100644 index 00000000..d1671958 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureCubeMapArray.java @@ -0,0 +1,48 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_texture_cube_map_array extension. + * + *The {@link EXTTextureArray EXT_texture_array} extension, and subsequently OpenGL 3.0 have introduced the concept of one- and two-dimensional array textures. An array + * texture is an ordered set of images with the same size and format. Each image in an array texture has a unique level. This extension expands texture + * array support to include cube map textures.
+ * + *A cube map array texture is a 2-dimensional array texture that may contain many cube map layers. Each cube map layer is a unique cube map image set. + * Images in a cube map array have the same size and format limitations as one- and two-dimensional array textures. A cube map array texture is specified + * using {@link GL12C#glTexImage3D TexImage3D} in a similar manner to two-dimensional arrays. Cube map array textures can be bound to a render targets of a frame buffer object + * as two-dimensional arrays are using FramebufferTextureLayer.
+ * + *When accessed by a programmable shader, a cube map array texture acts as a single unit. The "s", "t", "r" texture coordinates are treated as a regular + * cube map texture fetch. The "q" texture is treated as an unnormalized floating-point value identifying the layer of the cube map array texture. Cube map + * array texture lookups do not filter between layers.
+ * + *This extension does not provide for the use of cube map array textures with fixed-function fragment processing.
+ * + *Promoted to core in {@link GL40 OpenGL 4.0}.
+ */ +public final class ARBTextureCubeMapArray { + + /** Accepted by the {@code target} parameter of TexParameteri, TexParameteriv, TexParameterf, TexParameterfv, BindTexture, and GenerateMipmap. */ + public static final int GL_TEXTURE_CUBE_MAP_ARRAY_ARB = 0x9009; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv and GetFloatv. */ + public static final int GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB = 0x900A; + + /** Accepted by the {@code target} parameter of TexImage3D, TexSubImage3D, CompressedTeximage3D, CompressedTexSubImage3D and CopyTexSubImage3D. */ + public static final int GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB = 0x900B; + + /** TEXTURE_CUBE_MAP_ARRAY_ARB Returned by the {@code type} parameter of GetActiveUniform. */ + public static final int + GL_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900C, + GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB = 0x900D, + GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900E, + GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900F; + + private ARBTextureCubeMapArray() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureEnvCombine.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureEnvCombine.java new file mode 100644 index 00000000..c625a4cd --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureEnvCombine.java @@ -0,0 +1,58 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_texture_env_combine extension. + * + *New texture environment function COMBINE_ARB allows programmable texture combiner operations.
+ * + *Requires {@link ARBMultitexture ARB_multitexture}. Promoted to core in {@link GL13 OpenGL 1.3}.
+ */ +public final class ARBTextureEnvCombine { + + /** Accepted by the {@code params} parameter of TexEnvf, TexEnvi, TexEnvfv, and TexEnviv when the {@code pname} parameter value is TEXTURE_ENV_MODE. */ + public static final int GL_COMBINE_ARB = 0x8570; + + /** Accepted by the {@code pname} parameter of TexEnvf, TexEnvi, TexEnvfv, and TexEnviv when the {@code target} parameter value is TEXTURE_ENV. */ + public static final int + GL_COMBINE_RGB_ARB = 0x8571, + GL_COMBINE_ALPHA_ARB = 0x8572, + GL_SOURCE0_RGB_ARB = 0x8580, + GL_SOURCE1_RGB_ARB = 0x8581, + GL_SOURCE2_RGB_ARB = 0x8582, + GL_SOURCE0_ALPHA_ARB = 0x8588, + GL_SOURCE1_ALPHA_ARB = 0x8589, + GL_SOURCE2_ALPHA_ARB = 0x858A, + GL_OPERAND0_RGB_ARB = 0x8590, + GL_OPERAND1_RGB_ARB = 0x8591, + GL_OPERAND2_RGB_ARB = 0x8592, + GL_OPERAND0_ALPHA_ARB = 0x8598, + GL_OPERAND1_ALPHA_ARB = 0x8599, + GL_OPERAND2_ALPHA_ARB = 0x859A, + GL_RGB_SCALE_ARB = 0x8573; + + /** + * Accepted by the {@code params} parameter of TexEnvf, TexEnvi, TexEnvfv, and TexEnviv when the {@code pname} parameter value is COMBINE_RGB_ARB or + * COMBINE_ALPHA_ARB. + */ + public static final int + GL_ADD_SIGNED_ARB = 0x8574, + GL_INTERPOLATE_ARB = 0x8575, + GL_SUBTRACT_ARB = 0x84E7; + + /** + * Accepted by the {@code params} parameter of TexEnvf, TexEnvi, TexEnvfv, and TexEnviv when the {@code pname} parameter value is SOURCE0_RGB_ARB, + * SOURCE1_RGB_ARB, SOURCE2_RGB_ARB, SOURCE0_ALPHA_ARB, SOURCE1_ALPHA_ARB, or SOURCE2_ALPHA_ARB. + */ + public static final int + GL_CONSTANT_ARB = 0x8576, + GL_PRIMARY_COLOR_ARB = 0x8577, + GL_PREVIOUS_ARB = 0x8578; + + private ARBTextureEnvCombine() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureEnvDot3.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureEnvDot3.java new file mode 100644 index 00000000..39c2962d --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureEnvDot3.java @@ -0,0 +1,24 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_texture_env_dot3 extension. + * + *Adds new dot product operation to the texture combiner operations.
+ * + *Requires {@link ARBMultitexture ARB_multitexture} and {@link ARBTextureEnvCombine ARB_texture_env_combine}. Promoted to core in {@link GL13 OpenGL 1.3}.
+ */ +public final class ARBTextureEnvDot3 { + + /** Accepted by the {@code params} parameter of TexEnvf, TexEnvi, TexEnvfv, and TexEnviv when the {@code pname} parameter value is COMBINE_RGB_ARB. */ + public static final int + GL_DOT3_RGB_ARB = 0x86AE, + GL_DOT3_RGBA_ARB = 0x86AF; + + private ARBTextureEnvDot3() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureFilterAnisotropic.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureFilterAnisotropic.java new file mode 100644 index 00000000..c9ef7b7f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureFilterAnisotropic.java @@ -0,0 +1,46 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_texture_filter_anisotropic extension. + * + *Texture mapping using OpenGL's existing mipmap texture filtering modes assumes that the projection of the pixel filter footprint into texture space is + * a square (ie, isotropic). In practice however, the footprint may be long and narrow (ie, anisotropic). Consequently, mipmap filtering severely blurs + * images on surfaces angled obliquely away from the viewer.
+ * + *Several approaches exist for improving texture sampling by accounting for the anisotropic nature of the pixel filter footprint into texture space. This + * extension provides a general mechanism for supporting anisotropic texturing filtering schemes without specifying a particular formulation of + * anisotropic filtering.
+ * + *The extension permits the OpenGL application to specify on a per-texture or -sampler object basis the maximum degree of anisotropy to account for in + * texture filtering.
+ * + *Increasing the maximum degree of anisotropy may improve texture filtering, but may also significantly reduce the implementation's texture filtering + * rate. Implementations are free to clamp the specified degree of anisotropy to the implementation's maximum supported degree of anisotropy.
+ * + *A sampler or texture's maximum degree of anisotropy is specified independently from its minification and magnification filter (as opposed to being + * supported as an entirely new filtering mode). Implementations are free to use the specified minification and magnification filter to select a + * particular anisotropic texture filtering scheme. For example, a NEAREST filter with a maximum degree of anisotropy of two could be treated as a 2-tap + * filter that accounts for the direction of anisotropy. Implementations are also permitted to ignore the minification or magnification filter and + * implement the highest quality of anisotropic filtering possible.
+ * + *Applications seeking the highest quality anisotropic filtering available are advised to request a {@link GL11#GL_LINEAR_MIPMAP_LINEAR LINEAR_MIPMAP_LINEAR} minification filter, a {@link GL11#GL_LINEAR LINEAR} + * magnification filter, and a large maximum degree of anisotropy.
+ * + *Requires {@link GL12 OpenGL 1.2}.
+ */ +public final class ARBTextureFilterAnisotropic { + + /** Accepted by the {@code pname} parameters of GetTexParameterfv, GetTexParameteriv, TexParameterf, TexParameterfv, TexParameteri, and TexParameteriv. */ + public static final int GL_TEXTURE_MAX_ANISOTROPY = 0x84FE; + + /** Accepted by the {@code pname} parameters of GetBooleanv, GetDoublev, GetFloatv, and GetIntegerv. */ + public static final int GL_MAX_TEXTURE_MAX_ANISOTROPY = 0x84FF; + + private ARBTextureFilterAnisotropic() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureFilterMinmax.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureFilterMinmax.java new file mode 100644 index 00000000..b7caa889 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureFilterMinmax.java @@ -0,0 +1,38 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_texture_filter_minmax extension. + * + *In unextended OpenGL, minification and magnification filters such as {@link GL11#GL_LINEAR LINEAR} allow texture lookups to returned a filtered texel value produced by + * computing an weighted average of a collection of texels in the neighborhood of the texture coordinate provided.
+ * + *This extension provides a new texture and sampler parameter ({@link #GL_TEXTURE_REDUCTION_MODE_ARB TEXTURE_REDUCTION_MODE_ARB}) which allows applications to produce a filtered texel value + * by computing a component-wise minimum ({@link GL14#GL_MIN MIN}) or maximum ({@link GL14#GL_MAX MAX}) of the texels that would normally be averaged. The reduction mode is orthogonal + * to the minification and magnification filter parameters. The filter parameters are used to identify the set of texels used to produce a final filtered + * value; the reduction mode identifies how these texels are combined.
+ * + *Requires {@link GL33 OpenGL 3.3}.
+ */ +public final class ARBTextureFilterMinmax { + + /** + * Accepted by the {@code pname} parameter to SamplerParameter{i f}{v}, SamplerParameterI{u}iv, GetSamplerParameter{i f}v, GetSamplerParameterI{u}iv, + * TexParameter{i f}{v}, TexParameterI{u}iv, GetTexParameter{i f}v, GetTexParameterI{u}iv, TextureParameter{i f}{v}, TextureParameterI{u}iv, + * GetTextureParameter{i f}v, and GetTextureParameterI{u}iv. + */ + public static final int GL_TEXTURE_REDUCTION_MODE_ARB = 0x9366; + + /** + * Accepted by the {@code param} or {@code params} parameter to SamplerParameter{i f}{v}, SamplerParameterI{u}iv, TexParameter{i f}{v}, TexParameterI{u}iv, + * TextureParameter{i f}{v}, and TextureParameterI{u}iv when {@code pname} is TEXTURE_REDUCTION_MODE_ARB. + */ + public static final int GL_WEIGHTED_AVERAGE_ARB = 0x9367; + + private ARBTextureFilterMinmax() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureFloat.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureFloat.java new file mode 100644 index 00000000..44491270 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureFloat.java @@ -0,0 +1,49 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_texture_float extension. + * + *This extension adds texture internal formats with 16- and 32-bit floating-point components. The 32-bit floating-point components are in the standard + * IEEE float format. The 16-bit floating-point components have 1 sign bit, 5 exponent bits, and 10 mantissa bits. Floating-point components are clamped to + * the limits of the range representable by their format.
+ * + *Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public final class ARBTextureFloat { + + /** Accepted by the {@code value} parameter of GetTexLevelParameter. */ + public static final int + GL_TEXTURE_RED_TYPE_ARB = 0x8C10, + GL_TEXTURE_GREEN_TYPE_ARB = 0x8C11, + GL_TEXTURE_BLUE_TYPE_ARB = 0x8C12, + GL_TEXTURE_ALPHA_TYPE_ARB = 0x8C13, + GL_TEXTURE_LUMINANCE_TYPE_ARB = 0x8C14, + GL_TEXTURE_INTENSITY_TYPE_ARB = 0x8C15, + GL_TEXTURE_DEPTH_TYPE_ARB = 0x8C16; + + /** Returned by the {@code params} parameter of GetTexLevelParameter. */ + public static final int GL_UNSIGNED_NORMALIZED_ARB = 0x8C17; + + /** Accepted by the {@code internalFormat} parameter of TexImage1D, TexImage2D, and TexImage3D. */ + public static final int + GL_RGBA32F_ARB = 0x8814, + GL_RGB32F_ARB = 0x8815, + GL_ALPHA32F_ARB = 0x8816, + GL_INTENSITY32F_ARB = 0x8817, + GL_LUMINANCE32F_ARB = 0x8818, + GL_LUMINANCE_ALPHA32F_ARB = 0x8819, + GL_RGBA16F_ARB = 0x881A, + GL_RGB16F_ARB = 0x881B, + GL_ALPHA16F_ARB = 0x881C, + GL_INTENSITY16F_ARB = 0x881D, + GL_LUMINANCE16F_ARB = 0x881E, + GL_LUMINANCE_ALPHA16F_ARB = 0x881F; + + private ARBTextureFloat() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureGather.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureGather.java new file mode 100644 index 00000000..75f232a0 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureGather.java @@ -0,0 +1,26 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_texture_gather extension. + * + *This extension provides a new set of texture functions (textureGather) to the shading language that determine 2x2 footprint that are used for linear + * filtering in a texture lookup, and return a vector consisting of the first component from each of the four texels in the footprint.
+ * + *Promoted to core in {@link GL40 OpenGL 4.0}.
+ */ +public final class ARBTextureGather { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 0x8E5E, + GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 0x8E5F, + GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB = 0x8F9F; + + private ARBTextureGather() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureMirrorClampToEdge.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureMirrorClampToEdge.java new file mode 100644 index 00000000..0dbbbcca --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureMirrorClampToEdge.java @@ -0,0 +1,30 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_texture_mirror_clamp_to_edge extension. + * + *ARB_texture_mirror_clamp_to_edge extends the set of texture wrap modes to include an additional mode ({@link #GL_MIRROR_CLAMP_TO_EDGE MIRROR_CLAMP_TO_EDGE}) that effectively uses a + * texture map twice as large as the original image in which the additional half of the new image is a mirror image of the original image.
+ * + *This new mode relaxes the need to generate images whose opposite edges match by using the original image to generate a matching "mirror image". This + * mode allows the texture to be mirrored only once in the negative s, t, and r directions.
+ * + *Requires {@link GL14 OpenGL 1.4}. Promoted to core in {@link GL44 OpenGL 4.4}.
+ */ +public final class ARBTextureMirrorClampToEdge { + + /** + * Accepted by the {@code param} parameter of TexParameter{if}, SamplerParameter{if} and SamplerParameter{if}v, and by the {@code params} parameter of + * TexParameter{if}v, TexParameterI{i ui}v and SamplerParameterI{i ui}v when their {@code pname} parameter is {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S}, {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T}, or + * {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R}. + */ + public static final int GL_MIRROR_CLAMP_TO_EDGE = 0x8743; + + private ARBTextureMirrorClampToEdge() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureMirroredRepeat.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureMirroredRepeat.java new file mode 100644 index 00000000..97c8ef4e --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureMirroredRepeat.java @@ -0,0 +1,28 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_texture_mirrored_repeat extension. + * + *ARB_texture_mirrored_repeat extends the set of texture wrap modes to include a mode ({@link #GL_MIRRORED_REPEAT_ARB MIRRORED_REPEAT_ARB}) that effectively uses a texture map twice + * as large at the original image in which the additional half, for each coordinate, of the new image is a mirror image of the original image.
+ * + *This new mode relaxes the need to generate images whose opposite edges match by using the original image to generate a matching "mirror image".
+ * + *Promoted to core in {@link GL14 OpenGL 1.4}.
+ */ +public final class ARBTextureMirroredRepeat { + + /** + * Accepted by the {@code param} parameter of TexParameteri and TexParameterf, and by the {@code params} parameter of TexParameteriv and TexParameterfv, + * when their {@code pname} parameter is TEXTURE_WRAP_S, TEXTURE_WRAP_T, or TEXTURE_WRAP_R. + */ + public static final int GL_MIRRORED_REPEAT_ARB = 0x8370; + + private ARBTextureMirroredRepeat() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureMultisample.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureMultisample.java new file mode 100644 index 00000000..d9b165a3 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureMultisample.java @@ -0,0 +1,173 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_texture_multisample extension. + * + *This extension provides support for two new types of "multisample textures" - two-dimensional and two-dimensional array - as well as mechanisms to + * fetch a specific sample from such a texture in a shader, and to attach such textures to FBOs for rendering.
+ * + *This extension also includes the following functionality, first described in {@link NVExplicitMultisample NV_explicit_multisample}:
+ * + *Promoted to core in {@link GL32 OpenGL 3.2}.
+ */ +public class ARBTextureMultisample { + + /** Accepted by the {@code pname} parameter of GetMultisamplefv. */ + public static final int GL_SAMPLE_POSITION = 0x8E50; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_SAMPLE_MASK = 0x8E51; + + /** Accepted by the {@code target} parameter of GetBooleani_v and GetIntegeri_v. */ + public static final int GL_SAMPLE_MASK_VALUE = 0x8E52; + + /** Accepted by the {@code target} parameter of BindTexture and TexImage2DMultisample. */ + public static final int GL_TEXTURE_2D_MULTISAMPLE = 0x9100; + + /** Accepted by the {@code target} parameter of TexImage2DMultisample. */ + public static final int GL_PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101; + + /** Accepted by the {@code target} parameter of BindTexture and TexImage3DMultisample. */ + public static final int GL_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102; + + /** Accepted by the {@code target} parameter of TexImage3DMultisample. */ + public static final int GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int + GL_MAX_SAMPLE_MASK_WORDS = 0x8E59, + GL_MAX_COLOR_TEXTURE_SAMPLES = 0x910E, + GL_MAX_DEPTH_TEXTURE_SAMPLES = 0x910F, + GL_MAX_INTEGER_SAMPLES = 0x9110, + GL_TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104, + GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105; + + /** Accepted by the {@code pname} parameter of GetTexLevelParameter. */ + public static final int + GL_TEXTURE_SAMPLES = 0x9106, + GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107; + + /** Returned by the {@code type} parameter of GetActiveUniform. */ + public static final int + GL_SAMPLER_2D_MULTISAMPLE = 0x9108, + GL_INT_SAMPLER_2D_MULTISAMPLE = 0x9109, + GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A, + GL_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B, + GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C, + GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D; + + static { GL.initialize(); } + + protected ARBTextureMultisample() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glTexImage2DMultisample, caps.glTexImage3DMultisample, caps.glGetMultisamplefv, caps.glSampleMaski + ); + } + + // --- [ glTexImage2DMultisample ] --- + + /** + * Establishes the data storage, format, dimensions, and number of samples of a 2D multisample texture's image. + * + * @param target the target of the operation. One of:| {@link GL32C#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32C#GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} |
| {@link GL32C#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} | {@link GL32C#GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL32C#GL_SAMPLE_POSITION SAMPLE_POSITION} |
| {@link GL32C#GL_SAMPLE_POSITION SAMPLE_POSITION} |
Historically one- and two- component textures have been specified in OpenGL using the intensity, luminance or luminance-alpha (I/L/LA) formats. With the + * advent of programmable shaders and render-to-texture capabilites these legacy formats carry some historical artifacts which are no longer useful.
+ * + *For example, when sampling from such textures, the luminance values are replicated across the color components, and the intensity values are replicated + * across both the color and alpha components. This is no longer necessary with programmable shaders.
+ * + *It is also desirable to be able to render to one- and two- component format textures using capabilities such as framebuffer objects (FBO), but rendering + * to I/L/LA formats is under-specified (specifically how to map R/G/B/A values to I/L/A texture channels).
+ * + *This extension adds new base internal formats for the one-component {@link GL11#GL_RED RED} and two-component {@link #GL_RG RG} (red green) texture formats as well as sized + * internal formats for fixed-point, floating-point and pure integer texture formats. The new texure formats can be used for texturing as well as for + * rendering into with framebuffer objects.
+ * + *Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public final class ARBTextureRG { + + /** Accepted by the {@code internalFormat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, and CopyTexImage2D. */ + public static final int + GL_R8 = 0x8229, + GL_R16 = 0x822A, + GL_RG8 = 0x822B, + GL_RG16 = 0x822C, + GL_R16F = 0x822D, + GL_R32F = 0x822E, + GL_RG16F = 0x822F, + GL_RG32F = 0x8230, + GL_R8I = 0x8231, + GL_R8UI = 0x8232, + GL_R16I = 0x8233, + GL_R16UI = 0x8234, + GL_R32I = 0x8235, + GL_R32UI = 0x8236, + GL_RG8I = 0x8237, + GL_RG8UI = 0x8238, + GL_RG16I = 0x8239, + GL_RG16UI = 0x823A, + GL_RG32I = 0x823B, + GL_RG32UI = 0x823C, + GL_RG = 0x8227, + GL_COMPRESSED_RED = 0x8225, + GL_COMPRESSED_RG = 0x8226; + + /** Accepted by the {@code format} parameter of TexImage1D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, and ReadPixels. */ + public static final int GL_RG_INTEGER = 0x8228; + + private ARBTextureRG() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureRGB10_A2UI.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureRGB10_A2UI.java new file mode 100644 index 00000000..37819206 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureRGB10_A2UI.java @@ -0,0 +1,28 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_texture_rgb10_a2ui extension. + * + *This extension adds support for a new texturing format for unsigned 10.10.10.2 integer textures.
+ * + *OpenGL has supported {@link GL11#GL_RGB10 RGB10} and {@link GL11#GL_RGB10_A2 RGB10_A2} formats for a very long time. This extension provides a variant of RGB10_A2 which supports unsigned + * integer data (in contrast to the above "unsigned normalized integer" formats).
+ * + *Requires {@link GL30 OpenGL 3.0} or {@link EXTTextureInteger EXT_texture_integer}. Promoted to core in {@link GL33 OpenGL 3.3}.
+ */ +public final class ARBTextureRGB10_A2UI { + + /** + * Accepted by the {@code internalFormat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D, RenderbufferStorage and + * RenderbufferStorageMultisample. + */ + public static final int GL_RGB10_A2UI = 0x906F; + + private ARBTextureRGB10_A2UI() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureRectangle.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureRectangle.java new file mode 100644 index 00000000..bfb14545 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureRectangle.java @@ -0,0 +1,61 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ARB_texture_rectangle extension. + * + *OpenGL texturing is limited to images with power-of-two dimensions and an optional 1-texel border. The ARB_texture_rectangle extension adds a new + * texture target that supports 2D textures without requiring power-of-two dimensions.
+ * + *Non-power-of-two sized (NPOTS) textures are useful for storing video images that do not have power-of-two sized (POTS). Re-sampling artifacts are + * avoided and less texture memory may be required by using non-power-of-two sized textures. Non-power-of-two sized textures are also useful for shadow + * maps and window-space texturing.
+ * + *However, non-power-of-two sized textures have limitations that do not apply to power-of-two sized textures. NPOTS textures may not use mipmap filtering; + * POTS textures support both mipmapped and non-mipmapped filtering. NPOTS textures support only the {@link GL11#GL_CLAMP CLAMP}, {@link GL12#GL_CLAMP_TO_EDGE CLAMP_TO_EDGE}, and + * {@link GL13#GL_CLAMP_TO_BORDER CLAMP_TO_BORDER} wrap modes; POTS textures support {@link GL12#GL_CLAMP_TO_EDGE CLAMP_TO_EDGE}, {@link GL11#GL_REPEAT REPEAT}, {@link GL11#GL_CLAMP CLAMP}, {@link GL14#GL_MIRRORED_REPEAT MIRRORED_REPEAT}, and {@link GL13#GL_CLAMP_TO_BORDER CLAMP_TO_BORDER} + * (and GL_MIRROR_CLAMP_ATI and GL_MIRROR_CLAMP_TO_EDGE_ATI if ATI_texture_mirror_once is supported). NPOTS textures do not + * support an optional 1-texel border; POTS textures do support an optional 1-texel border.
+ * + *NPOTS textures are accessed by dimension-dependent (aka non-normalized) texture coordinates. So instead of thinking of the texture image lying in a + * [0..1]x[0..1] range, the NPOTS texture image lies in a [0..w]x[0..h] range.
+ * + *This extension adds a new texture target and related state (proxy, binding, max texture size).
+ */ +public final class ARBTextureRectangle { + + /** + * Accepted by the {@code cap} parameter of Enable, Disable and IsEnabled; by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv and + * GetDoublev; and by the {@code target} parameter of BindTexture, GetTexParameterfv, GetTexParameteriv, TexParameterf, TexParameteri, TexParameterfv and + * TexParameteriv. + */ + public static final int GL_TEXTURE_RECTANGLE_ARB = 0x84F5; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv and GetDoublev. */ + public static final int GL_TEXTURE_BINDING_RECTANGLE_ARB = 0x84F6; + + /** Accepted by the {@code target} parameter of GetTexLevelParameteriv, GetTexLevelParameterfv, GetTexParameteriv and TexImage2D. */ + public static final int GL_PROXY_TEXTURE_RECTANGLE_ARB = 0x84F7; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv and GetFloatv. */ + public static final int GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB = 0x84F8; + + /** + * TEXTURE_RECTANGLE_ARB Returned by {@code type} parameter of GetActiveUniform when the location {@code index} for program object {@code program} is of + * type sampler2DRect. + */ + public static final int GL_SAMPLER_2D_RECT_ARB = 0x8B63; + + /** + * Returned by {@code type} parameter of GetActiveUniform when the location {@code index} for program object {@code program} is of type + * sampler2DRectShadow. + */ + public static final int GL_SAMPLER_2D_RECT_SHADOW_ARB = 0x8B64; + + private ARBTextureRectangle() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureStorage.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureStorage.java new file mode 100644 index 00000000..5a649a97 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureStorage.java @@ -0,0 +1,136 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_texture_storage extension. + * + *The texture image specification commands in OpenGL allow each level to be separately specified with different sizes, formats, types and so on, and only + * imposes consistency checks at draw time. This adds overhead for implementations.
+ * + *This extension provides a mechanism for specifying the entire structure of a texture in a single call, allowing certain consistency checks and memory + * allocations to be done up front. Once specified, the format and dimensions of the image array become immutable, to simplify completeness checks in the + * implementation.
+ * + *When using this extension, it is no longer possible to supply texture data using TexImage*. Instead, data can be uploaded using TexSubImage*, or + * produced by other means (such as render-to-texture, mipmap generation, or rendering to a sibling EGLImage).
+ * + *This extension has complicated interactions with other extensions. The goal of most of these interactions is to ensure that a texture is always mipmap + * complete (and cube complete for cubemap textures).
+ * + *Requires {@link GL12 OpenGL 1.2}. Promoted to core in {@link GL42 OpenGL 4.2}.
+ */ +public class ARBTextureStorage { + + /** Accepted by the {@code value} parameter of GetTexParameter{if}v. */ + public static final int GL_TEXTURE_IMMUTABLE_FORMAT = 0x912F; + + static { GL.initialize(); } + + protected ARBTextureStorage() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.Set| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
The {@link ARBTextureStorage ARB_texture_storage} extension and OpenGL 4.2 introduced the concept of immutable texture objects. With these objects, once their data store + * has been sized and allocated, it could not be resized for the lifetime of the objects (although its content could be updated). OpenGL implementations + * may be able to take advantage of the knowledge that the underlying data store of certain objects cannot be deleted or otherwise reallocated without + * destruction of the whole object (normally, a much heavier weight and less frequent operation). Immutable storage for all types of textures besides + * multisample and buffer textures was introduced by ARB_texture_storage. For completeness, this extension introduces immutable storage for multisampled + * textures.
+ * + *Requires {@link GL42 OpenGL 4.2} or {@link ARBTextureStorage ARB_texture_storage}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public class ARBTextureStorageMultisample { + + static { GL.initialize(); } + + protected ARBTextureStorageMultisample() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.Set| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} |
Classic OpenGL texture formats conflate texture storage and interpretation, and assume that textures represent color. In modern applications, a + * significant quantity of textures don't represent color, but rather data like shadow maps, normal maps, page tables, occlusion data, etc. For the latter + * class of data, calling the data "RGBA" is just a convenient mapping of what the data is onto the current model, but isn't an accurate reflection of the + * reality of the data.
+ * + *The existing texture formats provide an almost orthogonal set of data types, sizes, and number of components, but the mappings of this storage into what + * the shader or fixed-function pipeline fetches is very much non-orthogonal. Previous extensions have added some of the most demanded missing formats, but + * the problem has not been solved once and for all.
+ * + *This extension provides a mechanism to swizzle the components of a texture before they are applied according to the texture environment in + * fixed-function or as they are returned to the shader.
+ * + *Promoted to core in {@link GL33 OpenGL 3.3}.
+ */ +public final class ARBTextureSwizzle { + + /** Accepted by the {@code pname} parameters of TexParameteri, TexParameterf, TexParameteriv, TexParameterfv, GetTexParameterfv, and GetTexParameteriv. */ + public static final int + GL_TEXTURE_SWIZZLE_R = 0x8E42, + GL_TEXTURE_SWIZZLE_G = 0x8E43, + GL_TEXTURE_SWIZZLE_B = 0x8E44, + GL_TEXTURE_SWIZZLE_A = 0x8E45; + + /** Accepted by the {@code pname} parameters of TexParameteriv, TexParameterfv, GetTexParameterfv, and GetTexParameteriv. */ + public static final int GL_TEXTURE_SWIZZLE_RGBA = 0x8E46; + + private ARBTextureSwizzle() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureView.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureView.java new file mode 100644 index 00000000..dbbbd617 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTextureView.java @@ -0,0 +1,77 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_texture_view extension. + * + *This extension allows a texture's data store to be "viewed" in multiple ways, either reinterpreting the data format/type as a different format/type with + * the same element size, or by clamping the mipmap level range or array slice range.
+ * + *The goals of this extension are to avoid having these alternate views become shared mutable containers of shared mutable objects, and to add the views + * to the API in a minimally invasive way.
+ * + *No new object types are added. Conceptually, a texture object is split into the following parts:
+ * + *With this extension, multiple textures can share a data store and have different state describing which portions of the data store to use and how to + * interpret the data elements. The data store is refcounted and not destroyed until the last texture sharing it is deleted.
+ * + *This extension leverages the {@link ARBTextureStorage ARB_texture_storage} concept of an "immutable texture". Views can only be created of textures created with TexStorage.
+ * + *Requires {@link GL42 OpenGL 4.2} or {@link ARBTextureStorage ARB_texture_storage}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public class ARBTextureView { + + /** Accepted by the {@code pname} parameters of GetTexParameterfv and GetTexParameteriv. */ + public static final int + GL_TEXTURE_VIEW_MIN_LEVEL = 0x82DB, + GL_TEXTURE_VIEW_NUM_LEVELS = 0x82DC, + GL_TEXTURE_VIEW_MIN_LAYER = 0x82DD, + GL_TEXTURE_VIEW_NUM_LAYERS = 0x82DE, + GL_TEXTURE_IMMUTABLE_LEVELS = 0x82DF; + + static { GL.initialize(); } + + protected ARBTextureView() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glTextureView + ); + } + + // --- [ glTextureView ] --- + + /** + * Initializes a texture as a data alias of another texture's data store. + * + * @param texture the texture object to be initialized as a view + * @param target the target to be used for the newly initialized texture + * @param origtexture the name of a texture object of which to make a view + * @param internalformat the internal format for the newly created view + * @param minlevel the lowest level of detail of the view + * @param numlevels the number of levels of detail to include in the view + * @param minlayer the index of the first layer to include in the view + * @param numlayers the number of layers to include in the view + */ + public static void glTextureView(@NativeType("GLuint") int texture, @NativeType("GLenum") int target, @NativeType("GLuint") int origtexture, @NativeType("GLenum") int internalformat, @NativeType("GLuint") int minlevel, @NativeType("GLuint") int numlevels, @NativeType("GLuint") int minlayer, @NativeType("GLuint") int numlayers) { + GL43C.glTextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTimerQuery.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTimerQuery.java new file mode 100644 index 00000000..c4ce6280 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTimerQuery.java @@ -0,0 +1,134 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_timer_query extension. + * + *Applications can benefit from accurate timing information in a number of different ways. During application development, timing information can help + * identify application or driver bottlenecks. At run time, applications can use timing information to dynamically adjust the amount of detail in a scene + * to achieve constant frame rates. OpenGL implementations have historically provided little to no useful timing information. Applications can get some + * idea of timing by reading timers on the CPU, but these timers are not synchronized with the graphics rendering pipeline. Reading a CPU timer does not + * guarantee the completion of a potentially large amount of graphics work accumulated before the timer is read, and will thus produce wildly inaccurate + * results. {@link GL11C#glFinish Finish} can be used to determine when previous rendering commands have been completed, but will idle the graphics pipeline and adversely + * affect application performance.
+ * + *This extension provides a query mechanism that can be used to determine the amount of time it takes to fully complete a set of GL commands, and without + * stalling the rendering pipeline. It uses the query object mechanisms first introduced in the occlusion query extension, which allow time intervals to be + * polled asynchronously by the application.
+ * + *Promoted to core in {@link GL33 OpenGL 3.3}.
+ */ +public class ARBTimerQuery { + + /** Accepted by the {@code target} parameter of BeginQuery, EndQuery, and GetQueryiv. */ + public static final int GL_TIME_ELAPSED = 0x88BF; + + /** + * Accepted by the {@code target} parameter of GetQueryiv and QueryCounter. Accepted by the {@code value} parameter of GetBooleanv, GetIntegerv, + * GetInteger64v, GetFloatv, and GetDoublev. + */ + public static final int GL_TIMESTAMP = 0x8E28; + + static { GL.initialize(); } + + protected ARBTimerQuery() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glQueryCounter, caps.glGetQueryObjecti64v, caps.glGetQueryObjectui64v + ); + } + + // --- [ glQueryCounter ] --- + + /** + * Records the GL time into a query object after all previous commands have reached the GL server but have not yet necessarily executed. + * + * @param id the name of a query object into which to record the GL time + * @param target the counter to query. Must be:| {@link GL33C#GL_TIMESTAMP TIMESTAMP} |
| {@link GL15#GL_QUERY_RESULT QUERY_RESULT} | {@link GL15#GL_QUERY_RESULT_AVAILABLE QUERY_RESULT_AVAILABLE} |
| {@link GL15#GL_QUERY_RESULT QUERY_RESULT} | {@link GL15#GL_QUERY_RESULT_AVAILABLE QUERY_RESULT_AVAILABLE} |
The {@link EXTTransformFeedback EXT_transform_feedback} extension allows applications to capture primitives to one or more buffer objects when transformed by the GL. This + * extension provides a few additional capabilities to these extensions, making transform feedback mode more useful.
+ * + *First, it provides transform feedback objects which encapsulate transform feedback-related state, allowing applications to replace the entire transform + * feedback configuration in a single bind call. Second, it provides the ability to pause and resume transform feedback operations. When transform feedback + * is paused, applications may render without transform feedback or may use transform feedback with different state and a different transform feedback + * object. When transform feedback is resumed, additional primitives are captured and appended to previously captured primitives for the object.
+ * + *Additionally, this extension provides the ability to draw primitives captured in transform feedback mode without querying the captured primitive count.
+ * The command {@link #glDrawTransformFeedback DrawTransformFeedback} is equivalent to {@code glDrawArrays(
Requires {@link GL20 GL20} or {@link ARBShaderObjects ARB_shader_objects} and {@link NVTransformFeedback NV_transform_feedback} or {@link EXTTransformFeedback EXT_transform_feedback}. + * Promoted to core in {@link GL40 OpenGL 4.0}.
+ */ +public class ARBTransformFeedback2 { + + /** Accepted by the {@code target} parameter of BindTransformFeedback. */ + public static final int GL_TRANSFORM_FEEDBACK = 0x8E22; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int + GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23, + GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24, + GL_TRANSFORM_FEEDBACK_BINDING = 0x8E25; + + static { GL.initialize(); } + + protected ARBTransformFeedback2() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBindTransformFeedback, caps.glDeleteTransformFeedbacks, caps.glGenTransformFeedbacks, caps.glIsTransformFeedback, + caps.glPauseTransformFeedback, caps.glResumeTransformFeedback, caps.glDrawTransformFeedback + ); + } + + // --- [ glBindTransformFeedback ] --- + + /** + * Binds a transform feedback object. + * + * @param target the target to which to bind the transform feedback object {@code id}. Must be:| {@link GL40C#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
When transform feedback operations are paused, transform feedback is still considered active and changing most transform feedback state related to the + * object results in an error. However, a new transform feedback object may be bound while transform feedback is paused. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} + * is generated by PauseTransformFeedback if the currently bound transform feedback is not active or is paused.
+ * + *When transform feedback is active and not paused, all geometric primitives generated must be compatible with the value of {@code primitiveMode} passed + * to {@link GL30C#glBeginTransformFeedback BeginTransformFeedback}. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated by {@link GL11#glBegin Begin} or any operation that implicitly calls {@link GL11#glBegin Begin} + * (such as {@link GL11C#glDrawElements DrawElements}) if {@code mode} is not one of the allowed modes. If a geometry shader is active, its output primitive type is used instead + * of the {@code mode} parameter passed to {@link GL11#glBegin Begin} for the purposes of this error check. Any primitive type may be used while transform feedback is + * paused.
+ */ + public static void glPauseTransformFeedback() { + GL40C.glPauseTransformFeedback(); + } + + // --- [ glResumeTransformFeedback ] --- + + /** + * Resumes transform feedback operations for the currently bound transform feedback object. + * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated by {@link #glResumeTransformFeedback ResumeTransformFeedback} if the currently bound transform feedback is not active or is not paused.
+ */ + public static void glResumeTransformFeedback() { + GL40C.glResumeTransformFeedback(); + } + + // --- [ glDrawTransformFeedback ] --- + + /** + * Render primitives using a count derived from a transform feedback object. + * + * @param mode what kind of primitives to render. One of:| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
This extension further extends the transform feedback capabilities provided by the {@link EXTTransformFeedback EXT_transform_feedback}, {@link NVTransformFeedback NV_transform_feedback}, and + * {@link NVTransformFeedback2 NV_transform_feedback2} extensions. Those extensions provided a new transform feedback mode, where selected vertex attributes can be recorded to + * a buffer object for each primitive processed by the GL.
+ * + *This extension provides increased flexibility in how vertex attributes can be written to buffer objects. Previous extensions allowed applications to + * record a set of attributes interleaved into a single buffer object (interleaved mode) or to record into multiple objects, but with only a single + * attribute per buffer (separate mode). This extension extends interleaved mode to write into multiple buffers, with multiple attributes per buffer. This + * capability is supported for all three styles of transform feedback:
+ * + *Additionally, this extension adds new support for multiple separate vertex streams. New geometry shader functionality provided by the + * {@link ARBGPUShader5 ARB_gpu_shader5} and NV_gpu_program5 extensions allows geometry shaders to direct each vertex arbitrarily at a specified + * vertex stream. For example, a geometry program might write each "regular" vertex it emits to one vertex stream while writing some per-primitive data it + * computes to a second vertex stream. This extension allows applications to choose a vertex stream for each buffer object it writes to, and allows the + * vertices written to each vertex stream to be recorded in separate buffer objects. Only one stream may be selected for rasterization, and in the initial + * implementation, the geometry shader output topology must be {@link GL11#GL_POINTS POINTS} if multiple streams are used. When geometry shaders are not used, or when an old + * geometry shader not writing multiple streams is used, all vertices produced by the GL are directed at the stream numbered zero. The set of transform + * feedback-related query targets is extended to accommodate multiple vertex streams, so it is possible to count the number of processed and recorded + * primitives for each stream separately.
+ * + *Requires {@link GL30 OpenGL 3.0} or {@link EXTTransformFeedback EXT_transform_feedback} or {@link NVTransformFeedback NV_transform_feedback}. Promoted to core in {@link GL40 OpenGL 4.0}.
+ */ +public class ARBTransformFeedback3 { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int + GL_MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70, + GL_MAX_VERTEX_STREAMS = 0x8E71; + + static { GL.initialize(); } + + protected ARBTransformFeedback3() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDrawTransformFeedbackStream, caps.glBeginQueryIndexed, caps.glEndQueryIndexed, caps.glGetQueryIndexediv + ); + } + + // --- [ glDrawTransformFeedbackStream ] --- + + /** + * Renders primitives using a count derived from a specifed stream of a transform feedback object. + * + * @param mode what kind of primitives to render. One of:| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
Multiple instances of geometry may be specified to the GL by calling functions such as {@link GL31C#glDrawArraysInstanced DrawArraysInstanced} and {@link GL31C#glDrawElementsInstanced DrawElementsInstanced}. + * Further, the results of a transform feedback operation may be returned to the GL by calling {@link GL40C#glDrawTransformFeedback DrawTransformFeedback}, or + * {@link GL40C#glDrawTransformFeedbackStream DrawTransformFeedbackStream}. However, it is not presently possible to draw multiple instances of data transform feedback without using a query + * and the resulting round trip from server to client.
+ * + *This extension adds functionality to draw multiple instances of the result of a transform feedback operation.
+ * + *Requires {@link GL40 OpenGL 4.0} or {@link ARBTransformFeedback2 ARB_transform_feedback2}. Requires {@link GL31 OpenGL 3.1} or {@link ARBDrawInstanced ARB_draw_instanced}. Promoted to core in {@link GL42 OpenGL 4.2}.
+ */ +public class ARBTransformFeedbackInstanced { + + static { GL.initialize(); } + + protected ARBTransformFeedbackInstanced() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDrawTransformFeedbackInstanced, caps.glDrawTransformFeedbackStreamInstanced + ); + } + + // --- [ glDrawTransformFeedbackInstanced ] --- + + /** + * Renders multiple instances of primitives using a count derived from a transform feedback object. + * + * @param mode what kind of primitives to render. One of:| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
This extension adds new query types which can be used to detect overflow of transform feedback buffers. The new query types are also accepted by + * conditional rendering commands.
+ * + *Requires {@link GL30 OpenGL 3.0}.
+ */ +public final class ARBTransformFeedbackOverflowQuery { + + /** + * Accepted by the {@code target} parameter of {@link GL15C#glBeginQuery BeginQuery}, {@link GL15C#glEndQuery EndQuery}, {@link GL15C#glGetQueryiv GetQueryiv}, + * {@link GL40C#glBeginQueryIndexed BeginQueryIndexed}, {@link GL40C#glEndQueryIndexed EndQueryIndexed} and {@link GL40C#glGetQueryIndexediv GetQueryIndexediv}. + */ + public static final int + GL_TRANSFORM_FEEDBACK_OVERFLOW_ARB = 0x82EC, + GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB = 0x82ED; + + private ARBTransformFeedbackOverflowQuery() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTransposeMatrix.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTransposeMatrix.java new file mode 100644 index 00000000..2b0a3263 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBTransposeMatrix.java @@ -0,0 +1,167 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the ARB_transpose_matrix extension. + * + *New functions and tokens are added allowing application matrices stored in row major order rather than column major order to be transferred to the + * OpenGL implementation. This allows an application to use standard C-language 2-dimensional arrays ({@code m[row][col]}) and have the array indices match the + * expected matrix row and column indexes. These arrays are referred to as transpose matrices since they are the transpose of the standard matrices passed + * to OpenGL.
+ * + *This extension adds an interface for transfering data to and from the OpenGL pipeline, it does not change any OpenGL processing or imply any changes in + * state representation.
+ * + *Promoted to core in {@link GL13 OpenGL 1.3}.
+ */ +public class ARBTransposeMatrix { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = 0x84E3, + GL_TRANSPOSE_PROJECTION_MATRIX_ARB = 0x84E4, + GL_TRANSPOSE_TEXTURE_MATRIX_ARB = 0x84E5, + GL_TRANSPOSE_COLOR_MATRIX_ARB = 0x84E6; + + static { GL.initialize(); } + + protected ARBTransposeMatrix() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glLoadTransposeMatrixfARB, caps.glLoadTransposeMatrixdARB, caps.glMultTransposeMatrixfARB, caps.glMultTransposeMatrixdARB + ); + } + + // --- [ glLoadTransposeMatrixfARB ] --- + + /** Unsafe version of: {@link #glLoadTransposeMatrixfARB LoadTransposeMatrixfARB} */ + public static native void nglLoadTransposeMatrixfARB(long m); + + /** + * Sets the current matrix to a 4 × 4 matrix in row-major order. + * + *The matrix is stored as 16 consecutive values, i.e. as:
+ * + *| a1 | a2 | a3 | a4 |
| a5 | a6 | a7 | a8 |
| a9 | a10 | a11 | a12 |
| a13 | a14 | a15 | a16 |
This extension introduces the concept of a group of GLSL uniforms known as a "uniform block", and the API mechanisms to store "uniform blocks" in GL + * buffer objects.
+ * + *The extension also defines both a standard cross-platform layout in memory for uniform block data, as well as mechanisms to allow the GL to optimize the + * data layout in an implementation-defined manner.
+ * + *Prior to this extension, the existing interface for modification of uniform values allowed modification of large numbers of values using glUniform* + * calls, but only for a single uniform name (or a uniform array) at a time. However, updating uniforms in this manner may not map well to heterogenous + * uniform data structures defined for a GL application and in these cases, the application is forced to either:
+ * + *These solutions have their disadvantages. Solution A imposes considerable development overhead on the application developer. Solution B may impose + * considerable run-time overhead on the application if the number of uniforms modified in a given frame of rendering is sufficiently large.
+ * + *This extension provides a better alternative to either (A) or (B) by allowing buffer object backing for the storage associated with all uniforms of a + * given GLSL program.
+ * + *Storing uniform blocks in buffer objects enables several key use cases:
+ * + *The data storage for a uniform block can be declared to use one of three layouts in memory: packed, shared, or std140.
+ * + *Any uniforms not declared in a named uniform block are said to be part of the "default uniform block".
+ * + *While uniforms in the default uniform block are updated with glUniform* entry points and can have static initializers, uniforms in named uniform blocks + * are not. Instead, uniform block data is updated using the routines that update buffer objects and can not use static initializers.
+ * + *Rules and Concepts Guiding this Specification:
+ * + *For reference, a uniform has a "uniform index" (subsequently referred to as "u_index) and also a "uniform location" to efficiently identify it in the + * uniform data store of the implementation. We subsequently refer to this uniform data store of the implementation as the "uniform database".
+ * + *A "uniform block" only has a "uniform block index" used for queries and connecting the "uniform block" to a buffer object. A "uniform block" has no + * "location" because "uniform blocks" are not updated directly. The buffer object APIs are used instead.
+ * + *Properties of Uniforms and uniform blocks:
+ * + *Requires {@link GL20 OpenGL 2.0} or {@link ARBShaderObjects ARB_shader_objects} and {@link GL15 OpenGL 1.5} or {@link ARBVertexBufferObject ARB_vertex_buffer_object}. Promoted to core in {@link GL31 OpenGL 3.1}.
+ */ +public class ARBUniformBufferObject { + + /** Accepted by the {@code target} parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, and GetBufferPointerv. */ + public static final int GL_UNIFORM_BUFFER = 0x8A11; + + /** Accepted by the {@code pname} parameter of GetIntegeri_v, GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_UNIFORM_BUFFER_BINDING = 0x8A28; + + /** Accepted by the {@code pname} parameter of GetIntegeri_v. */ + public static final int + GL_UNIFORM_BUFFER_START = 0x8A29, + GL_UNIFORM_BUFFER_SIZE = 0x8A2A; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B, + GL_MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C, + GL_MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D, + GL_MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E, + GL_MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F, + GL_MAX_UNIFORM_BLOCK_SIZE = 0x8A30, + GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31, + GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32, + GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33, + GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34; + + /** Accepted by the {@code pname} parameter of GetProgramiv. */ + public static final int + GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35, + GL_ACTIVE_UNIFORM_BLOCKS = 0x8A36; + + /** Accepted by the {@code pname} parameter of GetActiveUniformsiv. */ + public static final int + GL_UNIFORM_TYPE = 0x8A37, + GL_UNIFORM_SIZE = 0x8A38, + GL_UNIFORM_NAME_LENGTH = 0x8A39, + GL_UNIFORM_BLOCK_INDEX = 0x8A3A, + GL_UNIFORM_OFFSET = 0x8A3B, + GL_UNIFORM_ARRAY_STRIDE = 0x8A3C, + GL_UNIFORM_MATRIX_STRIDE = 0x8A3D, + GL_UNIFORM_IS_ROW_MAJOR = 0x8A3E; + + /** Accepted by the {@code pname} parameter of GetActiveUniformBlockiv. */ + public static final int + GL_UNIFORM_BLOCK_BINDING = 0x8A3F, + GL_UNIFORM_BLOCK_DATA_SIZE = 0x8A40, + GL_UNIFORM_BLOCK_NAME_LENGTH = 0x8A41, + GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42, + GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43, + GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44, + GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45, + GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46; + + /** Returned by GetActiveUniformsiv and GetUniformBlockIndex. */ + public static final int GL_INVALID_INDEX = 0xFFFFFFFF; + + static { GL.initialize(); } + + protected ARBUniformBufferObject() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetUniformIndices, caps.glGetActiveUniformsiv, caps.glGetActiveUniformName, caps.glGetUniformBlockIndex, caps.glGetActiveUniformBlockiv, + caps.glGetActiveUniformBlockName, caps.glBindBufferRange, caps.glBindBufferBase, caps.glGetIntegeri_v, caps.glUniformBlockBinding + ); + } + + // --- [ glGetUniformIndices ] --- + + /** + * Unsafe version of: {@link #glGetUniformIndices GetUniformIndices} + * + * @param uniformCount the number of uniforms whose indices to query + */ + public static void nglGetUniformIndices(int program, int uniformCount, long uniformNames, long uniformIndices) { + GL31C.nglGetUniformIndices(program, uniformCount, uniformNames, uniformIndices); + } + + /** + * Retrieves the indices of a number of uniforms within a program object + * + * @param program the name of a program containing uniforms whose indices to query + * @param uniformNames an array of pointers to buffers containing the names of the queried uniforms + * @param uniformIndices an array that will receive the indices of the uniforms + */ + public static void glGetUniformIndices(@NativeType("GLuint") int program, @NativeType("GLchar const **") PointerBuffer uniformNames, @NativeType("GLuint *") IntBuffer uniformIndices) { + GL31C.glGetUniformIndices(program, uniformNames, uniformIndices); + } + + /** + * Retrieves the indices of a number of uniforms within a program object + * + * @param program the name of a program containing uniforms whose indices to query + * @param uniformNames an array of pointers to buffers containing the names of the queried uniforms + * @param uniformIndices an array that will receive the indices of the uniforms + */ + public static void glGetUniformIndices(@NativeType("GLuint") int program, @NativeType("GLchar const **") CharSequence[] uniformNames, @NativeType("GLuint *") IntBuffer uniformIndices) { + GL31C.glGetUniformIndices(program, uniformNames, uniformIndices); + } + + /** + * Retrieves the indices of a number of uniforms within a program object + * + * @param program the name of a program containing uniforms whose indices to query + */ + @NativeType("void") + public static int glGetUniformIndices(@NativeType("GLuint") int program, @NativeType("GLchar const **") CharSequence uniformName) { + return GL31C.glGetUniformIndices(program, uniformName); + } + + // --- [ glGetActiveUniformsiv ] --- + + /** + * Unsafe version of: {@link #glGetActiveUniformsiv GetActiveUniformsiv} + * + * @param uniformCount the number of elements in the array of indices {@code uniformIndices} and the number of parameters written to {@code params} upon successful return + */ + public static void nglGetActiveUniformsiv(int program, int uniformCount, long uniformIndices, int pname, long params) { + GL31C.nglGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); + } + + /** + * Returns information about several active uniform variables for the specified program object. + * + * @param program the program object to be queried + * @param uniformIndices an array of {@code uniformCount} integers containing the indices of uniforms within {@code program} + * @param pname the property of the each uniform in {@code uniformIndices} that should be written into the corresponding element of {@code params} + * @param params an array of {@code uniformCount} integers which are to receive the value of {@code pname} for each uniform in {@code uniformIndices} + */ + public static void glGetActiveUniformsiv(@NativeType("GLuint") int program, @NativeType("GLuint const *") IntBuffer uniformIndices, @NativeType("GLenum") int pname, @NativeType("GLint *") IntBuffer params) { + GL31C.glGetActiveUniformsiv(program, uniformIndices, pname, params); + } + + /** + * Returns information about several active uniform variables for the specified program object. + * + * @param program the program object to be queried + * @param pname the property of the each uniform in {@code uniformIndices} that should be written into the corresponding element of {@code params} + */ + @NativeType("void") + public static int glGetActiveUniformsi(@NativeType("GLuint") int program, @NativeType("GLuint const *") int uniformIndex, @NativeType("GLenum") int pname) { + return GL31C.glGetActiveUniformsi(program, uniformIndex, pname); + } + + // --- [ glGetActiveUniformName ] --- + + /** + * Unsafe version of: {@link #glGetActiveUniformName GetActiveUniformName} + * + * @param bufSize the size of the buffer, in units of {@code GLchar}, of the buffer whose address is specified in {@code uniformName} + */ + public static void nglGetActiveUniformName(int program, int uniformIndex, int bufSize, long length, long uniformName) { + GL31C.nglGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); + } + + /** + * Queries the name of an active uniform. + * + * @param program the program containing the active uniform index {@code uniformIndex} + * @param uniformIndex the index of the active uniform whose name to query + * @param length the address of a variable that will receive the number of characters that were or would have been written to the buffer addressed by {@code uniformName} + * @param uniformName the address of a buffer into which the GL will place the name of the active uniform at {@code uniformIndex} within {@code program} + */ + public static void glGetActiveUniformName(@NativeType("GLuint") int program, @NativeType("GLuint") int uniformIndex, @Nullable @NativeType("GLsizei *") IntBuffer length, @NativeType("GLchar *") ByteBuffer uniformName) { + GL31C.glGetActiveUniformName(program, uniformIndex, length, uniformName); + } + + /** + * Queries the name of an active uniform. + * + * @param program the program containing the active uniform index {@code uniformIndex} + * @param uniformIndex the index of the active uniform whose name to query + * @param bufSize the size of the buffer, in units of {@code GLchar}, of the buffer whose address is specified in {@code uniformName} + */ + @NativeType("void") + public static String glGetActiveUniformName(@NativeType("GLuint") int program, @NativeType("GLuint") int uniformIndex, @NativeType("GLsizei") int bufSize) { + return GL31C.glGetActiveUniformName(program, uniformIndex, bufSize); + } + + /** + * Queries the name of an active uniform. + * + * @param program the program containing the active uniform index {@code uniformIndex} + * @param uniformIndex the index of the active uniform whose name to query + */ + @NativeType("void") + public static String glGetActiveUniformName(@NativeType("GLuint") int program, @NativeType("GLuint") int uniformIndex) { + return glGetActiveUniformName(program, uniformIndex, glGetActiveUniformsi(program, uniformIndex, GL_UNIFORM_NAME_LENGTH)); + } + + // --- [ glGetUniformBlockIndex ] --- + + /** Unsafe version of: {@link #glGetUniformBlockIndex GetUniformBlockIndex} */ + public static int nglGetUniformBlockIndex(int program, long uniformBlockName) { + return GL31C.nglGetUniformBlockIndex(program, uniformBlockName); + } + + /** + * Retrieves the index of a named uniform block. + * + * @param program the name of a program containing the uniform block + * @param uniformBlockName an array of characters to containing the name of the uniform block whose index to retrieve + */ + @NativeType("GLuint") + public static int glGetUniformBlockIndex(@NativeType("GLuint") int program, @NativeType("GLchar const *") ByteBuffer uniformBlockName) { + return GL31C.glGetUniformBlockIndex(program, uniformBlockName); + } + + /** + * Retrieves the index of a named uniform block. + * + * @param program the name of a program containing the uniform block + * @param uniformBlockName an array of characters to containing the name of the uniform block whose index to retrieve + */ + @NativeType("GLuint") + public static int glGetUniformBlockIndex(@NativeType("GLuint") int program, @NativeType("GLchar const *") CharSequence uniformBlockName) { + return GL31C.glGetUniformBlockIndex(program, uniformBlockName); + } + + // --- [ glGetActiveUniformBlockiv ] --- + + /** Unsafe version of: {@link #glGetActiveUniformBlockiv GetActiveUniformBlockiv} */ + public static void nglGetActiveUniformBlockiv(int program, int uniformBlockIndex, int pname, long params) { + GL31C.nglGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); + } + + /** + * Queries information about an active uniform block. + * + * @param program the name of a program containing the uniform block + * @param uniformBlockIndex the index of the uniform block within {@code program} + * @param pname the name of the parameter to query. One of:| {@link GL31C#GL_UNIFORM_BLOCK_BINDING UNIFORM_BLOCK_BINDING} | {@link GL31C#GL_UNIFORM_BLOCK_DATA_SIZE UNIFORM_BLOCK_DATA_SIZE} |
| {@link GL31C#GL_UNIFORM_BLOCK_NAME_LENGTH UNIFORM_BLOCK_NAME_LENGTH} | {@link GL31C#GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS UNIFORM_BLOCK_ACTIVE_UNIFORMS} |
| {@link GL31C#GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES} | {@link GL31C#GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER} |
| {@link GL31C#GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER} | {@link GL31C#GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER} |
| {@link GL31C#GL_UNIFORM_BLOCK_BINDING UNIFORM_BLOCK_BINDING} | {@link GL31C#GL_UNIFORM_BLOCK_DATA_SIZE UNIFORM_BLOCK_DATA_SIZE} |
| {@link GL31C#GL_UNIFORM_BLOCK_NAME_LENGTH UNIFORM_BLOCK_NAME_LENGTH} | {@link GL31C#GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS UNIFORM_BLOCK_ACTIVE_UNIFORMS} |
| {@link GL31C#GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES} | {@link GL31C#GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER} |
| {@link GL31C#GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER} | {@link GL31C#GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER} |
| {@link GL30C#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} |
| {@link GL30C#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} |
This extension provides a single new component format for vertex arrays to read 4-component unsigned byte vertex attributes with a BGRA component + * ordering.
+ * + *OpenGL expects vertex arrays containing 4 unsigned bytes per element to be in the RGBA, STRQ, or XYZW order (reading components left-to-right in their + * lower address to higher address order). Essentially the order the components appear in memory is the order the components appear in the resulting vertex + * attribute vector.
+ * + *However Direct3D has color (diffuse and specular) vertex arrays containing 4 unsigned bytes per element that are in a BGRA order (again reading + * components left-to-right in their lower address to higher address order). Direct3D calls this "ARGB" reading the components in the opposite order + * (reading components left-to-right in their higher address to lower address order). This ordering is generalized in the DirectX 10 by the + * DXGI_FORMAT_B8G8R8A8_UNORM format.
+ * + *For an OpenGL application to source color data from a vertex buffer formatted for Direct3D's color array format conventions, the application is forced + * to either:
+ * + *Neither option is entirely satisfactory.
+ * + *Option 1 means vertex shaders have to be re-written to source colors differently. If the same vertex shader is used with vertex arrays configured to + * source the color as 4 floating-point color components, the swizzle for BGRA colors stored as 4 unsigned bytes is no longer appropriate. The shader's + * swizzling of colors becomes dependent on the type and number of color components. Ideally the vertex shader should be independent from the format and + * component ordering of the data it sources.
+ * + *Option 2 is expensive because vertex buffers may have to be reformatted prior to use. OpenGL treats the memory for vertex arrays (whether client-side + * memory or buffer objects) as essentially untyped memory and vertex arrays can be stored separately, interleaved, or even interwoven (where multiple + * arrays overlap with differing strides and formats).
+ * + *Rather than force a re-ordering of either vertex array components in memory or a vertex array format-dependent re-ordering of vertex shader inputs, + * OpenGL can simply provide a vertex array format that matches the Direct3D color component ordering.
+ * + *This approach mimics that of the {@link EXTBGRA EXT_bgra} extension for pixel and texel formats except for vertex instead of image data.
+ * + *Promoted to core in {@link GL32 OpenGL 3.2}.
+ */ +public final class ARBVertexArrayBGRA { + + /** Accepted by the {@code size} parameter of ColorPointer, SecondaryColorPointer, and VertexAttribPointer. */ + public static final int GL_BGRA = 0x80E1; + + private ARBVertexArrayBGRA() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBVertexArrayObject.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBVertexArrayObject.java new file mode 100644 index 00000000..a090d25e --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBVertexArrayObject.java @@ -0,0 +1,127 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_vertex_array_object extension. + * + *This extension introduces named vertex array objects which encapsulate vertex array state on the client side. These objects allow applications to + * rapidly switch between large sets of array state. In addition, layered libraries can return to the default array state by simply creating and binding a + * new vertex array object.
+ * + *This extension differs from GL_APPLE_vertex_array_object in that client memory cannot be accessed through a non-zero vertex array object. It also + * differs in that vertex array objects are explicitly not sharable between contexts.
+ * + *Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public class ARBVertexArrayObject { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_VERTEX_ARRAY_BINDING = 0x85B5; + + static { GL.initialize(); } + + protected ARBVertexArrayObject() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBindVertexArray, caps.glDeleteVertexArrays, caps.glGenVertexArrays, caps.glIsVertexArray + ); + } + + // --- [ glBindVertexArray ] --- + + /** + * Binds a vertex array object + * + * @param array the name of the vertex array to bind + */ + public static void glBindVertexArray(@NativeType("GLuint") int array) { + GL30C.glBindVertexArray(array); + } + + // --- [ glDeleteVertexArrays ] --- + + /** + * Unsafe version of: {@link #glDeleteVertexArrays DeleteVertexArrays} + * + * @param n the number of vertex array objects to be deleted + */ + public static void nglDeleteVertexArrays(int n, long arrays) { + GL30C.nglDeleteVertexArrays(n, arrays); + } + + /** + * Deletes vertex array objects. + * + * @param arrays an array containing the n names of the objects to be deleted + */ + public static void glDeleteVertexArrays(@NativeType("GLuint const *") IntBuffer arrays) { + GL30C.glDeleteVertexArrays(arrays); + } + + /** Deletes vertex array objects. */ + public static void glDeleteVertexArrays(@NativeType("GLuint const *") int array) { + GL30C.glDeleteVertexArrays(array); + } + + // --- [ glGenVertexArrays ] --- + + /** + * Unsafe version of: {@link #glGenVertexArrays GenVertexArrays} + * + * @param n the number of vertex array object names to generate + */ + public static void nglGenVertexArrays(int n, long arrays) { + GL30C.nglGenVertexArrays(n, arrays); + } + + /** + * Generates vertex array object names. + * + * @param arrays a buffer in which the generated vertex array object names are stored + */ + public static void glGenVertexArrays(@NativeType("GLuint *") IntBuffer arrays) { + GL30C.glGenVertexArrays(arrays); + } + + /** Generates vertex array object names. */ + @NativeType("void") + public static int glGenVertexArrays() { + return GL30C.glGenVertexArrays(); + } + + // --- [ glIsVertexArray ] --- + + /** + * Determines if a name corresponds to a vertex array object. + * + * @param array a value that may be the name of a vertex array object + */ + @NativeType("GLboolean") + public static boolean glIsVertexArray(@NativeType("GLuint") int array) { + return GL30C.glIsVertexArray(array); + } + + /** Array version of: {@link #glDeleteVertexArrays DeleteVertexArrays} */ + public static void glDeleteVertexArrays(@NativeType("GLuint const *") int[] arrays) { + GL30C.glDeleteVertexArrays(arrays); + } + + /** Array version of: {@link #glGenVertexArrays GenVertexArrays} */ + public static void glGenVertexArrays(@NativeType("GLuint *") int[] arrays) { + GL30C.glGenVertexArrays(arrays); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBVertexAttrib64Bit.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBVertexAttrib64Bit.java new file mode 100644 index 00000000..9de44e47 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBVertexAttrib64Bit.java @@ -0,0 +1,309 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the ARB_vertex_attrib_64bit extension. + * + *This extension provides OpenGL shading language support for vertex shader inputs with 64-bit floating-point components and OpenGL API support for + * specifying the value of those inputs using vertex array or immediate mode entry points. This builds on the support for general-purpose support for + * 64-bit floating-point values in the ARB_gpu_shader_fp64 extension.
+ * + *This extension provides a new class of vertex attribute functions, beginning with "VertexAttribL" ("L" for "long"), that can be used to specify + * attributes with 64-bit floating-point components. This extension provides no automatic type conversion between attribute and shader variables; + * single-precision attributes are not automatically converted to double-precision or vice versa. For shader variables with 64-bit component types, the + * "VertexAttribL" functions must be used to specify attribute values. For other shader variables, the "VertexAttribL" functions must not be used. If a + * vertex attribute is specified using the wrong attribute function, the values of the corresponding shader input are undefined. This approach requiring + * matching types is identical to that used for the "VertexAttribI" functions provided by OpenGL 3.0 and the {@link EXTGPUShader4 EXT_gpu_shader4} extension.
+ * + *Additionally, some vertex shader inputs using the wider 64-bit components may count double against the implementation-dependent limit on the number of + * vertex shader attribute vectors. A 64-bit scalar or a two-component vector consumes only a single generic vertex attribute; three- and four-component + * "long" may count as two. This approach is similar to the one used in the current GL where matrix attributes consume multiple attributes.
+ * + *Note that 64-bit generic vertex attributes were nominally supported beginning with the introduction of vertex shaders in OpenGL 2.0. However, the OpenGL + * Shading Language at the time had no support for 64-bit data types, so any such values were automatically converted to 32-bit.
+ * + *Support for 64-bit floating-point vertex attributes in this extension can be combined with other extensions. In particular, this extension provides an + * entry point that can be used with EXT_direct_state_access to directly set state for any vertex array object. Also, the related + * {@link NVVertexAttribInteger64bit NV_vertex_attrib_integer_64bit} extension provides an entry point to specify bindless vertex attribute arrays with 64-bit + * components, integer or floating-point.
+ * + *Requires {@link GL30 OpenGL 3.0}, GLSL 1.30 and {@link ARBGPUShaderFP64 ARB_gpu_shader_fp64}. Promoted to core in {@link GL41 OpenGL 4.1}.
+ */ +public class ARBVertexAttrib64Bit { + + /** Returned in the {@code type} parameter of GetActiveAttrib. */ + public static final int + GL_DOUBLE_VEC2 = 0x8FFC, + GL_DOUBLE_VEC3 = 0x8FFD, + GL_DOUBLE_VEC4 = 0x8FFE, + GL_DOUBLE_MAT2 = 0x8F46, + GL_DOUBLE_MAT3 = 0x8F47, + GL_DOUBLE_MAT4 = 0x8F48, + GL_DOUBLE_MAT2x3 = 0x8F49, + GL_DOUBLE_MAT2x4 = 0x8F4A, + GL_DOUBLE_MAT3x2 = 0x8F4B, + GL_DOUBLE_MAT3x4 = 0x8F4C, + GL_DOUBLE_MAT4x2 = 0x8F4D, + GL_DOUBLE_MAT4x3 = 0x8F4E; + + static { GL.initialize(); } + + protected ARBVertexAttrib64Bit() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.Set| {@link GL11#GL_DOUBLE DOUBLE} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_DOUBLE DOUBLE} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_DOUBLE DOUBLE} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_DOUBLE DOUBLE} |
OpenGL currently supports (at least) 16 vertex attributes and 16 vertex buffer bindings, with a fixed mapping between vertex attributes and vertex + * buffer bindings. This extension allows the application to change the mapping between attributes and bindings, which can make it more efficient to update + * vertex buffer bindings for interleaved vertex formats where many attributes share the same buffer.
+ * + *This extension also separates the vertex binding update from the vertex attribute format update, which saves applications the effort of redundantly + * specifying the same format state over and over.
+ * + *Conceptually, this extension splits the state for generic vertex attribute arrays into:
+ * + *Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public class ARBVertexAttribBinding { + + /** Accepted by the {@code pname} parameter of GetVertexAttrib*v. */ + public static final int + GL_VERTEX_ATTRIB_BINDING = 0x82D4, + GL_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5; + + /** Accepted by the {@code target} parameter of GetBooleani_v, GetIntegeri_v, GetFloati_v, GetDoublei_v, and GetInteger64i_v. */ + public static final int + GL_VERTEX_BINDING_DIVISOR = 0x82D6, + GL_VERTEX_BINDING_OFFSET = 0x82D7, + GL_VERTEX_BINDING_STRIDE = 0x82D8, + GL_VERTEX_BINDING_BUFFER = 0x8F4F; + + /** Accepted by the {@code pname} parameter of GetIntegerv, .... */ + public static final int + GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9, + GL_MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA; + + static { GL.initialize(); } + + protected ARBVertexAttribBinding() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.Set| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
This extension provides the ability to replace the single modelview transformation with a set of n vertex units. (Where n is constrained to an + * implementation defined maximum.) Each unit has its own modelview transform matrix. For each unit, there is a current weight associated with the vertex. + * When this extension is enabled the vertices are transformed by the modelview matrices of all of the enabled units. Afterward, these results are scaled + * by the weights for the respective units and then summed to create the eye-space vertex. A similar procedure is followed for the normals, except they are + * transformed by the inverse transpose of the modelview matrices.
+ */ +public class ARBVertexBlend { + + /** Accepted by the {@code value} parameters of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_MAX_VERTEX_UNITS_ARB = 0x86A4, + GL_ACTIVE_VERTEX_UNITS_ARB = 0x86A5; + + /** + * Accepted by the {@code cap} parameters of Enable and Disable, by the {@code value} parameter of IsEnabled, GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int + GL_WEIGHT_SUM_UNITY_ARB = 0x86A6, + GL_VERTEX_BLEND_ARB = 0x86A7; + + /** Accepted by the {@code mode} parameter of MatrixMode and by the {@code value} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_MODELVIEW0_ARB = 0x1700, + GL_MODELVIEW1_ARB = 0x850A, + GL_MODELVIEW2_ARB = 0x8722, + GL_MODELVIEW3_ARB = 0x8723, + GL_MODELVIEW4_ARB = 0x8724, + GL_MODELVIEW5_ARB = 0x8725, + GL_MODELVIEW6_ARB = 0x8726, + GL_MODELVIEW7_ARB = 0x8727, + GL_MODELVIEW8_ARB = 0x8728, + GL_MODELVIEW9_ARB = 0x8729, + GL_MODELVIEW10_ARB = 0x872A, + GL_MODELVIEW11_ARB = 0x872B, + GL_MODELVIEW12_ARB = 0x872C, + GL_MODELVIEW13_ARB = 0x872D, + GL_MODELVIEW14_ARB = 0x872E, + GL_MODELVIEW15_ARB = 0x872F, + GL_MODELVIEW16_ARB = 0x8730, + GL_MODELVIEW17_ARB = 0x8731, + GL_MODELVIEW18_ARB = 0x8732, + GL_MODELVIEW19_ARB = 0x8733, + GL_MODELVIEW20_ARB = 0x8734, + GL_MODELVIEW21_ARB = 0x8735, + GL_MODELVIEW22_ARB = 0x8736, + GL_MODELVIEW23_ARB = 0x8737, + GL_MODELVIEW24_ARB = 0x8738, + GL_MODELVIEW25_ARB = 0x8739, + GL_MODELVIEW26_ARB = 0x873A, + GL_MODELVIEW27_ARB = 0x873B, + GL_MODELVIEW28_ARB = 0x873C, + GL_MODELVIEW29_ARB = 0x873D, + GL_MODELVIEW30_ARB = 0x873E, + GL_MODELVIEW31_ARB = 0x873F; + + /** Accepted by the {@code value} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_CURRENT_WEIGHT_ARB = 0x86A8; + + /** Accepted by the {@code value} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_WEIGHT_ARRAY_TYPE_ARB = 0x86A9, + GL_WEIGHT_ARRAY_STRIDE_ARB = 0x86AA, + GL_WEIGHT_ARRAY_SIZE_ARB = 0x86AB; + + /** Accepted by the {@code pname} parameter of GetPointerv. */ + public static final int GL_WEIGHT_ARRAY_POINTER_ARB = 0x86AC; + + /** + * Accepted by the {@code cap} parameters of EnableClientState and DisableClientState, by the {@code value} parameter of IsEnabled, GetBooleanv, + * GetIntegerv, GetFloatv, and GetDoublev. + */ + public static final int GL_WEIGHT_ARRAY_ARB = 0x86AD; + + static { GL.initialize(); } + + protected ARBVertexBlend() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glWeightfvARB, caps.glWeightbvARB, caps.glWeightubvARB, caps.glWeightsvARB, caps.glWeightusvARB, caps.glWeightivARB, caps.glWeightuivARB, + caps.glWeightdvARB, caps.glWeightPointerARB, caps.glVertexBlendARB + ); + } + + // --- [ glWeightfvARB ] --- + + /** + * Unsafe version of: {@link #glWeightfvARB WeightfvARB} + * + * @param size the number of weights to set. Must be a value between 1 and {@link #GL_MAX_VERTEX_UNITS_ARB MAX_VERTEX_UNITS_ARB}. + */ + public static native void nglWeightfvARB(int size, long weights); + + /** + * Sets the current vertex weights. + * + * @param weights the vertex weights + */ + public static void glWeightfvARB(@NativeType("GLfloat *") FloatBuffer weights) { + nglWeightfvARB(weights.remaining(), memAddress(weights)); + } + + // --- [ glWeightbvARB ] --- + + /** + * Unsafe version of: {@link #glWeightbvARB WeightbvARB} + * + * @param size the number of weights to set. Must be a value between 1 and {@link #GL_MAX_VERTEX_UNITS_ARB MAX_VERTEX_UNITS_ARB}. + */ + public static native void nglWeightbvARB(int size, long weights); + + /** + * Byte version of {@link #glWeightfvARB WeightfvARB}. + * + * @param weights the vertex weights + */ + public static void glWeightbvARB(@NativeType("GLbyte *") ByteBuffer weights) { + nglWeightbvARB(weights.remaining(), memAddress(weights)); + } + + // --- [ glWeightubvARB ] --- + + /** + * Unsafe version of: {@link #glWeightubvARB WeightubvARB} + * + * @param size the number of weights to set. Must be a value between 1 and {@link #GL_MAX_VERTEX_UNITS_ARB MAX_VERTEX_UNITS_ARB}. + */ + public static native void nglWeightubvARB(int size, long weights); + + /** + * Unsigned byte version of {@link #glWeightfvARB WeightfvARB}. + * + * @param weights the vertex weights + */ + public static void glWeightubvARB(@NativeType("GLubyte *") ByteBuffer weights) { + nglWeightubvARB(weights.remaining(), memAddress(weights)); + } + + // --- [ glWeightsvARB ] --- + + /** + * Unsafe version of: {@link #glWeightsvARB WeightsvARB} + * + * @param size the number of weights to set. Must be a value between 1 and {@link #GL_MAX_VERTEX_UNITS_ARB MAX_VERTEX_UNITS_ARB}. + */ + public static native void nglWeightsvARB(int size, long weights); + + /** + * Short version of {@link #glWeightfvARB WeightfvARB}. + * + * @param weights the vertex weights + */ + public static void glWeightsvARB(@NativeType("GLshort *") ShortBuffer weights) { + nglWeightsvARB(weights.remaining(), memAddress(weights)); + } + + // --- [ glWeightusvARB ] --- + + /** + * Unsafe version of: {@link #glWeightusvARB WeightusvARB} + * + * @param size the number of weights to set. Must be a value between 1 and {@link #GL_MAX_VERTEX_UNITS_ARB MAX_VERTEX_UNITS_ARB}. + */ + public static native void nglWeightusvARB(int size, long weights); + + /** + * Unsigned short version of {@link #glWeightfvARB WeightfvARB}. + * + * @param weights the vertex weights + */ + public static void glWeightusvARB(@NativeType("GLushort *") ShortBuffer weights) { + nglWeightusvARB(weights.remaining(), memAddress(weights)); + } + + // --- [ glWeightivARB ] --- + + /** + * Unsafe version of: {@link #glWeightivARB WeightivARB} + * + * @param size the number of weights to set. Must be a value between 1 and {@link #GL_MAX_VERTEX_UNITS_ARB MAX_VERTEX_UNITS_ARB}. + */ + public static native void nglWeightivARB(int size, long weights); + + /** + * Integer version of {@link #glWeightfvARB WeightfvARB}. + * + * @param weights the vertex weights + */ + public static void glWeightivARB(@NativeType("GLint *") IntBuffer weights) { + nglWeightivARB(weights.remaining(), memAddress(weights)); + } + + // --- [ glWeightuivARB ] --- + + /** + * Unsafe version of: {@link #glWeightuivARB WeightuivARB} + * + * @param size the number of weights to set. Must be a value between 1 and {@link #GL_MAX_VERTEX_UNITS_ARB MAX_VERTEX_UNITS_ARB}. + */ + public static native void nglWeightuivARB(int size, long weights); + + /** + * Unsigned integer version of {@link #glWeightfvARB WeightfvARB}. + * + * @param weights the vertex weights + */ + public static void glWeightuivARB(@NativeType("GLuint *") IntBuffer weights) { + nglWeightuivARB(weights.remaining(), memAddress(weights)); + } + + // --- [ glWeightdvARB ] --- + + /** + * Unsafe version of: {@link #glWeightdvARB WeightdvARB} + * + * @param size the number of weights to set. Must be a value between 1 and {@link #GL_MAX_VERTEX_UNITS_ARB MAX_VERTEX_UNITS_ARB}. + */ + public static native void nglWeightdvARB(int size, long weights); + + /** + * Double version of {@link #glWeightfvARB WeightfvARB}. + * + * @param weights the vertex weights + */ + public static void glWeightdvARB(@NativeType("GLdouble *") DoubleBuffer weights) { + nglWeightdvARB(weights.remaining(), memAddress(weights)); + } + + // --- [ glWeightPointerARB ] --- + + /** Unsafe version of: {@link #glWeightPointerARB WeightPointerARB} */ + public static native void nglWeightPointerARB(int size, int type, int stride, long pointer); + + /** + * Specifies the location and organization of a weight array. + * + * @param size the number of values per vertex that are stored in the array. Must be a value between 1 and {@link #GL_MAX_VERTEX_UNITS_ARB MAX_VERTEX_UNITS_ARB}. + * @param type the data type of the values stored in the array. One of:| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} |
This extension defines an interface that allows various types of data (especially vertex array data) to be cached in high-performance graphics memory on + * the server, thereby increasing the rate of data transfers.
+ * + *Chunks of data are encapsulated within "buffer objects", which conceptually are nothing more than arrays of bytes, just like any chunk of memory. An API + * is provided whereby applications can read from or write to buffers, either via the GL itself ({@link #glBufferDataARB BufferDataARB}, {@link #glBufferSubDataARB BufferSubDataARB}, + * {@link #glGetBufferSubDataARB GetBufferSubDataARB}) or via a pointer to the memory.
+ * + *The latter technique is known as "mapping" a buffer. When an application maps a buffer, it is given a pointer to the memory. When the application + * finishes reading from or writing to the memory, it is required to "unmap" the buffer before it is once again permitted to use that buffer as a GL data + * source or sink. Mapping often allows applications to eliminate an extra data copy otherwise required to access the buffer, thereby enhancing + * performance. In addition, requiring that applications unmap the buffer to use it as a data source or sink ensures that certain classes of latent + * synchronization bugs cannot occur.
+ * + *Although this extension only defines hooks for buffer objects to be used with OpenGL's vertex array APIs, the API defined in this extension permits + * buffer objects to be used as either data sources or sinks for any GL command that takes a pointer as an argument. Normally, in the absence of this + * extension, a pointer passed into the GL is simply a pointer to the user's data. This extension defines a mechanism whereby this pointer is used not as a + * pointer to the data itself, but as an offset into a currently bound buffer object. The buffer object ID zero is reserved, and when buffer object zero is + * bound to a given target, the commands affected by that buffer binding behave normally. When a nonzero buffer ID is bound, then the pointer represents an + * offset.
+ * + *In the case of vertex arrays, this extension defines not merely one binding for all attributes, but a separate binding for each individual attribute. As + * a result, applications can source their attributes from multiple buffers. An application might, for example, have a model with constant texture + * coordinates and variable geometry. The texture coordinates might be retrieved from a buffer object with the usage mode "STATIC_DRAW", indicating to the + * GL that the application does not expect to update the contents of the buffer frequently or even at all, while the vertices might be retrieved from a + * buffer object with the usage mode "STREAM_DRAW", indicating that the vertices will be updated on a regular basis.
+ * + *In addition, a binding is defined by which applications can source index data (as used by {@link GL11C#glDrawElements DrawElements}, {@link GL12C#glDrawRangeElements DrawRangeElements}, and + * {@link GL14C#glMultiDrawElements MultiDrawElements}) from a buffer object. On some platforms, this enables very large models to be rendered with no more than a few small commands + * to the graphics device.
+ * + *It is expected that a future extension will allow sourcing pixel data from and writing pixel data to a buffer object.
+ * + *Promoted to core in {@link GL15 OpenGL 1.5}.
+ */ +public class ARBVertexBufferObject { + + /** + * Accepted by the {@code target} parameters of BindBufferARB, BufferDataARB, BufferSubDataARB, MapBufferARB, UnmapBufferARB, GetBufferSubDataARB, + * GetBufferParameterivARB, and GetBufferPointervARB. + */ + public static final int + GL_ARRAY_BUFFER_ARB = 0x8892, + GL_ELEMENT_ARRAY_BUFFER_ARB = 0x8893; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_ARRAY_BUFFER_BINDING_ARB = 0x8894, + GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = 0x8895, + GL_VERTEX_ARRAY_BUFFER_BINDING_ARB = 0x8896, + GL_NORMAL_ARRAY_BUFFER_BINDING_ARB = 0x8897, + GL_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x8898, + GL_INDEX_ARRAY_BUFFER_BINDING_ARB = 0x8899, + GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 0x889A, + GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 0x889B, + GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x889C, + GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 0x889D, + GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = 0x889E; + + /** Accepted by the {@code pname} parameter of GetVertexAttribivARB. */ + public static final int GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 0x889F; + + /** Accepted by the {@code usage} parameter of BufferDataARB. */ + public static final int + GL_STREAM_DRAW_ARB = 0x88E0, + GL_STREAM_READ_ARB = 0x88E1, + GL_STREAM_COPY_ARB = 0x88E2, + GL_STATIC_DRAW_ARB = 0x88E4, + GL_STATIC_READ_ARB = 0x88E5, + GL_STATIC_COPY_ARB = 0x88E6, + GL_DYNAMIC_DRAW_ARB = 0x88E8, + GL_DYNAMIC_READ_ARB = 0x88E9, + GL_DYNAMIC_COPY_ARB = 0x88EA; + + /** Accepted by the {@code access} parameter of MapBufferARB. */ + public static final int + GL_READ_ONLY_ARB = 0x88B8, + GL_WRITE_ONLY_ARB = 0x88B9, + GL_READ_WRITE_ARB = 0x88BA; + + /** Accepted by the {@code pname} parameter of GetBufferParameterivARB. */ + public static final int + GL_BUFFER_SIZE_ARB = 0x8764, + GL_BUFFER_USAGE_ARB = 0x8765, + GL_BUFFER_ACCESS_ARB = 0x88BB, + GL_BUFFER_MAPPED_ARB = 0x88BC; + + /** Accepted by the {@code pname} parameter of GetBufferPointervARB. */ + public static final int GL_BUFFER_MAP_POINTER_ARB = 0x88BD; + + static { GL.initialize(); } + + protected ARBVertexBufferObject() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBindBufferARB, caps.glDeleteBuffersARB, caps.glGenBuffersARB, caps.glIsBufferARB, caps.glBufferDataARB, caps.glBufferSubDataARB, + caps.glGetBufferSubDataARB, caps.glMapBufferARB, caps.glUnmapBufferARB, caps.glGetBufferParameterivARB, caps.glGetBufferPointervARB + ); + } + + // --- [ glBindBufferARB ] --- + + /** + * Binds a named buffer object. + * + * @param target the target to which the buffer object is bound. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_STREAM_DRAW_ARB STREAM_DRAW_ARB} | {@link #GL_STREAM_READ_ARB STREAM_READ_ARB} | {@link #GL_STREAM_COPY_ARB STREAM_COPY_ARB} | {@link #GL_STATIC_DRAW_ARB STATIC_DRAW_ARB} | {@link #GL_STATIC_READ_ARB STATIC_READ_ARB} |
| {@link #GL_STATIC_COPY_ARB STATIC_COPY_ARB} | {@link #GL_DYNAMIC_DRAW_ARB DYNAMIC_DRAW_ARB} | {@link #GL_DYNAMIC_READ_ARB DYNAMIC_READ_ARB} | {@link #GL_DYNAMIC_COPY_ARB DYNAMIC_COPY_ARB} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_STREAM_DRAW_ARB STREAM_DRAW_ARB} | {@link #GL_STREAM_READ_ARB STREAM_READ_ARB} | {@link #GL_STREAM_COPY_ARB STREAM_COPY_ARB} | {@link #GL_STATIC_DRAW_ARB STATIC_DRAW_ARB} | {@link #GL_STATIC_READ_ARB STATIC_READ_ARB} |
| {@link #GL_STATIC_COPY_ARB STATIC_COPY_ARB} | {@link #GL_DYNAMIC_DRAW_ARB DYNAMIC_DRAW_ARB} | {@link #GL_DYNAMIC_READ_ARB DYNAMIC_READ_ARB} | {@link #GL_DYNAMIC_COPY_ARB DYNAMIC_COPY_ARB} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_STREAM_DRAW_ARB STREAM_DRAW_ARB} | {@link #GL_STREAM_READ_ARB STREAM_READ_ARB} | {@link #GL_STREAM_COPY_ARB STREAM_COPY_ARB} | {@link #GL_STATIC_DRAW_ARB STATIC_DRAW_ARB} | {@link #GL_STATIC_READ_ARB STATIC_READ_ARB} |
| {@link #GL_STATIC_COPY_ARB STATIC_COPY_ARB} | {@link #GL_DYNAMIC_DRAW_ARB DYNAMIC_DRAW_ARB} | {@link #GL_DYNAMIC_READ_ARB DYNAMIC_READ_ARB} | {@link #GL_DYNAMIC_COPY_ARB DYNAMIC_COPY_ARB} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_STREAM_DRAW_ARB STREAM_DRAW_ARB} | {@link #GL_STREAM_READ_ARB STREAM_READ_ARB} | {@link #GL_STREAM_COPY_ARB STREAM_COPY_ARB} | {@link #GL_STATIC_DRAW_ARB STATIC_DRAW_ARB} | {@link #GL_STATIC_READ_ARB STATIC_READ_ARB} |
| {@link #GL_STATIC_COPY_ARB STATIC_COPY_ARB} | {@link #GL_DYNAMIC_DRAW_ARB DYNAMIC_DRAW_ARB} | {@link #GL_DYNAMIC_READ_ARB DYNAMIC_READ_ARB} | {@link #GL_DYNAMIC_COPY_ARB DYNAMIC_COPY_ARB} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_STREAM_DRAW_ARB STREAM_DRAW_ARB} | {@link #GL_STREAM_READ_ARB STREAM_READ_ARB} | {@link #GL_STREAM_COPY_ARB STREAM_COPY_ARB} | {@link #GL_STATIC_DRAW_ARB STATIC_DRAW_ARB} | {@link #GL_STATIC_READ_ARB STATIC_READ_ARB} |
| {@link #GL_STATIC_COPY_ARB STATIC_COPY_ARB} | {@link #GL_DYNAMIC_DRAW_ARB DYNAMIC_DRAW_ARB} | {@link #GL_DYNAMIC_READ_ARB DYNAMIC_READ_ARB} | {@link #GL_DYNAMIC_COPY_ARB DYNAMIC_COPY_ARB} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_STREAM_DRAW_ARB STREAM_DRAW_ARB} | {@link #GL_STREAM_READ_ARB STREAM_READ_ARB} | {@link #GL_STREAM_COPY_ARB STREAM_COPY_ARB} | {@link #GL_STATIC_DRAW_ARB STATIC_DRAW_ARB} | {@link #GL_STATIC_READ_ARB STATIC_READ_ARB} |
| {@link #GL_STATIC_COPY_ARB STATIC_COPY_ARB} | {@link #GL_DYNAMIC_DRAW_ARB DYNAMIC_DRAW_ARB} | {@link #GL_DYNAMIC_READ_ARB DYNAMIC_READ_ARB} | {@link #GL_DYNAMIC_COPY_ARB DYNAMIC_COPY_ARB} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
LWJGL note: This method comes in 3 flavors:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_READ_ONLY_ARB READ_ONLY_ARB} | {@link #GL_WRITE_ONLY_ARB WRITE_ONLY_ARB} | {@link #GL_READ_WRITE_ARB READ_WRITE_ARB} |
LWJGL note: This method comes in 3 flavors:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_READ_ONLY_ARB READ_ONLY_ARB} | {@link #GL_WRITE_ONLY_ARB WRITE_ONLY_ARB} | {@link #GL_READ_WRITE_ARB READ_WRITE_ARB} |
LWJGL note: This method comes in 3 flavors:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_READ_ONLY_ARB READ_ONLY_ARB} | {@link #GL_WRITE_ONLY_ARB WRITE_ONLY_ARB} | {@link #GL_READ_WRITE_ARB READ_WRITE_ARB} |
Returns TRUE unless data values in the buffer’s data store have become corrupted during the period that the buffer was mapped. Such corruption can be + * the result of a screen resolution change or other window system-dependent event that causes system heaps such as those for high-performance graphics + * memory to be discarded. GL implementations must guarantee that such corruption can occur only during the periods that a buffer’s data store is mapped. + * If such corruption has occurred, UnmapBuffer returns FALSE, and the contents of the buffer’s data store become undefined.
+ * + * @param target the target buffer object being unmapped. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_BUFFER_MAP_POINTER_ARB BUFFER_MAP_POINTER_ARB} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_BUFFER_MAP_POINTER_ARB BUFFER_MAP_POINTER_ARB} |
Unextended OpenGL mandates a certain set of configurable per-vertex computations defining vertex transformation, texture coordinate generation and + * transformation, and lighting. Several extensions have added further per-vertex computations to OpenGL. For example, extensions have defined new texture + * coordinate generation modes ({@link ARBTextureCubeMap ARB_texture_cube_map}, {@link NVTexgenReflection NV_texgen_reflection}, NV_texgen_emboss), new vertex + * transformation modes ({@link ARBVertexBlend ARB_vertex_blend}, EXT_vertex_weighting), new lighting modes (OpenGL 1.2's separate specular and + * rescale normal functionality), several modes for fog distance generation ({@link NVFogDistance NV_fog_distance}), and eye-distance point size attenuation + * ({@link ARBPointParameters ARB_point_parameters}).
+ * + *Each such extension adds a small set of relatively inflexible per-vertex computations.
+ * + *This inflexibility is in contrast to the typical flexibility provided by the underlying programmable floating point engines (whether micro-coded vertex + * engines, DSPs, or CPUs) that are traditionally used to implement OpenGL's per-vertex computations. The purpose of this extension is to expose to the + * OpenGL application writer a significant degree of per-vertex programmability for computing vertex parameters.
+ * + *For the purposes of discussing this extension, a vertex program is a sequence of floating-point 4-component vector operations that determines how a set + * of program parameters (defined outside of OpenGL's {@link GL11#glBegin Begin}/{@link GL11#glEnd End} pair) and an input set of per-vertex parameters are transformed to a set of + * per-vertex result parameters.
+ * + *The per-vertex computations for standard OpenGL given a particular set of lighting and texture coordinate generation modes (along with any state for + * extensions defining per-vertex computations) is, in essence, a vertex program. However, the sequence of operations is defined implicitly by the current + * OpenGL state settings rather than defined explicitly as a sequence of instructions.
+ * + *This extension provides an explicit mechanism for defining vertex program instruction sequences for application-defined vertex programs. In order to + * define such vertex programs, this extension defines a vertex programming model including a floating-point 4-component vector instruction set and a + * relatively large set of floating-point 4-component registers.
+ * + *The extension's vertex programming model is designed for efficient hardware implementation and to support a wide variety of vertex programs. By design, + * the entire set of existing vertex programs defined by existing OpenGL per-vertex computation extensions can be implemented using the extension's vertex + * programming model.
+ */ +public class ARBVertexProgram { + + /** + * Accepted by the {@code cap} parameter of Disable, Enable, and IsEnabled, by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev, and by the {@code target} parameter of ProgramStringARB, BindProgramARB, ProgramEnvParameter4[df][v]ARB, ProgramLocalParameter4[df][v]ARB, + * GetProgramEnvParameter[df]vARB, GetProgramLocalParameter[df]vARB, GetProgramivARB, and GetProgramStringARB. + */ + public static final int GL_VERTEX_PROGRAM_ARB = 0x8620; + + /** + * Accepted by the {@code cap} parameter of Disable, Enable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int + GL_VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642, + GL_VERTEX_PROGRAM_TWO_SIDE_ARB = 0x8643, + GL_COLOR_SUM_ARB = 0x8458; + + /** Accepted by the {@code format} parameter of ProgramStringARB. */ + public static final int GL_PROGRAM_FORMAT_ASCII_ARB = 0x8875; + + /** Accepted by the {@code pname} parameter of GetVertexAttrib[dfi]vARB. */ + public static final int + GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 0x8622, + GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = 0x8623, + GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 0x8624, + GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = 0x8625, + GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A, + GL_CURRENT_VERTEX_ATTRIB_ARB = 0x8626; + + /** Accepted by the {@code pname} parameter of GetVertexAttribPointervARB. */ + public static final int GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645; + + /** Accepted by the {@code pname} parameter of GetProgramivARB. */ + public static final int + GL_PROGRAM_LENGTH_ARB = 0x8627, + GL_PROGRAM_FORMAT_ARB = 0x8876, + GL_PROGRAM_BINDING_ARB = 0x8677, + GL_PROGRAM_INSTRUCTIONS_ARB = 0x88A0, + GL_MAX_PROGRAM_INSTRUCTIONS_ARB = 0x88A1, + GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A2, + GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A3, + GL_PROGRAM_TEMPORARIES_ARB = 0x88A4, + GL_MAX_PROGRAM_TEMPORARIES_ARB = 0x88A5, + GL_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A6, + GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A7, + GL_PROGRAM_PARAMETERS_ARB = 0x88A8, + GL_MAX_PROGRAM_PARAMETERS_ARB = 0x88A9, + GL_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AA, + GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AB, + GL_PROGRAM_ATTRIBS_ARB = 0x88AC, + GL_MAX_PROGRAM_ATTRIBS_ARB = 0x88AD, + GL_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AE, + GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AF, + GL_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B0, + GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B1, + GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B2, + GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B3, + GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 0x88B4, + GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = 0x88B5, + GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = 0x88B6; + + /** Accepted by the {@code pname} parameter of GetProgramStringARB. */ + public static final int GL_PROGRAM_STRING_ARB = 0x8628; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_PROGRAM_ERROR_POSITION_ARB = 0x864B, + GL_CURRENT_MATRIX_ARB = 0x8641, + GL_TRANSPOSE_CURRENT_MATRIX_ARB = 0x88B7, + GL_CURRENT_MATRIX_STACK_DEPTH_ARB = 0x8640, + GL_MAX_VERTEX_ATTRIBS_ARB = 0x8869, + GL_MAX_PROGRAM_MATRICES_ARB = 0x862F, + GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 0x862E; + + /** Accepted by the {@code name} parameter of GetString. */ + public static final int GL_PROGRAM_ERROR_STRING_ARB = 0x8874; + + /** Accepted by the {@code mode} parameter of MatrixMode. */ + public static final int + GL_MATRIX0_ARB = 0x88C0, + GL_MATRIX1_ARB = 0x88C1, + GL_MATRIX2_ARB = 0x88C2, + GL_MATRIX3_ARB = 0x88C3, + GL_MATRIX4_ARB = 0x88C4, + GL_MATRIX5_ARB = 0x88C5, + GL_MATRIX6_ARB = 0x88C6, + GL_MATRIX7_ARB = 0x88C7, + GL_MATRIX8_ARB = 0x88C8, + GL_MATRIX9_ARB = 0x88C9, + GL_MATRIX10_ARB = 0x88CA, + GL_MATRIX11_ARB = 0x88CB, + GL_MATRIX12_ARB = 0x88CC, + GL_MATRIX13_ARB = 0x88CD, + GL_MATRIX14_ARB = 0x88CE, + GL_MATRIX15_ARB = 0x88CF, + GL_MATRIX16_ARB = 0x88D0, + GL_MATRIX17_ARB = 0x88D1, + GL_MATRIX18_ARB = 0x88D2, + GL_MATRIX19_ARB = 0x88D3, + GL_MATRIX20_ARB = 0x88D4, + GL_MATRIX21_ARB = 0x88D5, + GL_MATRIX22_ARB = 0x88D6, + GL_MATRIX23_ARB = 0x88D7, + GL_MATRIX24_ARB = 0x88D8, + GL_MATRIX25_ARB = 0x88D9, + GL_MATRIX26_ARB = 0x88DA, + GL_MATRIX27_ARB = 0x88DB, + GL_MATRIX28_ARB = 0x88DC, + GL_MATRIX29_ARB = 0x88DD, + GL_MATRIX30_ARB = 0x88DE, + GL_MATRIX31_ARB = 0x88DF; + + static { GL.initialize(); } + + protected ARBVertexProgram() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glVertexAttrib1sARB, caps.glVertexAttrib1fARB, caps.glVertexAttrib1dARB, caps.glVertexAttrib2sARB, caps.glVertexAttrib2fARB, + caps.glVertexAttrib2dARB, caps.glVertexAttrib3sARB, caps.glVertexAttrib3fARB, caps.glVertexAttrib3dARB, caps.glVertexAttrib4sARB, + caps.glVertexAttrib4fARB, caps.glVertexAttrib4dARB, caps.glVertexAttrib4NubARB, caps.glVertexAttrib1svARB, caps.glVertexAttrib1fvARB, + caps.glVertexAttrib1dvARB, caps.glVertexAttrib2svARB, caps.glVertexAttrib2fvARB, caps.glVertexAttrib2dvARB, caps.glVertexAttrib3svARB, + caps.glVertexAttrib3fvARB, caps.glVertexAttrib3dvARB, caps.glVertexAttrib4fvARB, caps.glVertexAttrib4bvARB, caps.glVertexAttrib4svARB, + caps.glVertexAttrib4ivARB, caps.glVertexAttrib4ubvARB, caps.glVertexAttrib4usvARB, caps.glVertexAttrib4uivARB, caps.glVertexAttrib4dvARB, + caps.glVertexAttrib4NbvARB, caps.glVertexAttrib4NsvARB, caps.glVertexAttrib4NivARB, caps.glVertexAttrib4NubvARB, caps.glVertexAttrib4NusvARB, + caps.glVertexAttrib4NuivARB, caps.glVertexAttribPointerARB, caps.glEnableVertexAttribArrayARB, caps.glDisableVertexAttribArrayARB, + caps.glProgramStringARB, caps.glBindProgramARB, caps.glDeleteProgramsARB, caps.glGenProgramsARB, caps.glProgramEnvParameter4dARB, + caps.glProgramEnvParameter4dvARB, caps.glProgramEnvParameter4fARB, caps.glProgramEnvParameter4fvARB, caps.glProgramLocalParameter4dARB, + caps.glProgramLocalParameter4dvARB, caps.glProgramLocalParameter4fARB, caps.glProgramLocalParameter4fvARB, caps.glGetProgramEnvParameterfvARB, + caps.glGetProgramEnvParameterdvARB, caps.glGetProgramLocalParameterfvARB, caps.glGetProgramLocalParameterdvARB, caps.glGetProgramivARB, + caps.glGetProgramStringARB, caps.glGetVertexAttribfvARB, caps.glGetVertexAttribdvARB, caps.glGetVertexAttribivARB, + caps.glGetVertexAttribPointervARB, caps.glIsProgramARB + ); + } + + // --- [ glVertexAttrib1sARB ] --- + + /** + * Short version of {@link #glVertexAttrib1fARB VertexAttrib1fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + */ + public static void glVertexAttrib1sARB(@NativeType("GLuint") int index, @NativeType("GLshort") short v0) { + ARBVertexShader.glVertexAttrib1sARB(index, v0); + } + + // --- [ glVertexAttrib1fARB ] --- + + /** + * Specifies the value of a generic vertex attribute. The y and z components are implicitly set to 0.0f and w to 1.0f. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + */ + public static void glVertexAttrib1fARB(@NativeType("GLuint") int index, @NativeType("GLfloat") float v0) { + ARBVertexShader.glVertexAttrib1fARB(index, v0); + } + + // --- [ glVertexAttrib1dARB ] --- + + /** + * Double version of {@link #glVertexAttrib1fARB VertexAttrib1fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + */ + public static void glVertexAttrib1dARB(@NativeType("GLuint") int index, @NativeType("GLdouble") double v0) { + ARBVertexShader.glVertexAttrib1dARB(index, v0); + } + + // --- [ glVertexAttrib2sARB ] --- + + /** + * Short version of {@link #glVertexAttrib2fARB VertexAttrib2fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + */ + public static void glVertexAttrib2sARB(@NativeType("GLuint") int index, @NativeType("GLshort") short v0, @NativeType("GLshort") short v1) { + ARBVertexShader.glVertexAttrib2sARB(index, v0, v1); + } + + // --- [ glVertexAttrib2fARB ] --- + + /** + * Specifies the value of a generic vertex attribute. The y component is implicitly set to 0.0f and w to 1.0f. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + */ + public static void glVertexAttrib2fARB(@NativeType("GLuint") int index, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1) { + ARBVertexShader.glVertexAttrib2fARB(index, v0, v1); + } + + // --- [ glVertexAttrib2dARB ] --- + + /** + * Double version of {@link #glVertexAttrib2fARB VertexAttrib2fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + */ + public static void glVertexAttrib2dARB(@NativeType("GLuint") int index, @NativeType("GLdouble") double v0, @NativeType("GLdouble") double v1) { + ARBVertexShader.glVertexAttrib2dARB(index, v0, v1); + } + + // --- [ glVertexAttrib3sARB ] --- + + /** + * Short version of {@link #glVertexAttrib3fARB VertexAttrib3fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + * @param v2 the vertex attribute z component + */ + public static void glVertexAttrib3sARB(@NativeType("GLuint") int index, @NativeType("GLshort") short v0, @NativeType("GLshort") short v1, @NativeType("GLshort") short v2) { + ARBVertexShader.glVertexAttrib3sARB(index, v0, v1, v2); + } + + // --- [ glVertexAttrib3fARB ] --- + + /** + * Specifies the value of a generic vertex attribute. The w is implicitly set to 1.0f. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + * @param v2 the vertex attribute z component + */ + public static void glVertexAttrib3fARB(@NativeType("GLuint") int index, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1, @NativeType("GLfloat") float v2) { + ARBVertexShader.glVertexAttrib3fARB(index, v0, v1, v2); + } + + // --- [ glVertexAttrib3dARB ] --- + + /** + * Double version of {@link #glVertexAttrib3fARB VertexAttrib3fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + * @param v2 the vertex attribute z component + */ + public static void glVertexAttrib3dARB(@NativeType("GLuint") int index, @NativeType("GLdouble") double v0, @NativeType("GLdouble") double v1, @NativeType("GLdouble") double v2) { + ARBVertexShader.glVertexAttrib3dARB(index, v0, v1, v2); + } + + // --- [ glVertexAttrib4sARB ] --- + + /** + * Short version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + * @param v2 the vertex attribute z component + * @param v3 the vertex attribute w component + */ + public static void glVertexAttrib4sARB(@NativeType("GLuint") int index, @NativeType("GLshort") short v0, @NativeType("GLshort") short v1, @NativeType("GLshort") short v2, @NativeType("GLshort") short v3) { + ARBVertexShader.glVertexAttrib4sARB(index, v0, v1, v2, v3); + } + + // --- [ glVertexAttrib4fARB ] --- + + /** + * Specifies the value of a generic vertex attribute. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + * @param v2 the vertex attribute z component + * @param v3 the vertex attribute w component + */ + public static void glVertexAttrib4fARB(@NativeType("GLuint") int index, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1, @NativeType("GLfloat") float v2, @NativeType("GLfloat") float v3) { + ARBVertexShader.glVertexAttrib4fARB(index, v0, v1, v2, v3); + } + + // --- [ glVertexAttrib4dARB ] --- + + /** + * Double version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + * @param v2 the vertex attribute z component + * @param v3 the vertex attribute w component + */ + public static void glVertexAttrib4dARB(@NativeType("GLuint") int index, @NativeType("GLdouble") double v0, @NativeType("GLdouble") double v1, @NativeType("GLdouble") double v2, @NativeType("GLdouble") double v3) { + ARBVertexShader.glVertexAttrib4dARB(index, v0, v1, v2, v3); + } + + // --- [ glVertexAttrib4NubARB ] --- + + /** + * Normalized unsigned byte version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param x the vertex attribute x component + * @param y the vertex attribute y component + * @param z the vertex attribute z component + * @param w the vertex attribute w component + */ + public static void glVertexAttrib4NubARB(@NativeType("GLuint") int index, @NativeType("GLubyte") byte x, @NativeType("GLubyte") byte y, @NativeType("GLubyte") byte z, @NativeType("GLubyte") byte w) { + ARBVertexShader.glVertexAttrib4NubARB(index, x, y, z, w); + } + + // --- [ glVertexAttrib1svARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib1svARB VertexAttrib1svARB} */ + public static void nglVertexAttrib1svARB(int index, long v) { + ARBVertexShader.nglVertexAttrib1svARB(index, v); + } + + /** + * Pointer version of {@link #glVertexAttrib1sARB VertexAttrib1sARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib1svARB(@NativeType("GLuint") int index, @NativeType("GLshort const *") ShortBuffer v) { + ARBVertexShader.glVertexAttrib1svARB(index, v); + } + + // --- [ glVertexAttrib1fvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib1fvARB VertexAttrib1fvARB} */ + public static void nglVertexAttrib1fvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib1fvARB(index, v); + } + + /** + * Pointer version of {@link #glVertexAttrib1fARB VertexAttrib1fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib1fvARB(@NativeType("GLuint") int index, @NativeType("GLfloat const *") FloatBuffer v) { + ARBVertexShader.glVertexAttrib1fvARB(index, v); + } + + // --- [ glVertexAttrib1dvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib1dvARB VertexAttrib1dvARB} */ + public static void nglVertexAttrib1dvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib1dvARB(index, v); + } + + /** + * Pointer version of {@link #glVertexAttrib1dARB VertexAttrib1dARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib1dvARB(@NativeType("GLuint") int index, @NativeType("GLdouble const *") DoubleBuffer v) { + ARBVertexShader.glVertexAttrib1dvARB(index, v); + } + + // --- [ glVertexAttrib2svARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib2svARB VertexAttrib2svARB} */ + public static void nglVertexAttrib2svARB(int index, long v) { + ARBVertexShader.nglVertexAttrib2svARB(index, v); + } + + /** + * Pointer version of {@link #glVertexAttrib2sARB VertexAttrib2sARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib2svARB(@NativeType("GLuint") int index, @NativeType("GLshort const *") ShortBuffer v) { + ARBVertexShader.glVertexAttrib2svARB(index, v); + } + + // --- [ glVertexAttrib2fvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib2fvARB VertexAttrib2fvARB} */ + public static void nglVertexAttrib2fvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib2fvARB(index, v); + } + + /** + * Pointer version of {@link #glVertexAttrib2fARB VertexAttrib2fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib2fvARB(@NativeType("GLuint") int index, @NativeType("GLfloat const *") FloatBuffer v) { + ARBVertexShader.glVertexAttrib2fvARB(index, v); + } + + // --- [ glVertexAttrib2dvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib2dvARB VertexAttrib2dvARB} */ + public static void nglVertexAttrib2dvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib2dvARB(index, v); + } + + /** + * Pointer version of {@link #glVertexAttrib2dARB VertexAttrib2dARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib2dvARB(@NativeType("GLuint") int index, @NativeType("GLdouble const *") DoubleBuffer v) { + ARBVertexShader.glVertexAttrib2dvARB(index, v); + } + + // --- [ glVertexAttrib3svARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib3svARB VertexAttrib3svARB} */ + public static void nglVertexAttrib3svARB(int index, long v) { + ARBVertexShader.nglVertexAttrib3svARB(index, v); + } + + /** + * Pointer version of {@link #glVertexAttrib3sARB VertexAttrib3sARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib3svARB(@NativeType("GLuint") int index, @NativeType("GLshort const *") ShortBuffer v) { + ARBVertexShader.glVertexAttrib3svARB(index, v); + } + + // --- [ glVertexAttrib3fvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib3fvARB VertexAttrib3fvARB} */ + public static void nglVertexAttrib3fvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib3fvARB(index, v); + } + + /** + * Pointer version of {@link #glVertexAttrib3fARB VertexAttrib3fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib3fvARB(@NativeType("GLuint") int index, @NativeType("GLfloat const *") FloatBuffer v) { + ARBVertexShader.glVertexAttrib3fvARB(index, v); + } + + // --- [ glVertexAttrib3dvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib3dvARB VertexAttrib3dvARB} */ + public static void nglVertexAttrib3dvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib3dvARB(index, v); + } + + /** + * Pointer version of {@link #glVertexAttrib3dARB VertexAttrib3dARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib3dvARB(@NativeType("GLuint") int index, @NativeType("GLdouble const *") DoubleBuffer v) { + ARBVertexShader.glVertexAttrib3dvARB(index, v); + } + + // --- [ glVertexAttrib4fvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4fvARB VertexAttrib4fvARB} */ + public static void nglVertexAttrib4fvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib4fvARB(index, v); + } + + /** + * Pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4fvARB(@NativeType("GLuint") int index, @NativeType("GLfloat const *") FloatBuffer v) { + ARBVertexShader.glVertexAttrib4fvARB(index, v); + } + + // --- [ glVertexAttrib4bvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4bvARB VertexAttrib4bvARB} */ + public static void nglVertexAttrib4bvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib4bvARB(index, v); + } + + /** + * Byte pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4bvARB(@NativeType("GLuint") int index, @NativeType("GLbyte const *") ByteBuffer v) { + ARBVertexShader.glVertexAttrib4bvARB(index, v); + } + + // --- [ glVertexAttrib4svARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4svARB VertexAttrib4svARB} */ + public static void nglVertexAttrib4svARB(int index, long v) { + ARBVertexShader.nglVertexAttrib4svARB(index, v); + } + + /** + * Pointer version of {@link #glVertexAttrib4sARB VertexAttrib4sARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4svARB(@NativeType("GLuint") int index, @NativeType("GLshort const *") ShortBuffer v) { + ARBVertexShader.glVertexAttrib4svARB(index, v); + } + + // --- [ glVertexAttrib4ivARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4ivARB VertexAttrib4ivARB} */ + public static void nglVertexAttrib4ivARB(int index, long v) { + ARBVertexShader.nglVertexAttrib4ivARB(index, v); + } + + /** + * Integer pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4ivARB(@NativeType("GLuint") int index, @NativeType("GLint const *") IntBuffer v) { + ARBVertexShader.glVertexAttrib4ivARB(index, v); + } + + // --- [ glVertexAttrib4ubvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4ubvARB VertexAttrib4ubvARB} */ + public static void nglVertexAttrib4ubvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib4ubvARB(index, v); + } + + /** + * Pointer version of {@link #glVertexAttrib4NubARB VertexAttrib4NubARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4ubvARB(@NativeType("GLuint") int index, @NativeType("GLubyte const *") ByteBuffer v) { + ARBVertexShader.glVertexAttrib4ubvARB(index, v); + } + + // --- [ glVertexAttrib4usvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4usvARB VertexAttrib4usvARB} */ + public static void nglVertexAttrib4usvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib4usvARB(index, v); + } + + /** + * Unsigned short pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4usvARB(@NativeType("GLuint") int index, @NativeType("GLushort const *") ShortBuffer v) { + ARBVertexShader.glVertexAttrib4usvARB(index, v); + } + + // --- [ glVertexAttrib4uivARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4uivARB VertexAttrib4uivARB} */ + public static void nglVertexAttrib4uivARB(int index, long v) { + ARBVertexShader.nglVertexAttrib4uivARB(index, v); + } + + /** + * Unsigned int pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4uivARB(@NativeType("GLuint") int index, @NativeType("GLuint const *") IntBuffer v) { + ARBVertexShader.glVertexAttrib4uivARB(index, v); + } + + // --- [ glVertexAttrib4dvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4dvARB VertexAttrib4dvARB} */ + public static void nglVertexAttrib4dvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib4dvARB(index, v); + } + + /** + * Pointer version of {@link #glVertexAttrib4dARB VertexAttrib4dARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4dvARB(@NativeType("GLuint") int index, @NativeType("GLdouble const *") DoubleBuffer v) { + ARBVertexShader.glVertexAttrib4dvARB(index, v); + } + + // --- [ glVertexAttrib4NbvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4NbvARB VertexAttrib4NbvARB} */ + public static void nglVertexAttrib4NbvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib4NbvARB(index, v); + } + + /** + * Normalized byte pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4NbvARB(@NativeType("GLuint") int index, @NativeType("GLbyte const *") ByteBuffer v) { + ARBVertexShader.glVertexAttrib4NbvARB(index, v); + } + + // --- [ glVertexAttrib4NsvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4NsvARB VertexAttrib4NsvARB} */ + public static void nglVertexAttrib4NsvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib4NsvARB(index, v); + } + + /** + * Normalized short pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4NsvARB(@NativeType("GLuint") int index, @NativeType("GLshort const *") ShortBuffer v) { + ARBVertexShader.glVertexAttrib4NsvARB(index, v); + } + + // --- [ glVertexAttrib4NivARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4NivARB VertexAttrib4NivARB} */ + public static void nglVertexAttrib4NivARB(int index, long v) { + ARBVertexShader.nglVertexAttrib4NivARB(index, v); + } + + /** + * Normalized int pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4NivARB(@NativeType("GLuint") int index, @NativeType("GLint const *") IntBuffer v) { + ARBVertexShader.glVertexAttrib4NivARB(index, v); + } + + // --- [ glVertexAttrib4NubvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4NubvARB VertexAttrib4NubvARB} */ + public static void nglVertexAttrib4NubvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib4NubvARB(index, v); + } + + /** + * Normalized unsigned byte pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4NubvARB(@NativeType("GLuint") int index, @NativeType("GLubyte const *") ByteBuffer v) { + ARBVertexShader.glVertexAttrib4NubvARB(index, v); + } + + // --- [ glVertexAttrib4NusvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4NusvARB VertexAttrib4NusvARB} */ + public static void nglVertexAttrib4NusvARB(int index, long v) { + ARBVertexShader.nglVertexAttrib4NusvARB(index, v); + } + + /** + * Normalized unsigned short pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4NusvARB(@NativeType("GLuint") int index, @NativeType("GLushort const *") ShortBuffer v) { + ARBVertexShader.glVertexAttrib4NusvARB(index, v); + } + + // --- [ glVertexAttrib4NuivARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4NuivARB VertexAttrib4NuivARB} */ + public static void nglVertexAttrib4NuivARB(int index, long v) { + ARBVertexShader.nglVertexAttrib4NuivARB(index, v); + } + + /** + * Normalized unsigned int pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4NuivARB(@NativeType("GLuint") int index, @NativeType("GLuint const *") IntBuffer v) { + ARBVertexShader.glVertexAttrib4NuivARB(index, v); + } + + // --- [ glVertexAttribPointerARB ] --- + + /** Unsafe version of: {@link #glVertexAttribPointerARB VertexAttribPointerARB} */ + public static void nglVertexAttribPointerARB(int index, int size, int type, boolean normalized, int stride, long pointer) { + ARBVertexShader.nglVertexAttribPointerARB(index, size, type, normalized, stride, pointer); + } + + /** + * Specifies the location and organization of a vertex attribute array. + * + * @param index the index of the generic vertex attribute to be modified + * @param size the number of values per vertex that are stored in the array. The initial value is 4. One of:| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
When a program string is loaded, it is interpreted according to syntactic and semantic rules corresponding to the program target specified by + * {@code target}. If a program violates the syntactic or semantic restrictions of the program target, ProgramStringARB generates the error + * {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION}.
+ * + *Additionally, ProgramString will update the program error position ({@link #GL_PROGRAM_ERROR_POSITION_ARB PROGRAM_ERROR_POSITION_ARB}) and error string ({@link #GL_PROGRAM_ERROR_STRING_ARB PROGRAM_ERROR_STRING_ARB}). If a + * program fails to load, the value of the program error position is set to the ubyte offset into the specified program string indicating where the first + * program error was detected. If the program fails to load because of a semantic restriction that is not detected until the program is fully scanned, the + * error position is set to the value of {@code len}. If a program loads successfully, the error position is set to the value negative one. The + * implementation-dependent program error string contains one or more error or warning messages. If a program loads succesfully, the error string may + * either contain warning messages or be empty.
+ * + * @param target the program target. One of:| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_PROGRAM_FORMAT_ASCII_ARB PROGRAM_FORMAT_ASCII_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_PROGRAM_LENGTH_ARB PROGRAM_LENGTH_ARB} | {@link #GL_PROGRAM_FORMAT_ARB PROGRAM_FORMAT_ARB} |
| {@link #GL_PROGRAM_BINDING_ARB PROGRAM_BINDING_ARB} | {@link #GL_PROGRAM_INSTRUCTIONS_ARB PROGRAM_INSTRUCTIONS_ARB} |
| {@link #GL_MAX_PROGRAM_INSTRUCTIONS_ARB MAX_PROGRAM_INSTRUCTIONS_ARB} | {@link #GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB PROGRAM_NATIVE_INSTRUCTIONS_ARB} |
| {@link #GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB} | {@link #GL_PROGRAM_TEMPORARIES_ARB PROGRAM_TEMPORARIES_ARB} |
| {@link #GL_MAX_PROGRAM_TEMPORARIES_ARB MAX_PROGRAM_TEMPORARIES_ARB} | {@link #GL_PROGRAM_NATIVE_TEMPORARIES_ARB PROGRAM_NATIVE_TEMPORARIES_ARB} |
| {@link #GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB MAX_PROGRAM_NATIVE_TEMPORARIES_ARB} | {@link #GL_PROGRAM_PARAMETERS_ARB PROGRAM_PARAMETERS_ARB} |
| {@link #GL_MAX_PROGRAM_PARAMETERS_ARB MAX_PROGRAM_PARAMETERS_ARB} | {@link #GL_PROGRAM_NATIVE_PARAMETERS_ARB PROGRAM_NATIVE_PARAMETERS_ARB} |
| {@link #GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB MAX_PROGRAM_NATIVE_PARAMETERS_ARB} | {@link #GL_PROGRAM_ATTRIBS_ARB PROGRAM_ATTRIBS_ARB} |
| {@link #GL_MAX_PROGRAM_ATTRIBS_ARB MAX_PROGRAM_ATTRIBS_ARB} | {@link #GL_PROGRAM_NATIVE_ATTRIBS_ARB PROGRAM_NATIVE_ATTRIBS_ARB} |
| {@link #GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB MAX_PROGRAM_NATIVE_ATTRIBS_ARB} | {@link #GL_PROGRAM_ADDRESS_REGISTERS_ARB PROGRAM_ADDRESS_REGISTERS_ARB} |
| {@link #GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB MAX_PROGRAM_ADDRESS_REGISTERS_ARB} | {@link #GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB} |
| {@link #GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB} | {@link #GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB MAX_PROGRAM_LOCAL_PARAMETERS_ARB} |
| {@link #GL_MAX_PROGRAM_ENV_PARAMETERS_ARB MAX_PROGRAM_ENV_PARAMETERS_ARB} | {@link #GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB PROGRAM_UNDER_NATIVE_LIMITS_ARB} |
| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_PROGRAM_LENGTH_ARB PROGRAM_LENGTH_ARB} | {@link #GL_PROGRAM_FORMAT_ARB PROGRAM_FORMAT_ARB} |
| {@link #GL_PROGRAM_BINDING_ARB PROGRAM_BINDING_ARB} | {@link #GL_PROGRAM_INSTRUCTIONS_ARB PROGRAM_INSTRUCTIONS_ARB} |
| {@link #GL_MAX_PROGRAM_INSTRUCTIONS_ARB MAX_PROGRAM_INSTRUCTIONS_ARB} | {@link #GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB PROGRAM_NATIVE_INSTRUCTIONS_ARB} |
| {@link #GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB} | {@link #GL_PROGRAM_TEMPORARIES_ARB PROGRAM_TEMPORARIES_ARB} |
| {@link #GL_MAX_PROGRAM_TEMPORARIES_ARB MAX_PROGRAM_TEMPORARIES_ARB} | {@link #GL_PROGRAM_NATIVE_TEMPORARIES_ARB PROGRAM_NATIVE_TEMPORARIES_ARB} |
| {@link #GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB MAX_PROGRAM_NATIVE_TEMPORARIES_ARB} | {@link #GL_PROGRAM_PARAMETERS_ARB PROGRAM_PARAMETERS_ARB} |
| {@link #GL_MAX_PROGRAM_PARAMETERS_ARB MAX_PROGRAM_PARAMETERS_ARB} | {@link #GL_PROGRAM_NATIVE_PARAMETERS_ARB PROGRAM_NATIVE_PARAMETERS_ARB} |
| {@link #GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB MAX_PROGRAM_NATIVE_PARAMETERS_ARB} | {@link #GL_PROGRAM_ATTRIBS_ARB PROGRAM_ATTRIBS_ARB} |
| {@link #GL_MAX_PROGRAM_ATTRIBS_ARB MAX_PROGRAM_ATTRIBS_ARB} | {@link #GL_PROGRAM_NATIVE_ATTRIBS_ARB PROGRAM_NATIVE_ATTRIBS_ARB} |
| {@link #GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB MAX_PROGRAM_NATIVE_ATTRIBS_ARB} | {@link #GL_PROGRAM_ADDRESS_REGISTERS_ARB PROGRAM_ADDRESS_REGISTERS_ARB} |
| {@link #GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB MAX_PROGRAM_ADDRESS_REGISTERS_ARB} | {@link #GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB} |
| {@link #GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB} | {@link #GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB MAX_PROGRAM_LOCAL_PARAMETERS_ARB} |
| {@link #GL_MAX_PROGRAM_ENV_PARAMETERS_ARB MAX_PROGRAM_ENV_PARAMETERS_ARB} | {@link #GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB PROGRAM_UNDER_NATIVE_LIMITS_ARB} |
{@code n} ubytes are returned into the array program where {@code n} is the length of the program in ubytes, as returned by {@link #glGetProgramivARB GetProgramivARB} when + * {@code pname} is {@link #GL_PROGRAM_LENGTH_ARB PROGRAM_LENGTH_ARB}. The program string is always returned using the format given when the program string was specified.
+ * + * @param target the program target. One of:| {@link #GL_VERTEX_PROGRAM_ARB VERTEX_PROGRAM_ARB} | {@link ARBFragmentProgram#GL_FRAGMENT_PROGRAM_ARB FRAGMENT_PROGRAM_ARB} |
| {@link #GL_PROGRAM_STRING_ARB PROGRAM_STRING_ARB} |
| {@link GL15#GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING VERTEX_ATTRIB_ARRAY_BUFFER_BINDING} | {@link ARBVertexShader#GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB VERTEX_ATTRIB_ARRAY_ENABLED_ARB} |
| {@link ARBVertexShader#GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB VERTEX_ATTRIB_ARRAY_SIZE_ARB} | {@link ARBVertexShader#GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB VERTEX_ATTRIB_ARRAY_STRIDE_ARB} |
| {@link ARBVertexShader#GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB VERTEX_ATTRIB_ARRAY_TYPE_ARB} | {@link ARBVertexShader#GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB} |
| {@link ARBVertexShader#GL_CURRENT_VERTEX_ATTRIB_ARB CURRENT_VERTEX_ATTRIB_ARB} | {@link GL30#GL_VERTEX_ATTRIB_ARRAY_INTEGER VERTEX_ATTRIB_ARRAY_INTEGER} |
| {@link GL33#GL_VERTEX_ATTRIB_ARRAY_DIVISOR VERTEX_ATTRIB_ARRAY_DIVISOR} |
| {@link GL15#GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING VERTEX_ATTRIB_ARRAY_BUFFER_BINDING} | {@link ARBVertexShader#GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB VERTEX_ATTRIB_ARRAY_ENABLED_ARB} |
| {@link ARBVertexShader#GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB VERTEX_ATTRIB_ARRAY_SIZE_ARB} | {@link ARBVertexShader#GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB VERTEX_ATTRIB_ARRAY_STRIDE_ARB} |
| {@link ARBVertexShader#GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB VERTEX_ATTRIB_ARRAY_TYPE_ARB} | {@link ARBVertexShader#GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB} |
| {@link ARBVertexShader#GL_CURRENT_VERTEX_ATTRIB_ARB CURRENT_VERTEX_ATTRIB_ARB} | {@link GL30#GL_VERTEX_ATTRIB_ARRAY_INTEGER VERTEX_ATTRIB_ARRAY_INTEGER} |
| {@link GL33#GL_VERTEX_ATTRIB_ARRAY_DIVISOR VERTEX_ATTRIB_ARRAY_DIVISOR} |
| {@link ARBVertexShader#GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB VERTEX_ATTRIB_ARRAY_POINTER_ARB} |
| {@link ARBVertexShader#GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB VERTEX_ATTRIB_ARRAY_POINTER_ARB} |
This extension adds programmable vertex level processing to OpenGL. The application can write vertex shaders in a high level language as defined in the + * OpenGL Shading Language specification. A vertex shader replaces the transformation, texture coordinate generation and lighting parts of OpenGL, and it + * also adds texture access at the vertex level. Furthermore, management of vertex shader objects and loading generic attributes are discussed. A vertex + * shader object, attached to a program object, can be compiled and linked to produce an executable that runs on the vertex processor in OpenGL. + * This extension also defines how such an executable interacts with the fixed functionality vertex processing of OpenGL 1.4.
+ * + *Promoted to core in {@link GL20 OpenGL 2.0}.
+ */ +public class ARBVertexShader { + + /** Accepted by the {@code shaderType} argument of CreateShaderObjectARB and returned by the {@code params} parameter of GetObjectParameter{if}vARB. */ + public static final int GL_VERTEX_SHADER_ARB = 0x8B31; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 0x8B4A, + GL_MAX_VARYING_FLOATS_ARB = 0x8B4B, + GL_MAX_VERTEX_ATTRIBS_ARB = 0x8869, + GL_MAX_TEXTURE_IMAGE_UNITS_ARB = 0x8872, + GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 0x8B4C, + GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 0x8B4D, + GL_MAX_TEXTURE_COORDS_ARB = 0x8871; + + /** + * Accepted by the {@code cap} parameter of Disable, Enable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int + GL_VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642, + GL_VERTEX_PROGRAM_TWO_SIDE_ARB = 0x8643; + + /** Accepted by the {@code pname} parameter GetObjectParameter{if}vARB. */ + public static final int + GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = 0x8B89, + GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 0x8B8A; + + /** Accepted by the {@code pname} parameter of GetVertexAttrib{dfi}vARB. */ + public static final int + GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 0x8622, + GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = 0x8623, + GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 0x8624, + GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = 0x8625, + GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A, + GL_CURRENT_VERTEX_ATTRIB_ARB = 0x8626; + + /** Accepted by the {@code pname} parameter of GetVertexAttribPointervARB. */ + public static final int GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645; + + /** Returned by the {@code type} parameter of GetActiveAttribARB. */ + public static final int + GL_FLOAT_VEC2_ARB = 0x8B50, + GL_FLOAT_VEC3_ARB = 0x8B51, + GL_FLOAT_VEC4_ARB = 0x8B52, + GL_FLOAT_MAT2_ARB = 0x8B5A, + GL_FLOAT_MAT3_ARB = 0x8B5B, + GL_FLOAT_MAT4_ARB = 0x8B5C; + + static { GL.initialize(); } + + protected ARBVertexShader() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glVertexAttrib1fARB, caps.glVertexAttrib1sARB, caps.glVertexAttrib1dARB, caps.glVertexAttrib2fARB, caps.glVertexAttrib2sARB, + caps.glVertexAttrib2dARB, caps.glVertexAttrib3fARB, caps.glVertexAttrib3sARB, caps.glVertexAttrib3dARB, caps.glVertexAttrib4fARB, + caps.glVertexAttrib4sARB, caps.glVertexAttrib4dARB, caps.glVertexAttrib4NubARB, caps.glVertexAttrib1fvARB, caps.glVertexAttrib1svARB, + caps.glVertexAttrib1dvARB, caps.glVertexAttrib2fvARB, caps.glVertexAttrib2svARB, caps.glVertexAttrib2dvARB, caps.glVertexAttrib3fvARB, + caps.glVertexAttrib3svARB, caps.glVertexAttrib3dvARB, caps.glVertexAttrib4fvARB, caps.glVertexAttrib4svARB, caps.glVertexAttrib4dvARB, + caps.glVertexAttrib4ivARB, caps.glVertexAttrib4bvARB, caps.glVertexAttrib4ubvARB, caps.glVertexAttrib4usvARB, caps.glVertexAttrib4uivARB, + caps.glVertexAttrib4NbvARB, caps.glVertexAttrib4NsvARB, caps.glVertexAttrib4NivARB, caps.glVertexAttrib4NubvARB, caps.glVertexAttrib4NusvARB, + caps.glVertexAttrib4NuivARB, caps.glVertexAttribPointerARB, caps.glEnableVertexAttribArrayARB, caps.glDisableVertexAttribArrayARB, + caps.glBindAttribLocationARB, caps.glGetActiveAttribARB, caps.glGetAttribLocationARB, caps.glGetVertexAttribivARB, caps.glGetVertexAttribfvARB, + caps.glGetVertexAttribdvARB, caps.glGetVertexAttribPointervARB + ); + } + + // --- [ glVertexAttrib1fARB ] --- + + /** + * Specifies the value of a generic vertex attribute. The y and z components are implicitly set to 0.0f and w to 1.0f. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + */ + public static native void glVertexAttrib1fARB(@NativeType("GLuint") int index, @NativeType("GLfloat") float v0); + + // --- [ glVertexAttrib1sARB ] --- + + /** + * Short version of {@link #glVertexAttrib1fARB VertexAttrib1fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + */ + public static native void glVertexAttrib1sARB(@NativeType("GLuint") int index, @NativeType("GLshort") short v0); + + // --- [ glVertexAttrib1dARB ] --- + + /** + * Double version of {@link #glVertexAttrib1fARB VertexAttrib1fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + */ + public static native void glVertexAttrib1dARB(@NativeType("GLuint") int index, @NativeType("GLdouble") double v0); + + // --- [ glVertexAttrib2fARB ] --- + + /** + * Specifies the value of a generic vertex attribute. The y component is implicitly set to 0.0f and w to 1.0f. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + */ + public static native void glVertexAttrib2fARB(@NativeType("GLuint") int index, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1); + + // --- [ glVertexAttrib2sARB ] --- + + /** + * Short version of {@link #glVertexAttrib2fARB VertexAttrib2fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + */ + public static native void glVertexAttrib2sARB(@NativeType("GLuint") int index, @NativeType("GLshort") short v0, @NativeType("GLshort") short v1); + + // --- [ glVertexAttrib2dARB ] --- + + /** + * Double version of {@link #glVertexAttrib2fARB VertexAttrib2fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + */ + public static native void glVertexAttrib2dARB(@NativeType("GLuint") int index, @NativeType("GLdouble") double v0, @NativeType("GLdouble") double v1); + + // --- [ glVertexAttrib3fARB ] --- + + /** + * Specifies the value of a generic vertex attribute. The w is implicitly set to 1.0f. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + * @param v2 the vertex attribute z component + */ + public static native void glVertexAttrib3fARB(@NativeType("GLuint") int index, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1, @NativeType("GLfloat") float v2); + + // --- [ glVertexAttrib3sARB ] --- + + /** + * Short version of {@link #glVertexAttrib3fARB VertexAttrib3fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + * @param v2 the vertex attribute z component + */ + public static native void glVertexAttrib3sARB(@NativeType("GLuint") int index, @NativeType("GLshort") short v0, @NativeType("GLshort") short v1, @NativeType("GLshort") short v2); + + // --- [ glVertexAttrib3dARB ] --- + + /** + * Double version of {@link #glVertexAttrib3fARB VertexAttrib3fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + * @param v2 the vertex attribute z component + */ + public static native void glVertexAttrib3dARB(@NativeType("GLuint") int index, @NativeType("GLdouble") double v0, @NativeType("GLdouble") double v1, @NativeType("GLdouble") double v2); + + // --- [ glVertexAttrib4fARB ] --- + + /** + * Specifies the value of a generic vertex attribute. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + * @param v2 the vertex attribute z component + * @param v3 the vertex attribute w component + */ + public static native void glVertexAttrib4fARB(@NativeType("GLuint") int index, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1, @NativeType("GLfloat") float v2, @NativeType("GLfloat") float v3); + + // --- [ glVertexAttrib4sARB ] --- + + /** + * Short version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + * @param v2 the vertex attribute z component + * @param v3 the vertex attribute w component + */ + public static native void glVertexAttrib4sARB(@NativeType("GLuint") int index, @NativeType("GLshort") short v0, @NativeType("GLshort") short v1, @NativeType("GLshort") short v2, @NativeType("GLshort") short v3); + + // --- [ glVertexAttrib4dARB ] --- + + /** + * Double version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v0 the vertex attribute x component + * @param v1 the vertex attribute y component + * @param v2 the vertex attribute z component + * @param v3 the vertex attribute w component + */ + public static native void glVertexAttrib4dARB(@NativeType("GLuint") int index, @NativeType("GLdouble") double v0, @NativeType("GLdouble") double v1, @NativeType("GLdouble") double v2, @NativeType("GLdouble") double v3); + + // --- [ glVertexAttrib4NubARB ] --- + + /** + * Normalized unsigned byte version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param x the vertex attribute x component + * @param y the vertex attribute y component + * @param z the vertex attribute z component + * @param w the vertex attribute w component + */ + public static native void glVertexAttrib4NubARB(@NativeType("GLuint") int index, @NativeType("GLubyte") byte x, @NativeType("GLubyte") byte y, @NativeType("GLubyte") byte z, @NativeType("GLubyte") byte w); + + // --- [ glVertexAttrib1fvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib1fvARB VertexAttrib1fvARB} */ + public static native void nglVertexAttrib1fvARB(int index, long v); + + /** + * Pointer version of {@link #glVertexAttrib1fARB VertexAttrib1fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib1fvARB(@NativeType("GLuint") int index, @NativeType("GLfloat const *") FloatBuffer v) { + if (CHECKS) { + check(v, 1); + } + nglVertexAttrib1fvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib1svARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib1svARB VertexAttrib1svARB} */ + public static native void nglVertexAttrib1svARB(int index, long v); + + /** + * Pointer version of {@link #glVertexAttrib1sARB VertexAttrib1sARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib1svARB(@NativeType("GLuint") int index, @NativeType("GLshort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 1); + } + nglVertexAttrib1svARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib1dvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib1dvARB VertexAttrib1dvARB} */ + public static native void nglVertexAttrib1dvARB(int index, long v); + + /** + * Pointer version of {@link #glVertexAttrib1dARB VertexAttrib1dARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib1dvARB(@NativeType("GLuint") int index, @NativeType("GLdouble const *") DoubleBuffer v) { + if (CHECKS) { + check(v, 1); + } + nglVertexAttrib1dvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib2fvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib2fvARB VertexAttrib2fvARB} */ + public static native void nglVertexAttrib2fvARB(int index, long v); + + /** + * Pointer version of {@link #glVertexAttrib2fARB VertexAttrib2fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib2fvARB(@NativeType("GLuint") int index, @NativeType("GLfloat const *") FloatBuffer v) { + if (CHECKS) { + check(v, 2); + } + nglVertexAttrib2fvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib2svARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib2svARB VertexAttrib2svARB} */ + public static native void nglVertexAttrib2svARB(int index, long v); + + /** + * Pointer version of {@link #glVertexAttrib2sARB VertexAttrib2sARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib2svARB(@NativeType("GLuint") int index, @NativeType("GLshort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 2); + } + nglVertexAttrib2svARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib2dvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib2dvARB VertexAttrib2dvARB} */ + public static native void nglVertexAttrib2dvARB(int index, long v); + + /** + * Pointer version of {@link #glVertexAttrib2dARB VertexAttrib2dARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib2dvARB(@NativeType("GLuint") int index, @NativeType("GLdouble const *") DoubleBuffer v) { + if (CHECKS) { + check(v, 2); + } + nglVertexAttrib2dvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib3fvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib3fvARB VertexAttrib3fvARB} */ + public static native void nglVertexAttrib3fvARB(int index, long v); + + /** + * Pointer version of {@link #glVertexAttrib3fARB VertexAttrib3fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib3fvARB(@NativeType("GLuint") int index, @NativeType("GLfloat const *") FloatBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglVertexAttrib3fvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib3svARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib3svARB VertexAttrib3svARB} */ + public static native void nglVertexAttrib3svARB(int index, long v); + + /** + * Pointer version of {@link #glVertexAttrib3sARB VertexAttrib3sARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib3svARB(@NativeType("GLuint") int index, @NativeType("GLshort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglVertexAttrib3svARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib3dvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib3dvARB VertexAttrib3dvARB} */ + public static native void nglVertexAttrib3dvARB(int index, long v); + + /** + * Pointer version of {@link #glVertexAttrib3dARB VertexAttrib3dARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib3dvARB(@NativeType("GLuint") int index, @NativeType("GLdouble const *") DoubleBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglVertexAttrib3dvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib4fvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4fvARB VertexAttrib4fvARB} */ + public static native void nglVertexAttrib4fvARB(int index, long v); + + /** + * Pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4fvARB(@NativeType("GLuint") int index, @NativeType("GLfloat const *") FloatBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttrib4fvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib4svARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4svARB VertexAttrib4svARB} */ + public static native void nglVertexAttrib4svARB(int index, long v); + + /** + * Pointer version of {@link #glVertexAttrib4sARB VertexAttrib4sARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4svARB(@NativeType("GLuint") int index, @NativeType("GLshort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttrib4svARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib4dvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4dvARB VertexAttrib4dvARB} */ + public static native void nglVertexAttrib4dvARB(int index, long v); + + /** + * Pointer version of {@link #glVertexAttrib4dARB VertexAttrib4dARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4dvARB(@NativeType("GLuint") int index, @NativeType("GLdouble const *") DoubleBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttrib4dvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib4ivARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4ivARB VertexAttrib4ivARB} */ + public static native void nglVertexAttrib4ivARB(int index, long v); + + /** + * Integer pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4ivARB(@NativeType("GLuint") int index, @NativeType("GLint const *") IntBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttrib4ivARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib4bvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4bvARB VertexAttrib4bvARB} */ + public static native void nglVertexAttrib4bvARB(int index, long v); + + /** + * Byte pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4bvARB(@NativeType("GLuint") int index, @NativeType("GLbyte const *") ByteBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttrib4bvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib4ubvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4ubvARB VertexAttrib4ubvARB} */ + public static native void nglVertexAttrib4ubvARB(int index, long v); + + /** + * Pointer version of {@link #glVertexAttrib4NubARB VertexAttrib4NubARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4ubvARB(@NativeType("GLuint") int index, @NativeType("GLubyte const *") ByteBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttrib4ubvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib4usvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4usvARB VertexAttrib4usvARB} */ + public static native void nglVertexAttrib4usvARB(int index, long v); + + /** + * Unsigned short pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4usvARB(@NativeType("GLuint") int index, @NativeType("GLushort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttrib4usvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib4uivARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4uivARB VertexAttrib4uivARB} */ + public static native void nglVertexAttrib4uivARB(int index, long v); + + /** + * Unsigned int pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4uivARB(@NativeType("GLuint") int index, @NativeType("GLuint const *") IntBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttrib4uivARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib4NbvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4NbvARB VertexAttrib4NbvARB} */ + public static native void nglVertexAttrib4NbvARB(int index, long v); + + /** + * Normalized byte pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4NbvARB(@NativeType("GLuint") int index, @NativeType("GLbyte const *") ByteBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttrib4NbvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib4NsvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4NsvARB VertexAttrib4NsvARB} */ + public static native void nglVertexAttrib4NsvARB(int index, long v); + + /** + * Normalized short pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4NsvARB(@NativeType("GLuint") int index, @NativeType("GLshort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttrib4NsvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib4NivARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4NivARB VertexAttrib4NivARB} */ + public static native void nglVertexAttrib4NivARB(int index, long v); + + /** + * Normalized int pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4NivARB(@NativeType("GLuint") int index, @NativeType("GLint const *") IntBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttrib4NivARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib4NubvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4NubvARB VertexAttrib4NubvARB} */ + public static native void nglVertexAttrib4NubvARB(int index, long v); + + /** + * Normalized unsigned byte pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4NubvARB(@NativeType("GLuint") int index, @NativeType("GLubyte const *") ByteBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttrib4NubvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib4NusvARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4NusvARB VertexAttrib4NusvARB} */ + public static native void nglVertexAttrib4NusvARB(int index, long v); + + /** + * Normalized unsigned short pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4NusvARB(@NativeType("GLuint") int index, @NativeType("GLushort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttrib4NusvARB(index, memAddress(v)); + } + + // --- [ glVertexAttrib4NuivARB ] --- + + /** Unsafe version of: {@link #glVertexAttrib4NuivARB VertexAttrib4NuivARB} */ + public static native void nglVertexAttrib4NuivARB(int index, long v); + + /** + * Normalized unsigned int pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}. + * + * @param index the index of the generic vertex attribute to be modified + * @param v the vertex attribute buffer + */ + public static void glVertexAttrib4NuivARB(@NativeType("GLuint") int index, @NativeType("GLuint const *") IntBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttrib4NuivARB(index, memAddress(v)); + } + + // --- [ glVertexAttribPointerARB ] --- + + /** Unsafe version of: {@link #glVertexAttribPointerARB VertexAttribPointerARB} */ + public static native void nglVertexAttribPointerARB(int index, int size, int type, boolean normalized, int stride, long pointer); + + /** + * Specifies the location and organization of a vertex attribute array. + * + * @param index the index of the generic vertex attribute to be modified + * @param size the number of values per vertex that are stored in the array. The initial value is 4. One of:| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| {@link GL15#GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING VERTEX_ATTRIB_ARRAY_BUFFER_BINDING} | {@link #GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB VERTEX_ATTRIB_ARRAY_ENABLED_ARB} |
| {@link #GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB VERTEX_ATTRIB_ARRAY_SIZE_ARB} | {@link #GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB VERTEX_ATTRIB_ARRAY_STRIDE_ARB} |
| {@link #GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB VERTEX_ATTRIB_ARRAY_TYPE_ARB} | {@link #GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB} |
| {@link #GL_CURRENT_VERTEX_ATTRIB_ARB CURRENT_VERTEX_ATTRIB_ARB} | {@link GL30#GL_VERTEX_ATTRIB_ARRAY_INTEGER VERTEX_ATTRIB_ARRAY_INTEGER} |
| {@link GL33#GL_VERTEX_ATTRIB_ARRAY_DIVISOR VERTEX_ATTRIB_ARRAY_DIVISOR} |
| {@link GL15#GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING VERTEX_ATTRIB_ARRAY_BUFFER_BINDING} | {@link #GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB VERTEX_ATTRIB_ARRAY_ENABLED_ARB} |
| {@link #GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB VERTEX_ATTRIB_ARRAY_SIZE_ARB} | {@link #GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB VERTEX_ATTRIB_ARRAY_STRIDE_ARB} |
| {@link #GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB VERTEX_ATTRIB_ARRAY_TYPE_ARB} | {@link #GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB} |
| {@link #GL_CURRENT_VERTEX_ATTRIB_ARB CURRENT_VERTEX_ATTRIB_ARB} | {@link GL30#GL_VERTEX_ATTRIB_ARRAY_INTEGER VERTEX_ATTRIB_ARRAY_INTEGER} |
| {@link GL33#GL_VERTEX_ATTRIB_ARRAY_DIVISOR VERTEX_ATTRIB_ARRAY_DIVISOR} |
| {@link #GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB VERTEX_ATTRIB_ARRAY_POINTER_ARB} |
| {@link #GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB VERTEX_ATTRIB_ARRAY_POINTER_ARB} |
This extension adds two new vertex attribute data formats: a signed 2.10.10.10 and an unsigned 2.10.10.10 vertex data format. These vertex data formats + * describe a 4 component stream which can be used to store normals or other attributes in a quantized form. Normals, tangents, binormals and other vertex + * attributes can often be specified at reduced precision without introducing noticeable artifacts, reducing the amount of memory and memory bandwidth they consume.
+ * + *Promoted to core in {@link GL33 OpenGL 3.3}.
+ */ +public class ARBVertexType2_10_10_10_REV { + + /** + * Accepted by the {@code type} parameter of VertexAttribPointer, VertexPointer, NormalPointer, ColorPointer, SecondaryColorPointer, TexCoordPointer, + * VertexAttribP{1234}ui, VertexP*, TexCoordP*, MultiTexCoordP*, NormalP3ui, ColorP*, SecondaryColorP and VertexAttribP*. + */ + public static final int GL_INT_2_10_10_10_REV = 0x8D9F; + + static { GL.initialize(); } + + protected ARBVertexType2_10_10_10_REV() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, boolean fc) { + return (fc || checkFunctions( + caps.glVertexP2ui, caps.glVertexP3ui, caps.glVertexP4ui, caps.glVertexP2uiv, caps.glVertexP3uiv, caps.glVertexP4uiv, caps.glTexCoordP1ui, + caps.glTexCoordP2ui, caps.glTexCoordP3ui, caps.glTexCoordP4ui, caps.glTexCoordP1uiv, caps.glTexCoordP2uiv, caps.glTexCoordP3uiv, + caps.glTexCoordP4uiv, caps.glMultiTexCoordP1ui, caps.glMultiTexCoordP2ui, caps.glMultiTexCoordP3ui, caps.glMultiTexCoordP4ui, + caps.glMultiTexCoordP1uiv, caps.glMultiTexCoordP2uiv, caps.glMultiTexCoordP3uiv, caps.glMultiTexCoordP4uiv, caps.glNormalP3ui, caps.glNormalP3uiv, + caps.glColorP3ui, caps.glColorP4ui, caps.glColorP3uiv, caps.glColorP4uiv, caps.glSecondaryColorP3ui, caps.glSecondaryColorP3uiv + )) && checkFunctions( + caps.glVertexAttribP1ui, caps.glVertexAttribP2ui, caps.glVertexAttribP3ui, caps.glVertexAttribP4ui, caps.glVertexAttribP1uiv, + caps.glVertexAttribP2uiv, caps.glVertexAttribP3uiv, caps.glVertexAttribP4uiv + ); + } + + // --- [ glVertexP2ui ] --- + + /** + * Packed component version of {@link GL11#glVertex2f Vertex2f}. + * + * @param type type of packing used on the data. One of:| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| type | of | packing | used | on | the | data |
| type | of | packing | used | on | the | data |
| type | of | packing | used | on | the | data |
| type | of | packing | used | on | the | data |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
OpenGL is modeled on a pipeline of operations. The final stage in this pipeline before rasterization is the viewport transformation. This stage + * transforms vertices from view space into window coordinates and allows the application to specify a rectangular region of screen space into which OpenGL + * should draw primitives. Unextended OpenGL implementations provide a single viewport per context. In order to draw primitives into multiple viewports, + * the OpenGL viewport may be changed between several draw calls. With the advent of Geometry Shaders, it has become possible for an application to amplify + * geometry and produce multiple output primitives for each primitive input to the Geometry Shader. It is possible to direct these primitives to render + * into a selected render target. However, all render targets share the same, global OpenGL viewport.
+ * + *This extension enhances OpenGL by providing a mechanism to expose multiple viewports. Each viewport is specified as a rectangle. The destination + * viewport may be selected per-primitive by the geometry shader. This allows the Geometry Shader to produce different versions of primitives destined for + * separate viewport rectangles on the same surface. Additionally, when combined with multiple framebuffer attachments, it allows a different viewport + * rectangle to be selected for each. This extension also exposes a separate scissor rectangle for each viewport. Finally, the viewport bounds are now + * floating point quantities allowing fractional pixel offsets to be applied during the viewport transform.
+ * + *Requires {@link GL32 OpenGL 3.2} or {@link EXTGeometryShader4 EXT_geometry_shader4} or {@link ARBGeometryShader4 ARB_geometry_shader4}. Promoted to core in {@link GL41 OpenGL 4.1}.
+ */ +public class ARBViewportArray { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, GetDoublev and GetInteger64v. */ + public static final int + GL_MAX_VIEWPORTS = 0x825B, + GL_VIEWPORT_SUBPIXEL_BITS = 0x825C, + GL_VIEWPORT_BOUNDS_RANGE = 0x825D, + GL_LAYER_PROVOKING_VERTEX = 0x825E, + GL_VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F; + + /** Returned in the {@code data} parameter from a Get query with a {@code pname} of LAYER_PROVOKING_VERTEX or VIEWPORT_INDEX_PROVOKING_VERTEX. */ + public static final int GL_UNDEFINED_VERTEX = 0x8260; + + static { GL.initialize(); } + + protected ARBViewportArray() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glViewportArrayv, caps.glViewportIndexedf, caps.glViewportIndexedfv, caps.glScissorArrayv, caps.glScissorIndexed, caps.glScissorIndexedv, + caps.glDepthRangeArrayv, caps.glDepthRangeIndexed, caps.glGetFloati_v, caps.glGetDoublei_v + ); + } + + // --- [ glViewportArrayv ] --- + + /** + * Unsafe version of: {@link #glViewportArrayv ViewportArrayv} + * + * @param count the number of viewports to set + */ + public static void nglViewportArrayv(int first, int count, long v) { + GL41C.nglViewportArrayv(first, count, v); + } + + /** + * Sets multiple viewports. + * + * @param first the first viewport to set + * @param v an array containing the viewport parameters + */ + public static void glViewportArrayv(@NativeType("GLuint") int first, @NativeType("GLfloat const *") FloatBuffer v) { + GL41C.glViewportArrayv(first, v); + } + + // --- [ glViewportIndexedf ] --- + + /** + * Sets a specified viewport. + * + * @param index the viewport to set + * @param x the left viewport coordinate + * @param y the bottom viewport coordinate + * @param w the viewport width + * @param h the viewport height + */ + public static void glViewportIndexedf(@NativeType("GLuint") int index, @NativeType("GLfloat") float x, @NativeType("GLfloat") float y, @NativeType("GLfloat") float w, @NativeType("GLfloat") float h) { + GL41C.glViewportIndexedf(index, x, y, w, h); + } + + // --- [ glViewportIndexedfv ] --- + + /** Unsafe version of: {@link #glViewportIndexedfv ViewportIndexedfv} */ + public static void nglViewportIndexedfv(int index, long v) { + GL41C.nglViewportIndexedfv(index, v); + } + + /** + * Pointer version of {@link #glViewportIndexedf ViewportIndexedf}. + * + * @param index the viewport to set + * @param v the viewport parameters + */ + public static void glViewportIndexedfv(@NativeType("GLuint") int index, @NativeType("GLfloat const *") FloatBuffer v) { + GL41C.glViewportIndexedfv(index, v); + } + + // --- [ glScissorArrayv ] --- + + /** + * Unsafe version of: {@link #glScissorArrayv ScissorArrayv} + * + * @param count the number of scissor boxes to modify + */ + public static void nglScissorArrayv(int first, int count, long v) { + GL41C.nglScissorArrayv(first, count, v); + } + + /** + * Defines the scissor box for multiple viewports. + * + * @param first the index of the first viewport whose scissor box to modify + * @param v an array containing the left, bottom, width and height of each scissor box, in that order + */ + public static void glScissorArrayv(@NativeType("GLuint") int first, @NativeType("GLint const *") IntBuffer v) { + GL41C.glScissorArrayv(first, v); + } + + // --- [ glScissorIndexed ] --- + + /** + * Defines the scissor box for a specific viewport. + * + * @param index the index of the viewport whose scissor box to modify + * @param left the left scissor box coordinate + * @param bottom the bottom scissor box coordinate + * @param width the scissor box width + * @param height the scissor box height + */ + public static void glScissorIndexed(@NativeType("GLuint") int index, @NativeType("GLint") int left, @NativeType("GLint") int bottom, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height) { + GL41C.glScissorIndexed(index, left, bottom, width, height); + } + + // --- [ glScissorIndexedv ] --- + + /** Unsafe version of: {@link #glScissorIndexedv ScissorIndexedv} */ + public static void nglScissorIndexedv(int index, long v) { + GL41C.nglScissorIndexedv(index, v); + } + + /** + * Pointer version of {@link #glScissorIndexed ScissorIndexed}. + * + * @param index the index of the viewport whose scissor box to modify + * @param v an array containing the left, bottom, width and height of each scissor box, in that order + */ + public static void glScissorIndexedv(@NativeType("GLuint") int index, @NativeType("GLint const *") IntBuffer v) { + GL41C.glScissorIndexedv(index, v); + } + + // --- [ glDepthRangeArrayv ] --- + + /** + * Unsafe version of: {@link #glDepthRangeArrayv DepthRangeArrayv} + * + * @param count the number of viewports whose depth range to update + */ + public static void nglDepthRangeArrayv(int first, int count, long v) { + GL41C.nglDepthRangeArrayv(first, count, v); + } + + /** + * Specifies mapping of depth values from normalized device coordinates to window coordinates for a specified set of viewports. + * + * @param first the index of the first viewport whose depth range to update + * @param v n array containing the near and far values for the depth range of each modified viewport + */ + public static void glDepthRangeArrayv(@NativeType("GLuint") int first, @NativeType("GLdouble const *") DoubleBuffer v) { + GL41C.glDepthRangeArrayv(first, v); + } + + // --- [ glDepthRangeIndexed ] --- + + /** + * Specifies mapping of depth values from normalized device coordinates to window coordinates for a specified viewport. + * + * @param index the index of the viewport whose depth range to update + * @param zNear the mapping of the near clipping plane to window coordinates. The initial value is 0. + * @param zFar the mapping of the far clipping plane to window coordinates. The initial value is 1. + */ + public static void glDepthRangeIndexed(@NativeType("GLuint") int index, @NativeType("GLdouble") double zNear, @NativeType("GLdouble") double zFar) { + GL41C.glDepthRangeIndexed(index, zNear, zFar); + } + + // --- [ glGetFloati_v ] --- + + /** Unsafe version of: {@link #glGetFloati_v GetFloati_v} */ + public static void nglGetFloati_v(int target, int index, long data) { + GL41C.nglGetFloati_v(target, index, data); + } + + /** + * Queries the float value of an indexed state variable. + * + * @param target the indexed state to query + * @param index the index of the element being queried + * @param data a scalar or buffer in which to place the returned data + */ + public static void glGetFloati_v(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLfloat *") FloatBuffer data) { + GL41C.glGetFloati_v(target, index, data); + } + + /** + * Queries the float value of an indexed state variable. + * + * @param target the indexed state to query + * @param index the index of the element being queried + */ + @NativeType("void") + public static float glGetFloati(@NativeType("GLenum") int target, @NativeType("GLuint") int index) { + return GL41C.glGetFloati(target, index); + } + + // --- [ glGetDoublei_v ] --- + + /** Unsafe version of: {@link #glGetDoublei_v GetDoublei_v} */ + public static void nglGetDoublei_v(int target, int index, long data) { + GL41C.nglGetDoublei_v(target, index, data); + } + + /** + * Queries the double value of an indexed state variable. + * + * @param target the indexed state to query + * @param index the index of the element being queried + * @param data a scalar or buffer in which to place the returned data + */ + public static void glGetDoublei_v(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLdouble *") DoubleBuffer data) { + GL41C.glGetDoublei_v(target, index, data); + } + + /** + * Queries the double value of an indexed state variable. + * + * @param target the indexed state to query + * @param index the index of the element being queried + */ + @NativeType("void") + public static double glGetDoublei(@NativeType("GLenum") int target, @NativeType("GLuint") int index) { + return GL41C.glGetDoublei(target, index); + } + + /** Array version of: {@link #glViewportArrayv ViewportArrayv} */ + public static void glViewportArrayv(@NativeType("GLuint") int first, @NativeType("GLfloat const *") float[] v) { + GL41C.glViewportArrayv(first, v); + } + + /** Array version of: {@link #glViewportIndexedfv ViewportIndexedfv} */ + public static void glViewportIndexedfv(@NativeType("GLuint") int index, @NativeType("GLfloat const *") float[] v) { + GL41C.glViewportIndexedfv(index, v); + } + + /** Array version of: {@link #glScissorArrayv ScissorArrayv} */ + public static void glScissorArrayv(@NativeType("GLuint") int first, @NativeType("GLint const *") int[] v) { + GL41C.glScissorArrayv(first, v); + } + + /** Array version of: {@link #glScissorIndexedv ScissorIndexedv} */ + public static void glScissorIndexedv(@NativeType("GLuint") int index, @NativeType("GLint const *") int[] v) { + GL41C.glScissorIndexedv(index, v); + } + + /** Array version of: {@link #glDepthRangeArrayv DepthRangeArrayv} */ + public static void glDepthRangeArrayv(@NativeType("GLuint") int first, @NativeType("GLdouble const *") double[] v) { + GL41C.glDepthRangeArrayv(first, v); + } + + /** Array version of: {@link #glGetFloati_v GetFloati_v} */ + public static void glGetFloati_v(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLfloat *") float[] data) { + GL41C.glGetFloati_v(target, index, data); + } + + /** Array version of: {@link #glGetDoublei_v GetDoublei_v} */ + public static void glGetDoublei_v(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLdouble *") double[] data) { + GL41C.glGetDoublei_v(target, index, data); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBWindowPos.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBWindowPos.java new file mode 100644 index 00000000..619b6457 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ARBWindowPos.java @@ -0,0 +1,347 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the ARB_window_pos extension. + * + *In order to set the current raster position to a specific window coordinate with the {@link GL11#glRasterPos2i RasterPos2i} command, the modelview matrix, projection matrix + * and viewport must be set very carefully. Furthermore, if the desired window coordinate is outside of the window's bounds one must rely on a subtle + * side-effect of the {@link GL11#glBitmap Bitmap} command in order to avoid frustum clipping.
+ * + *This extension provides a set of functions to directly set the current raster position in window coordinates, bypassing the modelview matrix, the + * projection matrix and the viewport-to-window mapping. Furthermore, clip testing is not performed, so that the current raster position is always valid.
+ * + *This greatly simplifies the process of setting the current raster position to a specific window coordinate prior to calling {@link GL11#glDrawPixels DrawPixels}, + * {@link GL11#glCopyPixels CopyPixels} or {@link GL11#glBitmap Bitmap}. Many matrix operations can be avoided when mixing 2D and 3D rendering.
+ * + *Promoted to core in {@link GL14 OpenGL 1.4}.
+ */ +public class ARBWindowPos { + + static { GL.initialize(); } + + protected ARBWindowPos() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glWindowPos2iARB, caps.glWindowPos2sARB, caps.glWindowPos2fARB, caps.glWindowPos2dARB, caps.glWindowPos2ivARB, caps.glWindowPos2svARB, + caps.glWindowPos2fvARB, caps.glWindowPos2dvARB, caps.glWindowPos3iARB, caps.glWindowPos3sARB, caps.glWindowPos3fARB, caps.glWindowPos3dARB, + caps.glWindowPos3ivARB, caps.glWindowPos3svARB, caps.glWindowPos3fvARB, caps.glWindowPos3dvARB + ); + } + + // --- [ glWindowPos2iARB ] --- + + /** + * Alternate way to set the current raster position. {@code z} is implictly set to 0. + * + * @param x the x value + * @param y the y value + */ + public static native void glWindowPos2iARB(@NativeType("GLint") int x, @NativeType("GLint") int y); + + // --- [ glWindowPos2sARB ] --- + + /** + * Short version of {@link #glWindowPos2iARB WindowPos2iARB}. + * + * @param x the x value + * @param y the y value + */ + public static native void glWindowPos2sARB(@NativeType("GLshort") short x, @NativeType("GLshort") short y); + + // --- [ glWindowPos2fARB ] --- + + /** + * Float version of {@link #glWindowPos2iARB WindowPos2iARB}. + * + * @param x the x value + * @param y the y value + */ + public static native void glWindowPos2fARB(@NativeType("GLfloat") float x, @NativeType("GLfloat") float y); + + // --- [ glWindowPos2dARB ] --- + + /** + * Double version of {@link #glWindowPos2iARB WindowPos2iARB}. + * + * @param x the x value + * @param y the y value + */ + public static native void glWindowPos2dARB(@NativeType("GLdouble") double x, @NativeType("GLdouble") double y); + + // --- [ glWindowPos2ivARB ] --- + + /** Unsafe version of: {@link #glWindowPos2ivARB WindowPos2ivARB} */ + public static native void nglWindowPos2ivARB(long p); + + /** + * Pointer version of {@link #glWindowPos2iARB WindowPos2iARB}. + * + * @param p the position value + */ + public static void glWindowPos2ivARB(@NativeType("GLint const *") IntBuffer p) { + if (CHECKS) { + check(p, 2); + } + nglWindowPos2ivARB(memAddress(p)); + } + + // --- [ glWindowPos2svARB ] --- + + /** Unsafe version of: {@link #glWindowPos2svARB WindowPos2svARB} */ + public static native void nglWindowPos2svARB(long p); + + /** + * Pointer version of {@link #glWindowPos2sARB WindowPos2sARB}. + * + * @param p the position value + */ + public static void glWindowPos2svARB(@NativeType("GLshort const *") ShortBuffer p) { + if (CHECKS) { + check(p, 2); + } + nglWindowPos2svARB(memAddress(p)); + } + + // --- [ glWindowPos2fvARB ] --- + + /** Unsafe version of: {@link #glWindowPos2fvARB WindowPos2fvARB} */ + public static native void nglWindowPos2fvARB(long p); + + /** + * Pointer version of {@link #glWindowPos2fARB WindowPos2fARB}. + * + * @param p the position value + */ + public static void glWindowPos2fvARB(@NativeType("GLfloat const *") FloatBuffer p) { + if (CHECKS) { + check(p, 2); + } + nglWindowPos2fvARB(memAddress(p)); + } + + // --- [ glWindowPos2dvARB ] --- + + /** Unsafe version of: {@link #glWindowPos2dvARB WindowPos2dvARB} */ + public static native void nglWindowPos2dvARB(long p); + + /** + * Pointer version of {@link #glWindowPos2dARB WindowPos2dARB}. + * + * @param p the position value + */ + public static void glWindowPos2dvARB(@NativeType("GLdouble const *") DoubleBuffer p) { + if (CHECKS) { + check(p, 2); + } + nglWindowPos2dvARB(memAddress(p)); + } + + // --- [ glWindowPos3iARB ] --- + + /** + * Alternate way to set the current raster position. + * + * @param x the x value + * @param y the y value + * @param z the z value + */ + public static native void glWindowPos3iARB(@NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLint") int z); + + // --- [ glWindowPos3sARB ] --- + + /** + * Short version of {@link #glWindowPos3iARB WindowPos3iARB}. + * + * @param x the x value + * @param y the y value + * @param z the z value + */ + public static native void glWindowPos3sARB(@NativeType("GLshort") short x, @NativeType("GLshort") short y, @NativeType("GLshort") short z); + + // --- [ glWindowPos3fARB ] --- + + /** + * Float version of {@link #glWindowPos3iARB WindowPos3iARB}. + * + * @param x the x value + * @param y the y value + * @param z the z value + */ + public static native void glWindowPos3fARB(@NativeType("GLfloat") float x, @NativeType("GLfloat") float y, @NativeType("GLfloat") float z); + + // --- [ glWindowPos3dARB ] --- + + /** + * Double version of {@link #glWindowPos3iARB WindowPos3iARB}. + * + * @param x the x value + * @param y the y value + * @param z the z value + */ + public static native void glWindowPos3dARB(@NativeType("GLdouble") double x, @NativeType("GLdouble") double y, @NativeType("GLdouble") double z); + + // --- [ glWindowPos3ivARB ] --- + + /** Unsafe version of: {@link #glWindowPos3ivARB WindowPos3ivARB} */ + public static native void nglWindowPos3ivARB(long p); + + /** + * Pointer version of {@link #glWindowPos3iARB WindowPos3iARB}. + * + * @param p the position value + */ + public static void glWindowPos3ivARB(@NativeType("GLint const *") IntBuffer p) { + if (CHECKS) { + check(p, 3); + } + nglWindowPos3ivARB(memAddress(p)); + } + + // --- [ glWindowPos3svARB ] --- + + /** Unsafe version of: {@link #glWindowPos3svARB WindowPos3svARB} */ + public static native void nglWindowPos3svARB(long p); + + /** + * Pointer version of {@link #glWindowPos3sARB WindowPos3sARB}. + * + * @param p the position value + */ + public static void glWindowPos3svARB(@NativeType("GLshort const *") ShortBuffer p) { + if (CHECKS) { + check(p, 3); + } + nglWindowPos3svARB(memAddress(p)); + } + + // --- [ glWindowPos3fvARB ] --- + + /** Unsafe version of: {@link #glWindowPos3fvARB WindowPos3fvARB} */ + public static native void nglWindowPos3fvARB(long p); + + /** + * Pointer version of {@link #glWindowPos3fARB WindowPos3fARB}. + * + * @param p the position value + */ + public static void glWindowPos3fvARB(@NativeType("GLfloat const *") FloatBuffer p) { + if (CHECKS) { + check(p, 3); + } + nglWindowPos3fvARB(memAddress(p)); + } + + // --- [ glWindowPos3dvARB ] --- + + /** Unsafe version of: {@link #glWindowPos3dvARB WindowPos3dvARB} */ + public static native void nglWindowPos3dvARB(long p); + + /** + * Pointer version of {@link #glWindowPos3dARB WindowPos3dARB}. + * + * @param p the position value + */ + public static void glWindowPos3dvARB(@NativeType("GLdouble const *") DoubleBuffer p) { + if (CHECKS) { + check(p, 3); + } + nglWindowPos3dvARB(memAddress(p)); + } + + /** Array version of: {@link #glWindowPos2ivARB WindowPos2ivARB} */ + public static void glWindowPos2ivARB(@NativeType("GLint const *") int[] p) { + long __functionAddress = GL.getICD().glWindowPos2ivARB; + if (CHECKS) { + check(__functionAddress); + check(p, 2); + } + callPV(p, __functionAddress); + } + + /** Array version of: {@link #glWindowPos2svARB WindowPos2svARB} */ + public static void glWindowPos2svARB(@NativeType("GLshort const *") short[] p) { + long __functionAddress = GL.getICD().glWindowPos2svARB; + if (CHECKS) { + check(__functionAddress); + check(p, 2); + } + callPV(p, __functionAddress); + } + + /** Array version of: {@link #glWindowPos2fvARB WindowPos2fvARB} */ + public static void glWindowPos2fvARB(@NativeType("GLfloat const *") float[] p) { + long __functionAddress = GL.getICD().glWindowPos2fvARB; + if (CHECKS) { + check(__functionAddress); + check(p, 2); + } + callPV(p, __functionAddress); + } + + /** Array version of: {@link #glWindowPos2dvARB WindowPos2dvARB} */ + public static void glWindowPos2dvARB(@NativeType("GLdouble const *") double[] p) { + long __functionAddress = GL.getICD().glWindowPos2dvARB; + if (CHECKS) { + check(__functionAddress); + check(p, 2); + } + callPV(p, __functionAddress); + } + + /** Array version of: {@link #glWindowPos3ivARB WindowPos3ivARB} */ + public static void glWindowPos3ivARB(@NativeType("GLint const *") int[] p) { + long __functionAddress = GL.getICD().glWindowPos3ivARB; + if (CHECKS) { + check(__functionAddress); + check(p, 3); + } + callPV(p, __functionAddress); + } + + /** Array version of: {@link #glWindowPos3svARB WindowPos3svARB} */ + public static void glWindowPos3svARB(@NativeType("GLshort const *") short[] p) { + long __functionAddress = GL.getICD().glWindowPos3svARB; + if (CHECKS) { + check(__functionAddress); + check(p, 3); + } + callPV(p, __functionAddress); + } + + /** Array version of: {@link #glWindowPos3fvARB WindowPos3fvARB} */ + public static void glWindowPos3fvARB(@NativeType("GLfloat const *") float[] p) { + long __functionAddress = GL.getICD().glWindowPos3fvARB; + if (CHECKS) { + check(__functionAddress); + check(p, 3); + } + callPV(p, __functionAddress); + } + + /** Array version of: {@link #glWindowPos3dvARB WindowPos3dvARB} */ + public static void glWindowPos3dvARB(@NativeType("GLdouble const *") double[] p) { + long __functionAddress = GL.getICD().glWindowPos3dvARB; + if (CHECKS) { + check(__functionAddress); + check(p, 3); + } + callPV(p, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ATIMeminfo.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ATIMeminfo.java new file mode 100644 index 00000000..5b67085c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ATIMeminfo.java @@ -0,0 +1,28 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the ATI_meminfo extension. + * + *Traditionally, OpenGL has treated resource management as a task of hardware virtualization hidden from applications. While providing great portability, + * this shielding of information can prevent applications from making intelligent decisions on the management of resources they create. For instance, an + * application may be better served by choosing a different rendering method if there is not sufficient resources to efficiently utilize its preferred + * method.
+ * + *Requires {@link GL11 OpenGL 1.1}
+ */ +public final class ATIMeminfo { + + /** Accepted by the {@code param} parameter of GetIntegerv. */ + public static final int + GL_VBO_FREE_MEMORY_ATI = 0x87FB, + GL_TEXTURE_FREE_MEMORY_ATI = 0x87FC, + GL_RENDERBUFFER_FREE_MEMORY_ATI = 0x87FD; + + private ATIMeminfo() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ATITextureCompression3DC.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ATITextureCompression3DC.java new file mode 100644 index 00000000..14705dd4 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/ATITextureCompression3DC.java @@ -0,0 +1,16 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** This extension is undocumented. See 3Dc for information. */ +public final class ATITextureCompression3DC { + + /** Accepted by the {@code internalformat} parameter of TexImage functions. */ + public static final int GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI = 0x8837; + + private ATITextureCompression3DC() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/CGL.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/CGL.java new file mode 100644 index 00000000..8b1e55d1 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/CGL.java @@ -0,0 +1,1650 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** Native bindings to CGL. */ +public class CGL { + + /** Attribute names for {@link #CGLChoosePixelFormat ChoosePixelFormat} and {@link #CGLDescribePixelFormat DescribePixelFormat}. */ + public static final int + kCGLPFAAllRenderers = 1, + kCGLPFATripleBuffer = 3, + kCGLPFADoubleBuffer = 5, + kCGLPFAStereo = 6, + kCGLPFAColorSize = 8, + kCGLPFAAlphaSize = 11, + kCGLPFADepthSize = 12, + kCGLPFAStencilSize = 13, + kCGLPFAMinimumPolicy = 51, + kCGLPFAMaximumPolicy = 52, + kCGLPFASampleBuffers = 55, + kCGLPFASamples = 56, + kCGLPFAColorFloat = 58, + kCGLPFAMultisample = 59, + kCGLPFASupersample = 60, + kCGLPFASampleAlpha = 61, + kCGLPFARendererID = 70, + kCGLPFASingleRenderer = 71, + kCGLPFANoRecovery = 72, + kCGLPFAAccelerated = 73, + kCGLPFAClosestPolicy = 74, + kCGLPFABackingStore = 76, + kCGLPFABackingVolatile = 77, + kCGLPFADisplayMask = 84, + kCGLPFAAllowOfflineRenderers = 96, + kCGLPFAAcceleratedCompute = 97, + kCGLPFAOpenGLProfile = 99, + kCGLPFASupportsAutomaticGraphicsSwitching = 101, + kCGLPFAVirtualScreenCount = 128, + kCGLPFAAuxBuffers = 7, + kCGLPFAAccumSize = 14, + kCGLPFAOffScreen = 53, + kCGLPFAAuxDepthStencil = 57, + kCGLPFAWindow = 80, + kCGLPFACompliant = 83, + kCGLPFAPBuffer = 90, + kCGLPFARemotePBuffer = 91, + kCGLPFARobust = 75, + kCGLPFAMPSafe = 78, + kCGLPFAMultiScreen = 81, + kCGLPFAFullScreen = 54; + + /** Property names for {@link #CGLDescribeRenderer DescribeRenderer}. */ + public static final int + kCGLRPOffScreen = 53, + kCGLRPRendererID = 70, + kCGLRPAccelerated = 73, + kCGLRPBackingStore = 76, + kCGLRPWindow = 80, + kCGLRPCompliant = 83, + kCGLRPDisplayMask = 84, + kCGLRPBufferModes = 100, + kCGLRPColorModes = 103, + kCGLRPAccumModes = 104, + kCGLRPDepthModes = 105, + kCGLRPStencilModes = 106, + kCGLRPMaxAuxBuffers = 107, + kCGLRPMaxSampleBuffers = 108, + kCGLRPMaxSamples = 109, + kCGLRPSampleModes = 110, + kCGLRPSampleAlpha = 111, + kCGLRPVideoMemory = 120, + kCGLRPTextureMemory = 121, + kCGLRPGPUVertProcCapable = 122, + kCGLRPGPUFragProcCapable = 123, + kCGLRPRendererCount = 128, + kCGLRPOnline = 129, + kCGLRPAcceleratedCompute = 130, + kCGLRPVideoMemoryMegabytes = 131, + kCGLRPTextureMemoryMegabytes = 132, + kCGLRPRobust = 75, + kCGLRPMPSafe = 78, + kCGLRPMultiScreen = 81, + kCGLRPFullScreen = 54; + + /** Enable names for {@link #CGLEnable Enable}, {@link #CGLDisable Disable}, and {@link #CGLIsEnabled IsEnabled}. */ + public static final int + kCGLCESwapRectangle = 201, + kCGLCESwapLimit = 203, + kCGLCERasterization = 221, + kCGLCEStateValidation = 301, + kCGLCESurfaceBackingSize = 305, + kCGLCEDisplayListOptimization = 307, + kCGLCEMPEngine = 313; + + /** Parameter names for {@link #CGLSetParameter SetParameter} and {@link #CGLGetParameter GetParameter}. */ + public static final int + kCGLCPSwapRectangle = 200, + kCGLCPSwapInterval = 222, + kCGLCPDispatchTableSize = 224, + kCGLCPClientStorage = 226, + kCGLCPSurfaceTexture = 228, + kCGLCPSurfaceOrder = 235, + kCGLCPSurfaceOpacity = 236, + kCGLCPSurfaceBackingSize = 304, + kCGLCPSurfaceSurfaceVolatile = 306, + kCGLCPReclaimResources = 308, + kCGLCPCurrentRendererID = 309, + kCGLCPGPUVertexProcessing = 310, + kCGLCPGPUFragmentProcessing = 311, + kCGLCPHasDrawable = 314, + kCGLCPMPSwapsInFlight = 315; + + /** Option names for {@link #CGLSetGlobalOption SetGlobalOption} and {@link #CGLGetGlobalOption GetGlobalOption}. */ + public static final int + kCGLGOFormatCacheSize = 501, + kCGLGOClearFormatCache = 502, + kCGLGORetainRenderers = 503, + kCGLGOResetLibrary = 504, + kCGLGOUseErrorHandler = 505, + kCGLGOUseBuildCache = 506; + + /** OpenGL Implementation Profiles. */ + public static final int + kCGLOGLPVersion_Legacy = 0x1000, + kCGLOGLPVersion_3_2_Core = 0x3200; + + /** CGL error return values. */ + public static final int + kCGLNoError = 0, + kCGLBadAttribute = 10000, + kCGLBadProperty = 10001, + kCGLBadPixelFormat = 10002, + kCGLBadRendererInfo = 10003, + kCGLBadContext = 10004, + kCGLBadDrawable = 10005, + kCGLBadDisplay = 10006, + kCGLBadState = 10007, + kCGLBadValue = 10008, + kCGLBadMatch = 10009, + kCGLBadEnumeration = 10010, + kCGLBadOffScreen = 10011, + kCGLBadFullScreen = 10012, + kCGLBadWindow = 10013, + kCGLBadAddress = 10014, + kCGLBadCodeModule = 10015, + kCGLBadAlloc = 10016, + kCGLBadConnection = 10017; + + /** Buffer modes. */ + public static final int + kCGLMonoscopicBit = 0x1, + kCGLStereoscopicBit = 0x2, + kCGLSingleBufferBit = 0x4, + kCGLDoubleBufferBit = 0x8, + kCGLTripleBufferBit = 0x10; + + /** Depth and stencil buffer depths. */ + public static final int + kCGL0Bit = 0x1, + kCGL1Bit = 0x2, + kCGL2Bit = 0x4, + kCGL3Bit = 0x8, + kCGL4Bit = 0x10, + kCGL5Bit = 0x20, + kCGL6Bit = 0x40, + kCGL8Bit = 0x80, + kCGL10Bit = 0x100, + kCGL12Bit = 0x200, + kCGL16Bit = 0x400, + kCGL24Bit = 0x800, + kCGL32Bit = 0x1000, + kCGL48Bit = 0x2000, + kCGL64Bit = 0x4000, + kCGL96Bit = 0x8000, + kCGL128Bit = 0x10000; + + /** Color and accumulation buffer formats. */ + public static final int + kCGLRGB444Bit = 0x40, + kCGLARGB4444Bit = 0x80, + kCGLRGB444A8Bit = 0x100, + kCGLRGB555Bit = 0x200, + kCGLARGB1555Bit = 0x400, + kCGLRGB555A8Bit = 0x800, + kCGLRGB565Bit = 0x1000, + kCGLRGB565A8Bit = 0x2000, + kCGLRGB888Bit = 0x4000, + kCGLARGB8888Bit = 0x8000, + kCGLRGB888A8Bit = 0x10000, + kCGLRGB101010Bit = 0x20000, + kCGLARGB2101010Bit = 0x40000, + kCGLRGB101010_A8Bit = 0x80000, + kCGLRGB121212Bit = 0x100000, + kCGLARGB12121212Bit = 0x200000, + kCGLRGB161616Bit = 0x400000, + kCGLRGBA16161616Bit = 0x800000, + kCGLRGBFloat64Bit = 0x1000000, + kCGLRGBAFloat64Bit = 0x2000000, + kCGLRGBFloat128Bit = 0x4000000, + kCGLRGBAFloat128Bit = 0x8000000, + kCGLRGBFloat256Bit = 0x10000000, + kCGLRGBAFloat256Bit = 0x20000000; + + /** Sampling modes. */ + public static final int + kCGLSupersampleBit = 0x1, + kCGLMultisampleBit = 0x2; + + protected CGL() { + throw new UnsupportedOperationException(); + } + + /** Contains the function pointers loaded from {@code GL.getFunctionProvider()}. */ + public static final class Functions { + + private Functions() {} + + /** Function address. */ + public static final long + GetCurrentContext = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLGetCurrentContext"), + SetCurrentContext = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLSetCurrentContext"), + GetShareGroup = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLGetShareGroup"), + ChoosePixelFormat = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLChoosePixelFormat"), + DestroyPixelFormat = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLDestroyPixelFormat"), + DescribePixelFormat = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLDescribePixelFormat"), + ReleasePixelFormat = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLReleasePixelFormat"), + RetainPixelFormat = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLRetainPixelFormat"), + GetPixelFormatRetainCount = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLGetPixelFormatRetainCount"), + QueryRendererInfo = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLQueryRendererInfo"), + DestroyRendererInfo = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLDestroyRendererInfo"), + DescribeRenderer = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLDescribeRenderer"), + CreateContext = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLCreateContext"), + DestroyContext = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLDestroyContext"), + CopyContext = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLCopyContext"), + RetainContext = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLRetainContext"), + ReleaseContext = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLReleaseContext"), + GetContextRetainCount = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLGetContextRetainCount"), + GetPixelFormat = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLGetPixelFormat"), + CreatePBuffer = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLCreatePBuffer"), + DestroyPBuffer = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLDestroyPBuffer"), + DescribePBuffer = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLDescribePBuffer"), + TexImagePBuffer = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLTexImagePBuffer"), + RetainPBuffer = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLRetainPBuffer"), + ReleasePBuffer = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLReleasePBuffer"), + GetPBufferRetainCount = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLGetPBufferRetainCount"), + SetOffScreen = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLSetOffScreen"), + GetOffScreen = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLGetOffScreen"), + SetFullScreen = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLSetFullScreen"), + SetFullScreenOnDisplay = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLSetFullScreenOnDisplay"), + SetPBuffer = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLSetPBuffer"), + GetPBuffer = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLGetPBuffer"), + ClearDrawable = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLClearDrawable"), + FlushDrawable = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLFlushDrawable"), + Enable = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLEnable"), + Disable = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLDisable"), + IsEnabled = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLIsEnabled"), + SetParameter = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLSetParameter"), + GetParameter = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLGetParameter"), + SetVirtualScreen = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLSetVirtualScreen"), + GetVirtualScreen = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLGetVirtualScreen"), + UpdateContext = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLUpdateContext"), + SetGlobalOption = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLSetGlobalOption"), + GetGlobalOption = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLGetGlobalOption"), + LockContext = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLLockContext"), + UnlockContext = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLUnlockContext"), + GetVersion = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLGetVersion"), + ErrorString = apiGetFunctionAddress(GL.getFunctionProvider(), "CGLErrorString"); + + } + + // --- [ CGLGetCurrentContext ] --- + + /** Returns the current rendering context. If there is none, returns {@code NULL}. */ + @NativeType("CGLContextObj") + public static long CGLGetCurrentContext() { + long __functionAddress = Functions.GetCurrentContext; + return callP(__functionAddress); + } + + // --- [ CGLSetCurrentContext ] --- + + /** + * Sets the specified rendering context as the current rendering context. + * + *There can be only one current rendering context. Subsequent OpenGL rendering calls operate on the current rendering context to modify the drawable + * object associated with it.
+ * + *You can use AGL macros to bypass the current rendering context mechanism and maintain your own current rendering context.
+ * + *A context is current on a per-thread basis. Multiple threads must serialize calls into the same context.
+ * + * @param context the rendering context to set as the current rendering context. Pass {@code NULL} to release the current rendering context without assigning a new one. + */ + @NativeType("CGLError") + public static int CGLSetCurrentContext(@NativeType("CGLContextObj") long context) { + long __functionAddress = Functions.SetCurrentContext; + return callPI(context, __functionAddress); + } + + // --- [ CGLGetShareGroup ] --- + + /** + * Returns the sharegroup of the specified rendering context. + * + * @param ctx a rendering context + */ + @NativeType("CGLShareGroupObj") + public static long CGLGetShareGroup(@NativeType("CGLContextObj") long ctx) { + long __functionAddress = Functions.GetShareGroup; + if (CHECKS) { + check(ctx); + } + return callPP(ctx, __functionAddress); + } + + // --- [ CGLChoosePixelFormat ] --- + + /** Unsafe version of: {@link #CGLChoosePixelFormat ChoosePixelFormat} */ + public static int nCGLChoosePixelFormat(long attribs, long pix, long npix) { + long __functionAddress = Functions.ChoosePixelFormat; + return callPPPI(attribs, pix, npix, __functionAddress); + } + + /** + * Creates a pixel format object that satisfies the constraints of the specified buffer and renderer attributes. + * + * @param attribs a 0 terminated array that contains a list of buffer and renderer attributes. Attributes can be Boolean or integer. If an attribute is integer, you + * must supply the desired value immediately following the attribute. If the attribute is Boolean, do not supply a value because its presence in the + * attributes array implies a true value. One of:| {@link #kCGLPFAAllRenderers PFAAllRenderers} | {@link #kCGLPFATripleBuffer PFATripleBuffer} | {@link #kCGLPFADoubleBuffer PFADoubleBuffer} | {@link #kCGLPFAStereo PFAStereo} | {@link #kCGLPFAColorSize PFAColorSize} |
| {@link #kCGLPFAAlphaSize PFAAlphaSize} | {@link #kCGLPFADepthSize PFADepthSize} | {@link #kCGLPFAStencilSize PFAStencilSize} | {@link #kCGLPFAMinimumPolicy PFAMinimumPolicy} | {@link #kCGLPFAMaximumPolicy PFAMaximumPolicy} |
| {@link #kCGLPFASampleBuffers PFASampleBuffers} | {@link #kCGLPFASamples PFASamples} | {@link #kCGLPFAColorFloat PFAColorFloat} | {@link #kCGLPFAMultisample PFAMultisample} | {@link #kCGLPFASupersample PFASupersample} |
| {@link #kCGLPFASampleAlpha PFASampleAlpha} | {@link #kCGLPFARendererID PFARendererID} | {@link #kCGLPFASingleRenderer PFASingleRenderer} | {@link #kCGLPFANoRecovery PFANoRecovery} | {@link #kCGLPFAAccelerated PFAAccelerated} |
| {@link #kCGLPFAClosestPolicy PFAClosestPolicy} | {@link #kCGLPFABackingStore PFABackingStore} | {@link #kCGLPFABackingVolatile PFABackingVolatile} | {@link #kCGLPFADisplayMask PFADisplayMask} | {@link #kCGLPFAAllowOfflineRenderers PFAAllowOfflineRenderers} |
| {@link #kCGLPFAAcceleratedCompute PFAAcceleratedCompute} | {@link #kCGLPFAOpenGLProfile PFAOpenGLProfile} | {@link #kCGLPFASupportsAutomaticGraphicsSwitching PFASupportsAutomaticGraphicsSwitching} | {@link #kCGLPFAVirtualScreenCount PFAVirtualScreenCount} | {@link #kCGLPFAAuxBuffers PFAAuxBuffers} |
| {@link #kCGLPFAAccumSize PFAAccumSize} | {@link #kCGLPFAOffScreen PFAOffScreen} | {@link #kCGLPFAAuxDepthStencil PFAAuxDepthStencil} | {@link #kCGLPFAWindow PFAWindow} | {@link #kCGLPFACompliant PFACompliant} |
| {@link #kCGLPFAPBuffer PFAPBuffer} | {@link #kCGLPFARemotePBuffer PFARemotePBuffer} | {@link #kCGLPFARobust PFARobust} | {@link #kCGLPFAMPSafe PFAMPSafe} | {@link #kCGLPFAMultiScreen PFAMultiScreen} |
| {@link #kCGLPFAFullScreen PFAFullScreen} |
| {@link #kCGLPFAAllRenderers PFAAllRenderers} | {@link #kCGLPFATripleBuffer PFATripleBuffer} | {@link #kCGLPFADoubleBuffer PFADoubleBuffer} | {@link #kCGLPFAStereo PFAStereo} | {@link #kCGLPFAColorSize PFAColorSize} |
| {@link #kCGLPFAAlphaSize PFAAlphaSize} | {@link #kCGLPFADepthSize PFADepthSize} | {@link #kCGLPFAStencilSize PFAStencilSize} | {@link #kCGLPFAMinimumPolicy PFAMinimumPolicy} | {@link #kCGLPFAMaximumPolicy PFAMaximumPolicy} |
| {@link #kCGLPFASampleBuffers PFASampleBuffers} | {@link #kCGLPFASamples PFASamples} | {@link #kCGLPFAColorFloat PFAColorFloat} | {@link #kCGLPFAMultisample PFAMultisample} | {@link #kCGLPFASupersample PFASupersample} |
| {@link #kCGLPFASampleAlpha PFASampleAlpha} | {@link #kCGLPFARendererID PFARendererID} | {@link #kCGLPFASingleRenderer PFASingleRenderer} | {@link #kCGLPFANoRecovery PFANoRecovery} | {@link #kCGLPFAAccelerated PFAAccelerated} |
| {@link #kCGLPFAClosestPolicy PFAClosestPolicy} | {@link #kCGLPFABackingStore PFABackingStore} | {@link #kCGLPFABackingVolatile PFABackingVolatile} | {@link #kCGLPFADisplayMask PFADisplayMask} | {@link #kCGLPFAAllowOfflineRenderers PFAAllowOfflineRenderers} |
| {@link #kCGLPFAAcceleratedCompute PFAAcceleratedCompute} | {@link #kCGLPFAOpenGLProfile PFAOpenGLProfile} | {@link #kCGLPFASupportsAutomaticGraphicsSwitching PFASupportsAutomaticGraphicsSwitching} | {@link #kCGLPFAVirtualScreenCount PFAVirtualScreenCount} | {@link #kCGLPFAAuxBuffers PFAAuxBuffers} |
| {@link #kCGLPFAAccumSize PFAAccumSize} | {@link #kCGLPFAOffScreen PFAOffScreen} | {@link #kCGLPFAAuxDepthStencil PFAAuxDepthStencil} | {@link #kCGLPFAWindow PFAWindow} | {@link #kCGLPFACompliant PFACompliant} |
| {@link #kCGLPFAPBuffer PFAPBuffer} | {@link #kCGLPFARemotePBuffer PFARemotePBuffer} | {@link #kCGLPFARobust PFARobust} | {@link #kCGLPFAMPSafe PFAMPSafe} | {@link #kCGLPFAMultiScreen PFAMultiScreen} |
| {@link #kCGLPFAFullScreen PFAFullScreen} |
The system retains the pixel format object when you call the function {@link #CGLCreateContext CreateContext}, so you can release a pixel format object immediately + * after passing it to the context creation function.
+ * + *Each call to CGLReleasePixelFormat decreases the reference count by 1. If the reference count reaches 0, the pixel format object is destroyed.
+ * + * @param pix the pixel format object whose reference count should be decremented + */ + public static void CGLReleasePixelFormat(@NativeType("CGLPixelFormatObj") long pix) { + long __functionAddress = Functions.ReleasePixelFormat; + if (CHECKS) { + check(pix); + } + callPV(pix, __functionAddress); + } + + // --- [ CGLRetainPixelFormat ] --- + + /** + * Increments the receiver's reference count. + * + *Each call to CGLRetainPixelFormat increases the reference count by 1. Each call to CGLRetainPixelFormat must be matched with a call to + * {@link #CGLReleasePixelFormat ReleasePixelFormat}.
+ * + * @param pix the pixel format object whose reference count should be incremented + */ + @NativeType("CGLPixelFormatObj") + public static long CGLRetainPixelFormat(@NativeType("CGLPixelFormatObj") long pix) { + long __functionAddress = Functions.RetainPixelFormat; + if (CHECKS) { + check(pix); + } + return callPP(pix, __functionAddress); + } + + // --- [ CGLGetPixelFormatRetainCount ] --- + + /** + * Returns the retain count of a pixel format object. + * + * @param pix a pixel format object + */ + @NativeType("GLuint") + public static int CGLGetPixelFormatRetainCount(@NativeType("CGLPixelFormatObj") long pix) { + long __functionAddress = Functions.GetPixelFormatRetainCount; + if (CHECKS) { + check(pix); + } + return callPI(pix, __functionAddress); + } + + // --- [ CGLQueryRendererInfo ] --- + + /** Unsafe version of: {@link #CGLQueryRendererInfo QueryRendererInfo} */ + public static int nCGLQueryRendererInfo(int display_mask, long rend, long nrend) { + long __functionAddress = Functions.QueryRendererInfo; + return callPPI(display_mask, rend, nrend, __functionAddress); + } + + /** + * Creates a renderer information object that contains properties and values for renderers able to drive all the specified displays in a given display + * mask. + * + * @param display_mask a bit field that contains the bitwise OR of OpenGL display masks returned by the CGDisplayIDToOpenGLDisplayMask function. If you want to obtain + * information for all renderers in the system you must call CGLQueryRendererInfo once for each display bit. + * @param rend the memory address of a renderer information object. On return, points to a renderer information object that describes all renderers that are able + * to drive the displays specified by the {@code display_mask} parameter. If {@code display_mask} does not specify any displays, the value of + * {@code rend} is set to {@code NULL}. You must call {@link #CGLDestroyRendererInfo DestroyRendererInfo} when you no longer need this object. + * @param nrend on return, points to the number of renderers described in the renderer information object. If {@code display_mask} does not specify any displays, + * the value of {@code nrend} is set to 0. + */ + @NativeType("CGLError") + public static int CGLQueryRendererInfo(@NativeType("GLuint") int display_mask, @NativeType("CGLRendererInfoObj *") PointerBuffer rend, @NativeType("GLint *") IntBuffer nrend) { + if (CHECKS) { + check(rend, 1); + check(nrend, 1); + } + return nCGLQueryRendererInfo(display_mask, memAddress(rend), memAddress(nrend)); + } + + // --- [ CGLDestroyRendererInfo ] --- + + /** + * Frees resources associated with a renderer information object. + * + * @param rend the renderer information object to destroy + */ + @NativeType("CGLError") + public static int CGLDestroyRendererInfo(@NativeType("CGLRendererInfoObj") long rend) { + long __functionAddress = Functions.DestroyRendererInfo; + if (CHECKS) { + check(rend); + } + return callPI(rend, __functionAddress); + } + + // --- [ CGLDescribeRenderer ] --- + + /** Unsafe version of: {@link #CGLDescribeRenderer DescribeRenderer} */ + public static int nCGLDescribeRenderer(long rend, int rend_num, int prop, long value) { + long __functionAddress = Functions.DescribeRenderer; + if (CHECKS) { + check(rend); + } + return callPPI(rend, rend_num, prop, value, __functionAddress); + } + + /** + * Obtains the value associated with a renderer property. + * + * @param rend an opaque renderer information object that contains a description of the renderer capabilities you want to inspect. You can obtain a renderer + * information object by calling the function {@link #CGLQueryRendererInfo QueryRendererInfo}. You must call {@link #CGLDestroyRendererInfo DestroyRendererInfo} when you no longer need this + * object. + * @param rend_num the index of the renderer inside the renderer information object — a value between 0 and the number of renderers minus one. The number of renderers + * can be obtained by calling {@link #CGLDescribeRenderer DescribeRenderer}, passing in {@code rend}, renderer number 0, and the renderer property + * {@link #kCGLRPRendererCount RPRendererCount}. + * @param prop the renderer property whose value you want to obtain. One of:| {@link #kCGLRPOffScreen RPOffScreen} | {@link #kCGLRPRendererID RPRendererID} | {@link #kCGLRPAccelerated RPAccelerated} | {@link #kCGLRPBackingStore RPBackingStore} | {@link #kCGLRPWindow RPWindow} |
| {@link #kCGLRPCompliant RPCompliant} | {@link #kCGLRPDisplayMask RPDisplayMask} | {@link #kCGLRPBufferModes RPBufferModes} | {@link #kCGLRPColorModes RPColorModes} | {@link #kCGLRPAccumModes RPAccumModes} |
| {@link #kCGLRPDepthModes RPDepthModes} | {@link #kCGLRPStencilModes RPStencilModes} | {@link #kCGLRPMaxAuxBuffers RPMaxAuxBuffers} | {@link #kCGLRPMaxSampleBuffers RPMaxSampleBuffers} | {@link #kCGLRPMaxSamples RPMaxSamples} |
| {@link #kCGLRPSampleModes RPSampleModes} | {@link #kCGLRPSampleAlpha RPSampleAlpha} | {@link #kCGLRPVideoMemory RPVideoMemory} | {@link #kCGLRPTextureMemory RPTextureMemory} | {@link #kCGLRPGPUVertProcCapable RPGPUVertProcCapable} |
| {@link #kCGLRPGPUFragProcCapable RPGPUFragProcCapable} | {@link #kCGLRPRendererCount RPRendererCount} | {@link #kCGLRPOnline RPOnline} | {@link #kCGLRPAcceleratedCompute RPAcceleratedCompute} | {@link #kCGLRPVideoMemoryMegabytes RPVideoMemoryMegabytes} |
| {@link #kCGLRPTextureMemoryMegabytes RPTextureMemoryMegabytes} | {@link #kCGLRPRobust RPRobust} | {@link #kCGLRPMPSafe RPMPSafe} | {@link #kCGLRPMultiScreen RPMultiScreen} | {@link #kCGLRPFullScreen RPFullScreen} |
Starting in Mac OS 10.5, CGL rendering contexts are reference counted. For compatibility reasons, calling CGLDestroyContext clears the drawable + * associated with the rendering context. Calling CGLDestroyContext is the equivalent of calling both {@link #CGLClearDrawable ClearDrawable} and + * {@link #CGLReleaseContext ReleaseContext}.
+ * + * @param ctx the rendering context to destroy + */ + @NativeType("CGLError") + public static int CGLDestroyContext(@NativeType("CGLContextObj") long ctx) { + long __functionAddress = Functions.DestroyContext; + if (CHECKS) { + check(ctx); + } + return callPI(ctx, __functionAddress); + } + + // --- [ CGLCopyContext ] --- + + /** + * Copies the specified state variables from one rendering context to another. + * + * @param src the source rendering context + * @param dst the destination rendering context + * @param mask a mask that specifies the state variables to copy. Pass a bit field that contains the bitwise OR of the state variable names that you want to copy. + * Use the symbolic mask constants that are passed to the OpenGL function {@link GL11#glPushAttrib PushAttrib}. To copy as many state variables + * as possible, supply the constant {@link GL11#GL_ALL_ATTRIB_BITS ALL_ATTRIB_BITS}. + */ + @NativeType("CGLError") + public static int CGLCopyContext(@NativeType("CGLContextObj") long src, @NativeType("CGLContextObj") long dst, @NativeType("GLbitfield") int mask) { + long __functionAddress = Functions.CopyContext; + if (CHECKS) { + check(src); + check(dst); + } + return callPPI(src, dst, mask, __functionAddress); + } + + // --- [ CGLRetainContext ] --- + + /** + * Increments the retain count on a CGL rendering context. + * + *Each call to CGLRetainContext increases the retain count by 1. To prevent memory leaks, each retain call must be balanced with a call to + * {@link #CGLReleaseContext ReleaseContext}.
+ * + * @param ctx the rendering context to be retained + * + * @return the same context that was passed into the function. + */ + @NativeType("CGLContextObj") + public static long CGLRetainContext(@NativeType("CGLContextObj") long ctx) { + long __functionAddress = Functions.RetainContext; + if (CHECKS) { + check(ctx); + } + return callPP(ctx, __functionAddress); + } + + // --- [ CGLReleaseContext ] --- + + /** + * Decrements the retain count on a CGL rendering context. + * + *Each call to CGLReleaseContext decreases the retain count by 1.
+ * + *When the retain count reaches 0, all resources associated with the rendering context are freed. If the rendering context that you pass is the current + * rendering context and it is freed, the current context is set to {@code NULL} and there is no current rendering context after the function executes. After the + * context is freed, you must make sure you do not use the destroyed rendering context. This includes using CGL macros in which the rendering context is + * explicitly passed to OpenGL.
+ * + * @param ctx the rendering context to be released + */ + public static void CGLReleaseContext(@NativeType("CGLContextObj") long ctx) { + long __functionAddress = Functions.ReleaseContext; + if (CHECKS) { + check(ctx); + } + callPV(ctx, __functionAddress); + } + + // --- [ CGLGetContextRetainCount ] --- + + /** + * Returns the current retain count of a CGL rendering context. + * + * @param ctx the CGL rendering context whose retain count you wish to discover + */ + @NativeType("GLuint") + public static int CGLGetContextRetainCount(@NativeType("CGLContextObj") long ctx) { + long __functionAddress = Functions.GetContextRetainCount; + if (CHECKS) { + check(ctx); + } + return callPI(ctx, __functionAddress); + } + + // --- [ CGLGetPixelFormat ] --- + + /** + * Retrieves the current pixel format associated with a CGL rendering context. + * + *The pixel format object is not retained before being returned to your application. If your application needs to maintain this object, it should call + * {@link #CGLRetainPixelFormat RetainPixelFormat}.
+ * + * @param ctx the CGL rendering context whose format you want to receive + */ + @NativeType("CGLPixelFormatObj") + public static long CGLGetPixelFormat(@NativeType("CGLContextObj") long ctx) { + long __functionAddress = Functions.GetPixelFormat; + if (CHECKS) { + check(ctx); + } + return callPP(ctx, __functionAddress); + } + + // --- [ CGLCreatePBuffer ] --- + + /** Unsafe version of: {@link #CGLCreatePBuffer CreatePBuffer} */ + public static int nCGLCreatePBuffer(int width, int height, int target, int internalFormat, int max_level, long pbuffer) { + long __functionAddress = Functions.CreatePBuffer; + return callPI(width, height, target, internalFormat, max_level, pbuffer, __functionAddress); + } + + /** + * Creates a pixel buffer of the specified size, compatible with the specified texture target. + * + *This function does not have any knowledge of OpenGL contexts or pixel format objects and does not specifically allocate the storage needed for the + * actual pixel buffer. These operations occur when you call the function {@link #CGLSetPBuffer SetPBuffer}.
+ * + *You can determine the dimensional limits of a pixel buffer by calling the OpenGL function glGetInteger. You can find the maximum size supported by + * querying GL_MAX_VIEWPORT_DIMS and the minimum size by querying GL_MIN_PBUFFER_VIEWPORT_DIMS_APPLE, which returns two integer values (similar to + * GL_MAX_VIEWPORT_DIMS). All pixel buffer dimensions that you request with the function aglCreatePBuffer should fall within these limits (inclusively) + * and should comply with any limitations imposed by the texture target you select.
+ * + *The maximum viewport size supported in OS X is quite large. You should take into consideration the amount of video or system memory required to support + * the requested pixel buffer size, including additional memory needed for multiple buffers and options such as multisampling.
+ * + *Starting in OS X v10.5, pixel buffer objects are reference counted. Pixel buffer objects are created with a reference count of 1 and are destroyed when + * the last reference to the object is released.
+ * + *Deprecated in OS X v10.7.
+ * + * @param width the width, in pixels, of the pixel buffer + * @param height the height, in pixels, of the pixel buffer + * @param target a constant that specifies the type of the pixel buffer target texture. One of:| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} |
| {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA} |
Starting in OS X v10.5, pixel buffer objects are reference counted. Calling this function is equivalent to calling {@link #CGLReleasePBuffer ReleasePBuffer}.
+ * + *Deprecated in OS X v10.7.
+ * + * @param pbuffer the pixel buffer object whose resources you want to release + */ + @NativeType("CGLError") + public static int CGLDestroyPBuffer(@NativeType("CGLPBufferObj") long pbuffer) { + long __functionAddress = Functions.DestroyPBuffer; + if (CHECKS) { + check(pbuffer); + } + return callPI(pbuffer, __functionAddress); + } + + // --- [ CGLDescribePBuffer ] --- + + /** Unsafe version of: {@link #CGLDescribePBuffer DescribePBuffer} */ + public static int nCGLDescribePBuffer(long obj, long width, long height, long target, long internalFormat, long mipmap) { + long __functionAddress = Functions.DescribePBuffer; + if (CHECKS) { + check(obj); + } + return callPPPPPPI(obj, width, height, target, internalFormat, mipmap, __functionAddress); + } + + /** + * Retrieves information that describes the specified pixel buffer object. + * + *The width, height, texture target, and internal texture color format of a pixel buffer object are set at its creation and cannot be changed without + * destroying and recreating the object. The level is set when the pixel buffer object is attached to a rendering context by calling the function + * {@link #CGLSetPBuffer SetPBuffer}.
+ * + *Deprecated in OS X v10.7.
+ * + * @param obj a pointer to the pixel buffer object + * @param width on return, points to the width, in pixels, of the pixel buffer + * @param height on return, points to the height, in pixels, of the pixel buffer + * @param target on return, points to a constant that specifies the pixel buffer texture target + * @param internalFormat on return, points to a constant that specifies the internal color format of the pixel buffer + * @param mipmap on return, points to the mipmap level of the pixel buffer or 0 if it doesn't use mipmaps + */ + @NativeType("CGLError") + public static int CGLDescribePBuffer(@NativeType("CGLPBufferObj") long obj, @NativeType("GLsizei *") IntBuffer width, @NativeType("GLsizei *") IntBuffer height, @NativeType("GLenum *") IntBuffer target, @NativeType("GLenum *") IntBuffer internalFormat, @NativeType("GLint *") IntBuffer mipmap) { + if (CHECKS) { + check(width, 1); + check(height, 1); + check(target, 1); + check(internalFormat, 1); + check(mipmap, 1); + } + return nCGLDescribePBuffer(obj, memAddress(width), memAddress(height), memAddress(target), memAddress(internalFormat), memAddress(mipmap)); + } + + // --- [ CGLTexImagePBuffer ] --- + + /** + * Binds the contents of a pixel buffer to a data source for a texture object. + * + *You must generate and bind a texture name (using standard OpenGL texturing calls) that is compatible with the pixel buffer texture target. Don't supply + * a texture object that was used previously for nonpixel buffer texturing operations unless you first call glDeleteTextures to regenerate the texture + * name.
+ * + *If you modify the content of a pixel buffer that uses mipmap levels, you must call this function again before drawing with the pixel buffer, to ensure + * that the content is synchronized with OpenGL. For pixel buffers without mipmaps, simply rebind to the texture object to synchronize content.
+ * + *No OpenGL texturing calls that modify a pixel buffer texture content are permitted (such as glTexSubImage2D or glCopyTexImage2D) with the pixel buffer + * texture as the destination. It is permitted to use texturing commands to read data from a pixel buffer texture, such as glCopyTexImage2D, with the + * pixel buffer texture as the source. It is also legal to use OpenGL functions such as glReadPixels to read the contents of a pixel buffer directly + * through the pixel buffer context.
+ * + *Note that texturing with the CGLTexImagePBuffer function can fail to produce the intended results without error in the same way other OpenGL texturing + * commands can normally fail. The function fails if you set an incompatible filter mode, do not enable the proper texture target, or other conditions + * described in the OpenGL specification.
+ * + *You don't need to share a context to use a pixel buffer object as a texture source. You can use independent pixel format objects and OpenGL contexts + * for both the pixel buffer and the target drawable object without sharing resources, and still texture using a pixel buffer in the target context.
+ * + *Deprecated in OS X v10.7.
+ * + * @param ctx a rendering context, which is the target context for the texture operation. This is the context that you plan to render content to. This is not the + * context attached to the pixel buffer. + * @param pbuffer a pixel buffer object + * @param source the source buffer to get the texture from, which should be a valid OpenGL buffer such as GL_FRONT or GL_BACK and should be compatible with the + * buffer and renderer attributes that you used to create the rendering context attached to the pixel buffer. This means that the pixel buffer must + * possess the buffer in question for the texturing operation to succeed. + */ + @NativeType("CGLError") + public static int CGLTexImagePBuffer(@NativeType("CGLContextObj") long ctx, @NativeType("CGLPBufferObj") long pbuffer, @NativeType("GLenum") int source) { + long __functionAddress = Functions.TexImagePBuffer; + if (CHECKS) { + check(ctx); + check(pbuffer); + } + return callPPI(ctx, pbuffer, source, __functionAddress); + } + + // --- [ CGLRetainPBuffer ] --- + + /** + * Increments the retain count on a pixel buffer object. + * + *Each call to CGLRetainPBuffer increases the retain count by 1. To prevent the pixel buffer object from being leaked, each retain call must be matched + * with a call to {@link #CGLReleasePBuffer ReleasePBuffer}.
+ * + *Deprecated in OS X v10.7.
+ * + * @param pbuffer the pixel buffer object whose retain count you wish to increment + */ + @NativeType("CGLPBufferObj") + public static long CGLRetainPBuffer(@NativeType("CGLPBufferObj") long pbuffer) { + long __functionAddress = Functions.RetainPBuffer; + if (CHECKS) { + check(pbuffer); + } + return callPP(pbuffer, __functionAddress); + } + + // --- [ CGLReleasePBuffer ] --- + + /** + * Releases the resources associated with a pixel buffer object. + * + *Starting in OS X v10.5, pixel buffer objects are reference counted. Calling this function is equivalent to calling CGLReleasePBuffer.
+ * + *Deprecated in OS X v10.7.
+ * + * @param pbuffer the pixel buffer object whose resources you want to release + */ + public static void CGLReleasePBuffer(@NativeType("CGLPBufferObj") long pbuffer) { + long __functionAddress = Functions.ReleasePBuffer; + if (CHECKS) { + check(pbuffer); + } + callPV(pbuffer, __functionAddress); + } + + // --- [ CGLGetPBufferRetainCount ] --- + + /** + * Returns the retain count of a pixel buffer object. + * + *Deprecated in OS X v10.7.
+ * + * @param pbuffer the pixel buffer object whose retain count you wish to retrieve + */ + @NativeType("GLuint") + public static int CGLGetPBufferRetainCount(@NativeType("CGLPBufferObj") long pbuffer) { + long __functionAddress = Functions.GetPBufferRetainCount; + if (CHECKS) { + check(pbuffer); + } + return callPI(pbuffer, __functionAddress); + } + + // --- [ CGLSetOffScreen ] --- + + /** Unsafe version of: {@link #CGLSetOffScreen SetOffScreen} */ + public static int nCGLSetOffScreen(long ctx, int width, int height, int rowbytes, long baseaddr) { + long __functionAddress = Functions.SetOffScreen; + if (CHECKS) { + check(ctx); + } + return callPPI(ctx, width, height, rowbytes, baseaddr, __functionAddress); + } + + /** + * Attaches a rendering context to an offscreen buffer. + * + *Before calling this function, you must set up the rendering context using a pixel format object created with the kCGLPFAOffScreen attribute. For more + * information about kCGLPFAOffScreen, see Buffer and Renderer Attributes.
+ * + *After calling this function, subsequent OpenGL drawing is rendered into the offscreen buffer and the viewport of the rendering context is set to the + * full size of the offscreen area.
+ * + *To exit offscreen mode, call {@link #CGLClearDrawable ClearDrawable}.
+ * + *To obtain functionality similar to offscreen mode on renderers that do not support it, attach the context to a hidden window and use the OpenGL + * function glReadPixels.
+ * + *Deprecated in OS X v10.7.
+ * + * @param ctx a rendering context + * @param width the width, in pixels, of the offscreen buffer + * @param height the height, in pixels, of the offscreen buffer + * @param rowbytes the number of bytes per row of the offscreen buffer, which must be greater than or equal to width times bytes per pixel + * @param baseaddr a pointer to a block of memory to use as the offscreen buffer. The size of the memory must be at least {@code rowbytes*height} bytes. + */ + @NativeType("CGLError") + public static int CGLSetOffScreen(@NativeType("CGLContextObj") long ctx, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLint") int rowbytes, @NativeType("void *") ByteBuffer baseaddr) { + if (CHECKS) { + check(baseaddr, rowbytes * height); + } + return nCGLSetOffScreen(ctx, width, height, rowbytes, memAddress(baseaddr)); + } + + // --- [ CGLGetOffScreen ] --- + + /** Unsafe version of: {@link #CGLGetOffScreen GetOffScreen} */ + public static int nCGLGetOffScreen(long ctx, long width, long height, long rowbytes, long baseaddr) { + long __functionAddress = Functions.GetOffScreen; + if (CHECKS) { + check(ctx); + } + return callPPPPPI(ctx, width, height, rowbytes, baseaddr, __functionAddress); + } + + /** + * Retrieves an offscreen buffer and its parameters for a specified rendering context. + * + *Deprecated in OS X v10.7.
+ * + * @param ctx a rendering context + * @param width on return, points to the width, in pixels, of the offscreen buffer. If the rendering context is not attached to an offscreen drawable object, the + * value of width is set to 0. + * @param height on return, points to the height, in pixels, of the offscreen buffer. If the rendering context is not attached to an offscreen drawable object, the + * value of height is set to 0. + * @param rowbytes on return, points to the number of bytes per row of the offscreen buffer. If the context is not attached to an offscreen drawable object, the value + * of rowbytes is set to 0. + * @param baseaddr on return, points to the base address of the offscreen buffer. If the context is not attached to an offscreen drawable object, the value of + * {@code baseaddr} is set to {@code NULL}. + */ + @NativeType("CGLError") + public static int CGLGetOffScreen(@NativeType("CGLContextObj") long ctx, @NativeType("GLsizei *") IntBuffer width, @NativeType("GLsizei *") IntBuffer height, @NativeType("GLint *") IntBuffer rowbytes, @NativeType("void **") PointerBuffer baseaddr) { + if (CHECKS) { + check(width, 1); + check(height, 1); + check(rowbytes, 1); + check(baseaddr, 1); + } + return nCGLGetOffScreen(ctx, memAddress(width), memAddress(height), memAddress(rowbytes), memAddress(baseaddr)); + } + + // --- [ CGLSetFullScreen ] --- + + /** + * Attaches a rendering context to its full-screen drawable object. + * + *Before calling this function, you must set up the rendering context using a pixel format object created with the kCGLPFAFullScreen attribute (see + * Buffer and Renderer Attributes). Some OpenGL renderers, such as the software renderer, do not support full-screen mode. After you call the function + * {@link #CGLChoosePixelFormat ChoosePixelFormat} with the full-screen attribute, you need to check whether the pixel format object is created successfully.
+ * + *You must capture the display prior to entering full-screen mode and release it after exiting. After calling this function, subsequent OpenGL drawing is + * rendered into the entire screen. For more information, see OpenGL Programming Guide for Mac.
+ * + *To exit full-screen mode, call {@link #CGLClearDrawable ClearDrawable}.
+ * + *Deprecated in OS X v10.7. Use {@link #CGLSetFullScreenOnDisplay SetFullScreenOnDisplay} instead.
+ * + * @param ctx a rendering context + */ + @NativeType("CGLError") + public static int CGLSetFullScreen(@NativeType("CGLContextObj") long ctx) { + long __functionAddress = Functions.SetFullScreen; + if (CHECKS) { + check(ctx); + } + return callPI(ctx, __functionAddress); + } + + // --- [ CGLSetFullScreenOnDisplay ] --- + + /** + * Attaches a rendering context to a full-screen drawable object." + + * + *This function obtains a drawable object that covers an entire screen and attaches it to the rendering context. A full-screen rendering context may + * allow the underlying renderer to provide better performance compared to a context associated with a window that partially covers the screen.
+ * + *Prior to calling this function, your application should ensure that the context is capable of rendering to this display by querying the appropriate + * renderer properties. For more information, see {@link #CGLQueryRendererInfo QueryRendererInfo}. Note that some renderers, including the software renderer, do not support + * full-screen mode.
+ * + *You must capture the screen prior to entering full-screen mode and release it after exiting. After calling this function, subsequent OpenGL drawing is + * rendered into the entire screen. For more information, see OpenGL Programming Guide for Mac.
+ * + *To exit full-screen mode, call {@link #CGLClearDrawable ClearDrawable}.
+ * + *In OS X v10.6 or later, this function is not deprecated, but is usually not necessary. If your application creates a window that completely covers the + * screen, the system implicitly creates a full-screen instance, for the same potential performance benefit.
+ * + *Deprecated in OS X v10.7.
+ * + * @param ctx a rendering context + * @param display_mask a bit field that contains the OpenGL display mask for the screen you wish the context to cover + */ + @NativeType("CGLError") + public static int CGLSetFullScreenOnDisplay(@NativeType("CGLContextObj") long ctx, @NativeType("GLuint") int display_mask) { + long __functionAddress = Functions.SetFullScreenOnDisplay; + if (CHECKS) { + check(ctx); + } + return callPI(ctx, display_mask, __functionAddress); + } + + // --- [ CGLSetPBuffer ] --- + + /** + * Attaches a pixel buffer object to a rendering context. + * + *The first time you call this function for a specific pixel buffer object, the system creates the necessary buffers. The buffers are created to support + * the attributes dictated by the pixel format object used to create the rendering context and by the parameters used to create the pixel buffer object. + * The storage requirements for pixel buffer objects, which can be quite large, are very similar to the requirements for windows or views with OpenGL + * contexts attached. All drawable objects compete for the same scarce resources. This function can fail is there is not enough contiguous VRAM for each + * buffer. It's best to code defensively with a scheme that reduces resource consumption without causing the application to resort to failure. Unless, of + * course, failure is the only viable alternative.
+ * + *The ability to attach a pixel buffer to a context is supported only on renderers that export GL_APPLE_pixel_buffer in the GL_EXTENSIONS string. Before + * calling this function, you should programmatically determine if it’s possible to attach a pixel buffer to a context by querying GL_EXTENSIONS in the + * context and looking for GL_APPLE_pixel_buffer. If that extension is not present, the renderer won’t allow setting the pixel buffer.
+ * + *In order of performance, these are the renderers you should consider using when setting up a rendering context to attach to a pixel buffer:
+ * + *Deprecated in OS X v10.7.
+ * + * @param ctx the rendering context to attach the pixel buffer to + * @param pbuffer a pixel buffer object + * @param face the cube map face to draw if the pixel buffer texture target type is {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP}; otherwise pass 0. + * @param level the mipmap level to draw. This must not exceed the maximum mipmap level set when the pixel buffer object was created. Pass 0 for a texture target + * that does not support mipmaps. + * @param screen a virtual screen value. The virtual screen determines the renderer OpenGL uses to draw to the pixel buffer object. For best performance, for a + * pixel buffer used as a texture source, you should supply the virtual screen value that results in using the same renderer used by the context + * that's the texturing target. + */ + @NativeType("CGLError") + public static int CGLSetPBuffer(@NativeType("CGLContextObj") long ctx, @NativeType("CGLPBufferObj") long pbuffer, @NativeType("GLenum") int face, @NativeType("GLint") int level, @NativeType("GLint") int screen) { + long __functionAddress = Functions.SetPBuffer; + if (CHECKS) { + check(ctx); + check(pbuffer); + } + return callPPI(ctx, pbuffer, face, level, screen, __functionAddress); + } + + // --- [ CGLGetPBuffer ] --- + + /** Unsafe version of: {@link #CGLGetPBuffer GetPBuffer} */ + public static int nCGLGetPBuffer(long ctx, long pbuffer, long face, long level, long screen) { + long __functionAddress = Functions.GetPBuffer; + if (CHECKS) { + check(ctx); + } + return callPPPPPI(ctx, pbuffer, face, level, screen, __functionAddress); + } + + /** + * Retrieves a pixel buffer and its parameters for a specified rendering context. + * + *Deprecated in OS X v10.7.
+ * + * @param ctx a rendering context + * @param pbuffer on return, points to the pixel buffer object attached to the rendering context + * @param face on return, points to the cube map face that is set if the pixel buffer texture target type is {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP}; otherwise 0 for all other + * texture target types. + * @param level on return, points to the current mipmap level for drawing + * @param screen on return, points to the current virtual screen number, as set by the last valid call to {@link #CGLSetPBuffer SetPBuffer} + */ + @NativeType("CGLError") + public static int CGLGetPBuffer(@NativeType("CGLContextObj") long ctx, @NativeType("CGLPBufferObj *") PointerBuffer pbuffer, @NativeType("GLenum *") IntBuffer face, @NativeType("GLint *") IntBuffer level, @NativeType("GLint *") IntBuffer screen) { + if (CHECKS) { + check(pbuffer, 1); + check(face, 1); + check(level, 1); + check(screen, 1); + } + return nCGLGetPBuffer(ctx, memAddress(pbuffer), memAddress(face), memAddress(level), memAddress(screen)); + } + + // --- [ CGLClearDrawable ] --- + + /** + * Disassociates a rendering context from any drawable objects attached to it. + * + * @param ctx a rendering context + */ + @NativeType("CGLError") + public static int CGLClearDrawable(@NativeType("CGLContextObj") long ctx) { + long __functionAddress = Functions.ClearDrawable; + if (CHECKS) { + check(ctx); + } + return callPI(ctx, __functionAddress); + } + + // --- [ CGLFlushDrawable ] --- + + /** + * Copies the back buffer of a double-buffered context to the front buffer. + * + *To create a double-buffered context, specify the {@link #kCGLPFADoubleBuffer PFADoubleBuffer} attribute when you create the pixel format object for the rendering + * context. If the backing store attribute is set to false, the buffers can be exchanged rather than copied. This is often the case in full-screen mode. If + * the receiver is not a double-buffered context, this call does nothing.
+ * + *If you set the swap interval attribute ({@link #kCGLCPSwapInterval CPSwapInterval}) appropriately, the copy takes place during the vertical retrace of the display, + * rather than immediately after CGLFlushDrawable is called. An implicit {@link GL11C#glFlush Flush} operation is performed by CGLFlushDrawable + * before it returns. For optimal performance, an application should not call glFlush immediately before calling CGLFlushDrawable. Subsequent OpenGL + * commands can be issued immediately after calling CGLFlushDrawable, but are not executed until the buffer copy is completed.
+ * + * @param ctx the context object + */ + @NativeType("CGLError") + public static int CGLFlushDrawable(@NativeType("CGLContextObj") long ctx) { + long __functionAddress = Functions.FlushDrawable; + if (CHECKS) { + check(ctx); + } + return callPI(ctx, __functionAddress); + } + + // --- [ CGLEnable ] --- + + /** + * Enables an option for a rendering context. + * + * @param ctx a rendering context + * @param pname the option to enable. One of:| {@link #kCGLCESwapRectangle CESwapRectangle} | {@link #kCGLCESwapLimit CESwapLimit} | {@link #kCGLCERasterization CERasterization} | {@link #kCGLCEStateValidation CEStateValidation} | {@link #kCGLCESurfaceBackingSize CESurfaceBackingSize} |
| {@link #kCGLCEDisplayListOptimization CEDisplayListOptimization} | {@link #kCGLCEMPEngine CEMPEngine} |
| {@link #kCGLCESwapRectangle CESwapRectangle} | {@link #kCGLCESwapLimit CESwapLimit} | {@link #kCGLCERasterization CERasterization} | {@link #kCGLCEStateValidation CEStateValidation} | {@link #kCGLCESurfaceBackingSize CESurfaceBackingSize} |
| {@link #kCGLCEDisplayListOptimization CEDisplayListOptimization} | {@link #kCGLCEMPEngine CEMPEngine} |
| {@link #kCGLCESwapRectangle CESwapRectangle} | {@link #kCGLCESwapLimit CESwapLimit} | {@link #kCGLCERasterization CERasterization} | {@link #kCGLCEStateValidation CEStateValidation} | {@link #kCGLCESurfaceBackingSize CESurfaceBackingSize} |
| {@link #kCGLCEDisplayListOptimization CEDisplayListOptimization} | {@link #kCGLCEMPEngine CEMPEngine} |
| {@link #kCGLCPSwapRectangle CPSwapRectangle} | {@link #kCGLCPSwapInterval CPSwapInterval} | {@link #kCGLCPDispatchTableSize CPDispatchTableSize} | {@link #kCGLCPClientStorage CPClientStorage} |
| {@link #kCGLCPSurfaceTexture CPSurfaceTexture} | {@link #kCGLCPSurfaceOrder CPSurfaceOrder} | {@link #kCGLCPSurfaceOpacity CPSurfaceOpacity} | {@link #kCGLCPSurfaceBackingSize CPSurfaceBackingSize} |
| {@link #kCGLCPSurfaceSurfaceVolatile CPSurfaceSurfaceVolatile} | {@link #kCGLCPReclaimResources CPReclaimResources} | {@link #kCGLCPCurrentRendererID CPCurrentRendererID} | {@link #kCGLCPGPUVertexProcessing CPGPUVertexProcessing} |
| {@link #kCGLCPGPUFragmentProcessing CPGPUFragmentProcessing} | {@link #kCGLCPHasDrawable CPHasDrawable} | {@link #kCGLCPMPSwapsInFlight CPMPSwapsInFlight} |
| {@link #kCGLCPSwapRectangle CPSwapRectangle} | {@link #kCGLCPSwapInterval CPSwapInterval} | {@link #kCGLCPDispatchTableSize CPDispatchTableSize} | {@link #kCGLCPClientStorage CPClientStorage} |
| {@link #kCGLCPSurfaceTexture CPSurfaceTexture} | {@link #kCGLCPSurfaceOrder CPSurfaceOrder} | {@link #kCGLCPSurfaceOpacity CPSurfaceOpacity} | {@link #kCGLCPSurfaceBackingSize CPSurfaceBackingSize} |
| {@link #kCGLCPSurfaceSurfaceVolatile CPSurfaceSurfaceVolatile} | {@link #kCGLCPReclaimResources CPReclaimResources} | {@link #kCGLCPCurrentRendererID CPCurrentRendererID} | {@link #kCGLCPGPUVertexProcessing CPGPUVertexProcessing} |
| {@link #kCGLCPGPUFragmentProcessing CPGPUFragmentProcessing} | {@link #kCGLCPHasDrawable CPHasDrawable} | {@link #kCGLCPMPSwapsInFlight CPMPSwapsInFlight} |
| {@link #kCGLCPSwapRectangle CPSwapRectangle} | {@link #kCGLCPSwapInterval CPSwapInterval} | {@link #kCGLCPDispatchTableSize CPDispatchTableSize} | {@link #kCGLCPClientStorage CPClientStorage} |
| {@link #kCGLCPSurfaceTexture CPSurfaceTexture} | {@link #kCGLCPSurfaceOrder CPSurfaceOrder} | {@link #kCGLCPSurfaceOpacity CPSurfaceOpacity} | {@link #kCGLCPSurfaceBackingSize CPSurfaceBackingSize} |
| {@link #kCGLCPSurfaceSurfaceVolatile CPSurfaceSurfaceVolatile} | {@link #kCGLCPReclaimResources CPReclaimResources} | {@link #kCGLCPCurrentRendererID CPCurrentRendererID} | {@link #kCGLCPGPUVertexProcessing CPGPUVertexProcessing} |
| {@link #kCGLCPGPUFragmentProcessing CPGPUFragmentProcessing} | {@link #kCGLCPHasDrawable CPHasDrawable} | {@link #kCGLCPMPSwapsInFlight CPMPSwapsInFlight} |
Setting the virtual screen forces the renderer associated with the virtual screen to process OpenGL commands issued to the specified context. Changing + * the virtual screen changes the current renderer. You should use this function only when it is necessary to override the default behavior. The current + * virtual screen is normally set automatically. Because the current virtual screen determines which OpenGL renderer is processing commands, the return + * values of all glGetXXX functions can be affected by the current virtual screen.
+ * + * @param ctx a rendering context + * @param screen a virtual screen number, which must be a value between 0 and the number of virtual screens minus one. The number of virtual screens available in a + * context can be obtained by calling the function {@link #CGLDescribePixelFormat DescribePixelFormat}, passing in the pixel format object used to create the rendering + * context, 0 for the virtual screen number ({@code pix_num} parameter), and the attribute constant {@link #kCGLPFAVirtualScreenCount PFAVirtualScreenCount}. + */ + @NativeType("CGLError") + public static int CGLSetVirtualScreen(@NativeType("CGLContextObj") long ctx, @NativeType("GLint") int screen) { + long __functionAddress = Functions.SetVirtualScreen; + if (CHECKS) { + check(ctx); + } + return callPI(ctx, screen, __functionAddress); + } + + // --- [ CGLGetVirtualScreen ] --- + + /** Unsafe version of: {@link #CGLGetVirtualScreen GetVirtualScreen} */ + public static int nCGLGetVirtualScreen(long ctx, long screen) { + long __functionAddress = Functions.GetVirtualScreen; + if (CHECKS) { + check(ctx); + } + return callPPI(ctx, screen, __functionAddress); + } + + /** + * Gets the current virtual screen number associated with a rendering context. + * + *The current virtual screen can change when a drawable object is moved or resized across graphics device boundaries. A change in the current virtual + * screen can affect the return values of some OpenGL functions and in most cases also means that the renderer has changed.
+ * + * @param ctx a rendering context + * @param screen on return, points to the virtual screen associated with the context. The value is always 0 on a single-display system and –1 if the function fails + * for any reason. + */ + @NativeType("CGLError") + public static int CGLGetVirtualScreen(@NativeType("CGLContextObj") long ctx, @NativeType("GLint *") IntBuffer screen) { + if (CHECKS) { + check(screen, 1); + } + return nCGLGetVirtualScreen(ctx, memAddress(screen)); + } + + // --- [ CGLUpdateContext ] --- + + /** + * Synchronizes new renderer state to that of the application context + * + * @param ctx a rendering context + */ + @NativeType("CGLError") + public static int CGLUpdateContext(@NativeType("CGLContextObj") long ctx) { + long __functionAddress = Functions.UpdateContext; + if (CHECKS) { + check(ctx); + } + return callPI(ctx, __functionAddress); + } + + // --- [ CGLSetGlobalOption ] --- + + /** Unsafe version of: {@link #CGLSetGlobalOption SetGlobalOption} */ + public static int nCGLSetGlobalOption(int pname, long params) { + long __functionAddress = Functions.SetGlobalOption; + return callPI(pname, params, __functionAddress); + } + + /** + * Sets the value of a global option. + * + * @param pname the name of the option whose value you want to set. One of:| {@link #kCGLGOFormatCacheSize GOFormatCacheSize} | {@link #kCGLGOClearFormatCache GOClearFormatCache} | {@link #kCGLGORetainRenderers GORetainRenderers} | {@link #kCGLGOResetLibrary GOResetLibrary} | {@link #kCGLGOUseErrorHandler GOUseErrorHandler} |
| {@link #kCGLGOUseBuildCache GOUseBuildCache} |
| {@link #kCGLGOFormatCacheSize GOFormatCacheSize} | {@link #kCGLGOClearFormatCache GOClearFormatCache} | {@link #kCGLGORetainRenderers GORetainRenderers} | {@link #kCGLGOResetLibrary GOResetLibrary} | {@link #kCGLGOUseErrorHandler GOUseErrorHandler} |
| {@link #kCGLGOUseBuildCache GOUseBuildCache} |
| {@link #kCGLGOFormatCacheSize GOFormatCacheSize} | {@link #kCGLGOClearFormatCache GOClearFormatCache} | {@link #kCGLGORetainRenderers GORetainRenderers} | {@link #kCGLGOResetLibrary GOResetLibrary} | {@link #kCGLGOUseErrorHandler GOUseErrorHandler} |
| {@link #kCGLGOUseBuildCache GOUseBuildCache} |
The function CGLLockContext blocks the thread it is on until all other threads have unlocked the same context using the function + * {@link #CGLUnlockContext UnlockContext}. You can use CGLLockContext recursively. Context-specific CGL calls by themselves do not require locking, but you can + * guarantee serial processing for a group of calls by surrounding them with CGLLockContext and CGLUnlockContext. Keep in mind that calls from the OpenGL + * API (the API provided by the Architecture Review Board) require locking.
+ * + *Applications that use NSOpenGL classes with multithreading can lock contexts using the functions CGLLockContext and CGLUnlockContext. To perform + * rendering in a thread other than the main one, you can lock the context that you want to access and safely execute OpenGL commands. The locking calls + * must be placed around all OpenGL calls in all threads.
+ * + * @param context a rendering context + */ + @NativeType("CGLError") + public static int CGLLockContext(@NativeType("CGLContextObj") long context) { + long __functionAddress = Functions.LockContext; + if (CHECKS) { + check(context); + } + return callPI(context, __functionAddress); + } + + // --- [ CGLUnlockContext ] --- + + /** + * Unlocks a CGL rendering context. + * + * @param context the CGL context to unlock + */ + @NativeType("CGLError") + public static int CGLUnlockContext(@NativeType("CGLContextObj") long context) { + long __functionAddress = Functions.UnlockContext; + if (CHECKS) { + check(context); + } + return callPI(context, __functionAddress); + } + + // --- [ CGLGetVersion ] --- + + /** Unsafe version of: {@link #CGLGetVersion GetVersion} */ + public static void nCGLGetVersion(long majorvers, long minorvers) { + long __functionAddress = Functions.GetVersion; + callPPV(majorvers, minorvers, __functionAddress); + } + + /** + * Gets the major and minor version numbers of the CGL library. + * + * @param majorvers on return, points to the major version number of the CGL library + * @param minorvers on return, points to the minor version number of the CGL library + */ + public static void CGLGetVersion(@NativeType("GLint *") IntBuffer majorvers, @NativeType("GLint *") IntBuffer minorvers) { + if (CHECKS) { + check(majorvers, 1); + check(minorvers, 1); + } + nCGLGetVersion(memAddress(majorvers), memAddress(minorvers)); + } + + // --- [ CGLErrorString ] --- + + /** Unsafe version of: {@link #CGLErrorString ErrorString} */ + public static long nCGLErrorString(int error) { + long __functionAddress = Functions.ErrorString; + return callP(error, __functionAddress); + } + + /** + * Returns a string that describes the specified result code. + * + * @param error the CGL result code constant returned from a CGL function. One of:| {@link #kCGLNoError NoError} | {@link #kCGLBadAttribute BadAttribute} | {@link #kCGLBadProperty BadProperty} | {@link #kCGLBadPixelFormat BadPixelFormat} | {@link #kCGLBadRendererInfo BadRendererInfo} | {@link #kCGLBadContext BadContext} | {@link #kCGLBadDrawable BadDrawable} |
| {@link #kCGLBadDisplay BadDisplay} | {@link #kCGLBadState BadState} | {@link #kCGLBadValue BadValue} | {@link #kCGLBadMatch BadMatch} | {@link #kCGLBadEnumeration BadEnumeration} | {@link #kCGLBadOffScreen BadOffScreen} | {@link #kCGLBadFullScreen BadFullScreen} |
| {@link #kCGLBadWindow BadWindow} | {@link #kCGLBadAddress BadAddress} | {@link #kCGLBadCodeModule BadCodeModule} | {@link #kCGLBadAlloc BadAlloc} | {@link #kCGLBadConnection BadConnection} |
This extension provides support for converting 422 pixels in host memory to 444 pixels as part of the pixel storage operation.
+ * + *The pixel unpack storage operation treats a 422 pixel as a 2 element format where the first element is C (chrominance) and the second element is L + * (luminance). Luminance is present on all pixels; a full chrominance value requires two pixels.
+ * + *The pixel pack storage operation converts RGB to a 422 pixel defined as a 2 element format where the first element stored is C (chrominance) and the + * second element stored is L (luminance). Luminance is present on all pixels; a full chrominance value requires two pixels.
+ * + *Both averaging and non-averaging is supported for green and blue assignments for pack and unpack operations.
+ */ +public final class EXT422Pixels { + + /** + * Accepted by the {@code format} parameter of DrawPixels, ReadPixels, TexImage1D, TexImage2D, GetTexImage, TexImage3D, TexSubImage1D, TexSubImage2D, + * TexSubImage3D, GetHistogram, GetMinmax, ConvolutionFilter1D, ConvolutionFilter2D, ConvolutionFilter3D, GetConvolutionFilter, SeparableFilter2D, + * SeparableFilter3D, GetSeparableFilter, ColorTable, and GetColorTable. + */ + public static final int + GL_422_EXT = 0x80CC, + GL_422_REV_EXT = 0x80CD, + GL_422_AVERAGE_EXT = 0x80CE, + GL_422_REV_AVERAGE_EXT = 0x80CF; + + private EXT422Pixels() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTABGR.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTABGR.java new file mode 100644 index 00000000..1e7374da --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTABGR.java @@ -0,0 +1,21 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_abgr extension. + * + *EXT_abgr extends the list of host-memory color formats. Specifically, it provides a reverse-order alternative to image format RGBA. The ABGR component + * order matches the cpack Iris GL format on big-endian machines.
+ */ +public final class EXTABGR { + + /** Accepted by the {@code format} parameter of DrawPixels, GetTexImage, ReadPixels, TexImage1D, and TexImage2D. */ + public static final int GL_ABGR_EXT = 0x8000; + + private EXTABGR() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBGRA.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBGRA.java new file mode 100644 index 00000000..ae858cb4 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBGRA.java @@ -0,0 +1,25 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_bgra extension. + * + *EXT_bgra extends the list of host-memory color formats. Specifically, it provides formats which match the memory layout of Windows DIBs so that + * applications can use the same data in both Windows API calls and OpenGL pixel API calls.
+ * + *Promoted to core in {@link GL12 OpenGL 1.2}.
+ */ +public final class EXTBGRA { + + /** Accepted by the {@code format} parameter of DrawPixels, GetTexImage, ReadPixels, TexImage1D, and TexImage2D. */ + public static final int + GL_BGR_EXT = 0x80E0, + GL_BGRA_EXT = 0x80E1; + + private EXTBGRA() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBindableUniform.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBindableUniform.java new file mode 100644 index 00000000..34563891 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBindableUniform.java @@ -0,0 +1,65 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_bindable_uniform extension. + * + *This extension introduces the concept of bindable uniforms to the OpenGL Shading Language. A uniform variable can be declared bindable, which means that + * the storage for the uniform is not allocated by the compiler/linker anymore, but is backed by a buffer object. This buffer object is bound to the + * bindable uniform through the new command UniformBufferEXT(). Binding needs to happen after linking a program object.
+ * + *Binding different buffer objects to a bindable uniform allows an application to easily use different "uniform data sets", without having to re-specify + * the data every time.
+ * + *A buffer object can be bound to bindable uniforms in different program objects. If those bindable uniforms are all of the same type, accessing a + * bindable uniform in program object A will result in the same data if the same access is made in program object B. This provides a mechanism for + * 'environment uniforms', uniform values that can be shared among multiple program objects.
+ */ +public class EXTBindableUniform { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = 0x8DE2, + GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = 0x8DE3, + GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = 0x8DE4, + GL_MAX_BINDABLE_UNIFORM_SIZE_EXT = 0x8DED, + GL_UNIFORM_BUFFER_BINDING_EXT = 0x8DEF; + + /** Accepted by the {@code target} parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, and GetBufferPointerv. */ + public static final int GL_UNIFORM_BUFFER_EXT = 0x8DEE; + + static { GL.initialize(); } + + protected EXTBindableUniform() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glUniformBufferEXT, caps.glGetUniformBufferSizeEXT, caps.glGetUniformOffsetEXT + ); + } + + // --- [ glUniformBufferEXT ] --- + + public static native void glUniformBufferEXT(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint") int buffer); + + // --- [ glGetUniformBufferSizeEXT ] --- + + @NativeType("GLint") + public static native int glGetUniformBufferSizeEXT(@NativeType("GLuint") int program, @NativeType("GLint") int location); + + // --- [ glGetUniformOffsetEXT ] --- + + @NativeType("GLintptr") + public static native long glGetUniformOffsetEXT(@NativeType("GLuint") int program, @NativeType("GLint") int location); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendColor.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendColor.java new file mode 100644 index 00000000..11dccf67 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendColor.java @@ -0,0 +1,48 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_blend_color extension. + * + *Blending capability is extended by defining a constant color that can be included in blending equations. A typical usage is blending two RGB images. + * Without the constant blend factor, one image must have an alpha channel with each pixel set to the desired blend factor.
+ * + *Promoted to core in {@link GL14 OpenGL 1.4}.
+ */ +public class EXTBlendColor { + + /** Accepted by the {@code sfactor} and {@code dfactor} parameters of BlendFunc. */ + public static final int + GL_CONSTANT_COLOR_EXT = 0x8001, + GL_ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002, + GL_CONSTANT_ALPHA_EXT = 0x8003, + GL_ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_BLEND_COLOR_EXT = 0x8005; + + static { GL.initialize(); } + + protected EXTBlendColor() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBlendColorEXT + ); + } + + // --- [ glBlendColorEXT ] --- + + public static native void glBlendColorEXT(@NativeType("GLfloat") float red, @NativeType("GLfloat") float green, @NativeType("GLfloat") float blue, @NativeType("GLfloat") float alpha); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendEquationSeparate.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendEquationSeparate.java new file mode 100644 index 00000000..447883d5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendEquationSeparate.java @@ -0,0 +1,49 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_blend_equation_separate extension. + * + *{@link EXTBlendFuncSeparate EXT_blend_func_separate} introduced separate RGB and alpha blend factors. {@link EXTBlendMinmax EXT_blend_minmax} introduced a distinct blend equation for + * combining source and destination blend terms. ({@link EXTBlendSubtract EXT_blend_subtract} & EXT_blend_logic_op added other blend equation + * modes.) OpenGL 1.4 integrated both functionalities into the core standard.
+ * + *While there are separate blend functions for the RGB and alpha blend factors, OpenGL 1.4 provides a single blend equation that applies to both RGB and + * alpha portions of blending.
+ * + *This extension provides a separate blend equation for RGB and alpha to match the generality available for blend factors.
+ * + *Requires {@link GL14 OpenGL 1.4} or {@link ARBImaging ARB_imaging} or {@link EXTBlendMinmax EXT_blend_minmax} and/or {@link EXTBlendSubtract EXT_blend_subtract}. Promoted to core in {@link GL20 OpenGL 2.0}.
+ */ +public class EXTBlendEquationSeparate { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_BLEND_EQUATION_RGB_EXT = 0x8009, + GL_BLEND_EQUATION_ALPHA_EXT = 0x883D; + + static { GL.initialize(); } + + protected EXTBlendEquationSeparate() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBlendEquationSeparateEXT + ); + } + + // --- [ glBlendEquationSeparateEXT ] --- + + public static native void glBlendEquationSeparateEXT(@NativeType("GLenum") int modeRGB, @NativeType("GLenum") int modeAlpha); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendFuncSeparate.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendFuncSeparate.java new file mode 100644 index 00000000..7fc9d9ae --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendFuncSeparate.java @@ -0,0 +1,45 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_blend_func_separate extension. + * + *Blending capability is extended by defining a function that allows independent setting of the RGB and alpha blend factors for blend operations that + * require source and destination blend factors. It is not always desired that the blending used for RGB is also applied to alpha.
+ * + *Promoted to core in {@link GL14 OpenGL 1.4}.
+ */ +public class EXTBlendFuncSeparate { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_BLEND_DST_RGB_EXT = 0x80C8, + GL_BLEND_SRC_RGB_EXT = 0x80C9, + GL_BLEND_DST_ALPHA_EXT = 0x80CA, + GL_BLEND_SRC_ALPHA_EXT = 0x80CB; + + static { GL.initialize(); } + + protected EXTBlendFuncSeparate() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBlendFuncSeparateEXT + ); + } + + // --- [ glBlendFuncSeparateEXT ] --- + + public static native void glBlendFuncSeparateEXT(@NativeType("GLenum") int sfactorRGB, @NativeType("GLenum") int dfactorRGB, @NativeType("GLenum") int sfactorAlpha, @NativeType("GLenum") int dfactorAlpha); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendMinmax.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendMinmax.java new file mode 100644 index 00000000..8952be90 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendMinmax.java @@ -0,0 +1,50 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_blend_minmax extension. + * + *Blending capability is extended by respecifying the entire blend equation. While this document defines only two new equations, the {@link #glBlendEquationEXT BlendEquationEXT} + * procedure that it defines will be used by subsequent extensions to define additional blending equations.
+ * + *The two new equations defined by this extension produce the minimum (or maximum) color components of the source and destination colors. Taking the + * maximum is useful for applications such as maximum projection in medical imaging.
+ * + *Promoted to core in {@link GL14 OpenGL 1.4}.
+ */ +public class EXTBlendMinmax { + + /** Accepted by the {@code mode} parameter of BlendEquationEXT. */ + public static final int + GL_FUNC_ADD_EXT = 0x8006, + GL_MIN_EXT = 0x8007, + GL_MAX_EXT = 0x8008; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_BLEND_EQUATION_EXT = 0x8009; + + static { GL.initialize(); } + + protected EXTBlendMinmax() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBlendEquationEXT + ); + } + + // --- [ glBlendEquationEXT ] --- + + public static native void glBlendEquationEXT(@NativeType("GLenum") int mode); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendSubtract.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendSubtract.java new file mode 100644 index 00000000..4bad34b2 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTBlendSubtract.java @@ -0,0 +1,26 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_blend_subtract extension. + * + *Two additional blending equations are specified using the interface defined by {@link EXTBlendMinmax EXT_blend_minmax}. These equations are similar to the default + * blending equation, but produce the difference of its left and right hand sides, rather than the sum. Image differences are useful in many image + * processing applications.
+ * + *Promoted to core in {@link GL14 OpenGL 1.4}.
+ */ +public final class EXTBlendSubtract { + + /** Accepted by the {@code mode} parameter of BlendEquationEXT. */ + public static final int + GL_FUNC_SUBTRACT_EXT = 0x800A, + GL_FUNC_REVERSE_SUBTRACT_EXT = 0x800B; + + private EXTBlendSubtract() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTClipVolumeHint.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTClipVolumeHint.java new file mode 100644 index 00000000..a3926f4b --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTClipVolumeHint.java @@ -0,0 +1,22 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_clip_volume_hint extension. + * + *EXT_clip_volume_hint provides a mechanism for applications to indicate that they do not require clip volume clipping for primitives. It allows + * applications to maximize performance in situations where they know that clipping is unnecessary. EXT_clip_volume_hint is only an indication, though, + * and implementations are free to ignore it.
+ */ +public final class EXTClipVolumeHint { + + /** Accepted by the target parameter of Hint and the pname parameter of GetBooleanv, GetDoublev, GetFloatv and GetIntegerv. */ + public static final int GL_CLIP_VOLUME_CLIPPING_HINT_EXT = 0x80F0; + + private EXTClipVolumeHint() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTCompiledVertexArray.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTCompiledVertexArray.java new file mode 100644 index 00000000..8287814a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTCompiledVertexArray.java @@ -0,0 +1,51 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_compiled_vertex_array extension. + * + *This extension defines an interface which allows static vertex array data to be cached or pre-compiled for more efficient rendering. This is useful for + * implementations which can cache the transformed results of array data for reuse by several DrawArrays, ArrayElement, or DrawElements commands. It is + * also useful for implementations which can transfer array data to fast memory for more efficient processing.
+ * + *For example, rendering an M by N mesh of quadrilaterals can be accomplished by setting up vertex arrays containing all of the vertexes in the mesh and + * issuing M DrawElements commands each of which operate on 2 * N vertexes. Each DrawElements command after the first will share N vertexes with the + * preceding DrawElements command. If the vertex array data is locked while the DrawElements commands are executed, then OpenGL may be able to transform + * each of these shared vertexes just once.
+ */ +public class EXTCompiledVertexArray { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = 0x81A8, + GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = 0x81A9; + + static { GL.initialize(); } + + protected EXTCompiledVertexArray() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glLockArraysEXT, caps.glUnlockArraysEXT + ); + } + + // --- [ glLockArraysEXT ] --- + + public static native void glLockArraysEXT(@NativeType("GLint") int first, @NativeType("GLsizei") int count); + + // --- [ glUnlockArraysEXT ] --- + + public static native void glUnlockArraysEXT(); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDebugLabel.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDebugLabel.java new file mode 100644 index 00000000..af10208c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDebugLabel.java @@ -0,0 +1,105 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_debug_label extension. + * + *This extension defines a mechanism for OpenGL and OpenGL ES applications to label their objects (textures, buffers, shaders, etc.) with a descriptive + * string.
+ * + *When profiling or debugging such an application within a debugger or profiler it is difficult to identify resources from their object names. Even when + * the resource itself is viewed it can be problematic to differentiate between similar resources. Attaching a label to an object helps obviate this + * difficulty.
+ * + *The intended purpose of this is purely to improve the user experience within OpenGL and OpenGL ES development tools.
+ */ +public class EXTDebugLabel { + + /** Accepted by the {@code type} parameter of LabelObjectEXT and GetObjectLabelEXT. */ + public static final int + GL_BUFFER_OBJECT_EXT = 0x9151, + GL_SHADER_OBJECT_EXT = 0x8B48, + GL_PROGRAM_OBJECT_EXT = 0x8B40, + GL_VERTEX_ARRAY_OBJECT_EXT = 0x9154, + GL_QUERY_OBJECT_EXT = 0x9153, + GL_PROGRAM_PIPELINE_OBJECT_EXT = 0x8A4F; + + static { GL.initialize(); } + + protected EXTDebugLabel() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glLabelObjectEXT, caps.glGetObjectLabelEXT + ); + } + + // --- [ glLabelObjectEXT ] --- + + public static native void nglLabelObjectEXT(int type, int object, int length, long label); + + public static void glLabelObjectEXT(@NativeType("GLenum") int type, @NativeType("GLuint") int object, @NativeType("GLchar const *") ByteBuffer label) { + nglLabelObjectEXT(type, object, label.remaining(), memAddress(label)); + } + + public static void glLabelObjectEXT(@NativeType("GLenum") int type, @NativeType("GLuint") int object, @NativeType("GLchar const *") CharSequence label) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + int labelEncodedLength = stack.nUTF8(label, false); + long labelEncoded = stack.getPointerAddress(); + nglLabelObjectEXT(type, object, labelEncodedLength, labelEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetObjectLabelEXT ] --- + + public static native void nglGetObjectLabelEXT(int type, int object, int bufSize, long length, long label); + + public static void glGetObjectLabelEXT(@NativeType("GLenum") int type, @NativeType("GLuint") int object, @NativeType("GLsizei *") IntBuffer length, @NativeType("GLchar *") ByteBuffer label) { + if (CHECKS) { + check(length, 1); + } + nglGetObjectLabelEXT(type, object, label.remaining(), memAddress(length), memAddress(label)); + } + + @NativeType("void") + public static String glGetObjectLabelEXT(@NativeType("GLenum") int type, @NativeType("GLuint") int object, @NativeType("GLsizei") int bufSize) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer length = stack.ints(0); + ByteBuffer label = stack.malloc(bufSize); + nglGetObjectLabelEXT(type, object, bufSize, memAddress(length), memAddress(label)); + return memUTF8(label, length.get(0)); + } finally { + stack.setPointer(stackPointer); + } + } + + /** Array version of: {@link #glGetObjectLabelEXT GetObjectLabelEXT} */ + public static void glGetObjectLabelEXT(@NativeType("GLenum") int type, @NativeType("GLuint") int object, @NativeType("GLsizei *") int[] length, @NativeType("GLchar *") ByteBuffer label) { + long __functionAddress = GL.getICD().glGetObjectLabelEXT; + if (CHECKS) { + check(__functionAddress); + check(length, 1); + } + callPPV(type, object, label.remaining(), length, memAddress(label), __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDebugMarker.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDebugMarker.java new file mode 100644 index 00000000..6ddc565a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDebugMarker.java @@ -0,0 +1,83 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_debug_marker extension. + * + *This extension defines a mechanism for OpenGL and OpenGL ES applications to annotate their command stream with markers for discrete events and groups + * of commands using descriptive text markers.
+ * + *When profiling or debugging such an application within a debugger or profiler it is difficult to relate the commands within the command stream to the + * elements of the scene or parts of the program code to which they correspond. Markers help obviate this by allowing applications to specify this link.
+ * + *The intended purpose of this is purely to improve the user experience within OpenGL and OpenGL ES development tools.
+ */ +public class EXTDebugMarker { + + static { GL.initialize(); } + + protected EXTDebugMarker() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glInsertEventMarkerEXT, caps.glPushGroupMarkerEXT, caps.glPopGroupMarkerEXT + ); + } + + // --- [ glInsertEventMarkerEXT ] --- + + public static native void nglInsertEventMarkerEXT(int length, long marker); + + public static void glInsertEventMarkerEXT(@NativeType("GLchar const *") ByteBuffer marker) { + nglInsertEventMarkerEXT(marker.remaining(), memAddress(marker)); + } + + public static void glInsertEventMarkerEXT(@NativeType("GLchar const *") CharSequence marker) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + int markerEncodedLength = stack.nUTF8(marker, false); + long markerEncoded = stack.getPointerAddress(); + nglInsertEventMarkerEXT(markerEncodedLength, markerEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glPushGroupMarkerEXT ] --- + + public static native void nglPushGroupMarkerEXT(int length, long marker); + + public static void glPushGroupMarkerEXT(@NativeType("GLchar const *") ByteBuffer marker) { + nglPushGroupMarkerEXT(marker.remaining(), memAddress(marker)); + } + + public static void glPushGroupMarkerEXT(@NativeType("GLchar const *") CharSequence marker) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + int markerEncodedLength = stack.nUTF8(marker, false); + long markerEncoded = stack.getPointerAddress(); + nglPushGroupMarkerEXT(markerEncodedLength, markerEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glPopGroupMarkerEXT ] --- + + public static native void glPopGroupMarkerEXT(); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDepthBoundsTest.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDepthBoundsTest.java new file mode 100644 index 00000000..0ae6a8e5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDepthBoundsTest.java @@ -0,0 +1,65 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_depth_bounds_test extension. + * + *This extension adds a new per-fragment test that is, logically, after the scissor test and before the alpha test. The depth bounds test compares the + * depth value stored at the location given by the incoming fragment's (xw,yw) coordinates to a user-defined minimum and maximum depth value. If the stored + * depth value is outside the user-defined range (exclusive), the incoming fragment is discarded.
+ * + *Unlike the depth test, the depth bounds test has NO dependency on the fragment's window-space depth value.
+ * + *This functionality is useful in the context of attenuated stenciled shadow volume rendering. To motivate the functionality's utility in this context, we + * first describe how conventional scissor testing can be used to optimize shadow volume rendering.
+ * + *If an attenuated light source's illumination can be bounded to a rectangle in XY window-space, the conventional scissor test can be used to discard + * shadow volume fragments that are guaranteed to be outside the light source's window-space XY rectangle. The stencil increments and decrements that would + * otherwise be generated by these scissored fragments are inconsequential because the light source's illumination can pre-determined to be fully + * attenuated outside the scissored region. In other words, the scissor test can be used to discard shadow volume fragments rendered outside the scissor, + * thereby improving performance, without affecting the ultimate illumination of these pixels with respect to the attenuated light source.
+ * + *This scissoring optimization can be used both when rendering the stenciled shadow volumes to update stencil (incrementing and decrementing the stencil + * buffer) AND when adding the illumination contribution of attenuated light source's.
+ * + *In a similar fashion, we can compute the attenuated light source's window-space Z bounds (zmin,zmax) of consequential illumination. Unless a depth value + * (in the depth buffer) at a pixel is within the range [zmin,zmax], the light source's illumination can be pre-determined to be inconsequential for the + * pixel. Said another way, the pixel being illuminated is either far enough in front of or behind the attenuated light source so that the light source's + * illumination for the pixel is fully attenuated. The depth bounds test can perform this test.
+ */ +public class EXTDepthBoundsTest { + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_DEPTH_BOUNDS_TEST_EXT = 0x8890; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_DEPTH_BOUNDS_EXT = 0x8891; + + static { GL.initialize(); } + + protected EXTDepthBoundsTest() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDepthBoundsEXT + ); + } + + // --- [ glDepthBoundsEXT ] --- + + public static native void glDepthBoundsEXT(double zmin, double zmax); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDirectStateAccess.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDirectStateAccess.java new file mode 100644 index 00000000..49477bd0 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDirectStateAccess.java @@ -0,0 +1,4144 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_direct_state_access extension. + * + *This extension introduces a set of new "direct state access" commands (meaning no selector is involved) to access (update and query) OpenGL state that + * previously depended on the OpenGL state selectors for access. These new commands supplement the existing selector-based OpenGL commands to access the + * same state.
+ * + *The intent of this extension is to make it more efficient for libraries to avoid disturbing selector and latched state. The extension also allows more + * efficient command usage by eliminating the need for selector update commands.
+ * + *Two derivative advantages of this extension are 1) display lists can be executed using these commands that avoid disturbing selectors that subsequent + * commands may depend on, and 2) drivers implemented with a dual-thread partitioning with OpenGL command buffering from an application thread and then + * OpenGL command dispatching in a concurrent driver thread can avoid thread synchronization created by selector saving, setting, command execution, and + * selector restoration.
+ * + *This extension does not itself add any new OpenGL state.
+ * + *We call a state variable in OpenGL an "OpenGL state selector" or simply a "selector" if OpenGL commands depend on the state variable to determine what + * state to query or update. The matrix mode and active texture are both selectors. Object bindings for buffers, programs, textures, and framebuffer + * objects are also selectors.
+ * + *We call OpenGL state "latched" if the state is set by one OpenGL command but then that state is saved by a subsequent command or the state determines + * how client memory or buffer object memory is accessed by a subsequent command. The array and element array buffer bindings are latched by vertex array + * specification commands to determine which buffer a given vertex array uses. Vertex array state and pixel pack/unpack state decides how client memory or + * buffer object memory is accessed by subsequent vertex pulling or image specification commands.
+ * + *The existence of selectors and latched state in the OpenGL API reduces the number of parameters to various sets of OpenGL commands but complicates the + * access to state for layered libraries which seek to access state without disturbing other state, namely the state of state selectors and latched state. + * In many cases, selectors and latched state were introduced by extensions as OpenGL evolved to minimize the disruption to the OpenGL API when new + * functionality, particularly the pluralization of existing functionality as when texture objects and later multiple texture units, was introduced.
+ * + *The OpenGL API involves several selectors (listed in historical order of introduction):
+ * + *The new selector-free update commands can be compiled into display lists.
+ * + *The OpenGL API has latched state for vertex array buffer objects and pixel store state. When an application issues a GL command to unpack or pack pixels + * (for example, glTexImage2D or glReadPixels respectively), the current unpack and pack pixel store state determines how the pixels are unpacked + * from/packed to client memory or pixel buffer objects. For example, consider:
+ * + *
+ * glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_TRUE);
+ * glPixelStorei(GL_UNPACK_ROW_LENGTH, 640);
+ * glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 47);
+ * glDrawPixels(100, 100, GL_RGB, GL_FLOAT, pixels);The unpack swap bytes and row length state set by the preceding glPixelStorei commands (as well as the 6 other unpack pixel store state variables) + * control how data is read (unpacked) from buffer of data pointed to by pixels. The glBindBuffer command also specifies an unpack buffer object (47) so + * the pixel pointer is actually treated as a byte offset into buffer object 47.
+ * + *When an application issues a command to configure a vertex array, the current array buffer state is latched as the binding for the particular vertex + * array being specified. For example, consider:
+ * + *
+ * glBindBuffer(GL_ARRAY_BUFFER, 23);
+ * glVertexPointer(3, GL_FLOAT, 12, pointer);The glBindBuffer command updates the array buffering binding (GL_ARRAY_BUFFER_BINDING) to the buffer object named 23. The subsequent glVertexPointer + * command specifies explicit parameters for the size, type, stride, and pointer to access the position vertex array BUT ALSO latches the current array + * buffer binding for the vertex array buffer binding (GL_VERTEX_ARRAY_BUFFER_BINDING). Effectively the current array buffer binding buffer object becomes + * an implicit fifth parameter to glVertexPointer and this applies to all the gl*Pointer vertex array specification commands.
+ * + *Selectors and latched state create problems for layered libraries using OpenGL because selectors require the selector state to be modified to update + * some other state and latched state means implicit state can affect the operation of commands specifying, packing, or unpacking data through + * pointers/offsets. For layered libraries, a state update performed by the library may attempt to save the selector state, set the selector, update/query + * some state the selector controls, and then restore the selector to its saved state. Layered libraries can skip the selector save/restore but this risks + * introducing uncertainty about the state of a selector after calling layered library routines. Such selector side-effects are difficult to document and + * lead to compatibility issues as the layered library evolves or its usage varies. For latched state, layered libraries may find commands such as + * glDrawPixels do not work as expected because latched pixel store state is not what the library expects. Querying or pushing the latched state, setting + * the latched state explicitly, performing the operation involving latched state, and then restoring or popping the latched state avoids entanglements + * with latched state but at considerable cost.
+ * + *Consider the following routine to set the modelview matrix involving the matrix mode selector:
+ * + *
+ * void setModelviewMatrix(const GLfloat matrix[16])
+ * {
+ * GLenum savedMatrixMode;
+ *
+ * glGetIntegerv(GL_MATRIX_MODE, &savedMatrixMode);
+ * glMatrixMode(GL_MODELVIEW);
+ * glLoadMatrixf(matrix);
+ * glMatrixMode(savedMatrixMode);
+ * }Notice that four OpenGL commands are required to update the current modelview matrix without disturbing the matrix mode selector.
+ * + *OpenGL query commands can also substantially reduce the performance of modern OpenGL implementations which may off-load OpenGL state processing to + * another CPU core/thread or to the GPU itself.
+ * + *An alternative to querying the selector is to use the glPushAttrib/glPopAttrib commands. However this approach typically involves pushing far more state + * than simply the one or two selectors that need to be saved and restored. Because so much state is associated with a given push/pop attribute bit, the + * glPushAttrib and glPopAttrib commands are considerably more costly than the save/restore approach. Additionally glPushAttrib risks overflowing the + * attribute stack.
+ * + *The reliability and performance of layered libraries and applications can be improved by adding to the OpenGL API a new set of commands to access + * directly OpenGL state that otherwise involves selectors to access.
+ * + *The above example can be reimplemented more efficiently and without selector side-effects:
+ * + *
+ * void setModelviewMatrix(const GLfloat matrix[16])
+ * {
+ * glMatrixLoadfEXT(GL_MODELVIEW, matrix);
+ * }Consider a layered library seeking to load a texture:
+ * + *
+ * void loadTexture(GLint texobj, GLint width, GLint height, void *data)
+ * {
+ * glBindTexture(GL_TEXTURE_2D, texobj);
+ * glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, width, height, GL_RGB, GL_FLOAT, data);
+ * }The library expects the data to be packed into the buffer pointed to by data. But what if the current pixel unpack buffer binding is not zero so the + * current pixel unpack buffer, rather than client memory, will be read? Or what if the application has modified the GL_UNPACK_ROW_LENGTH pixel store state + * before loadTexture is called?
+ * + *We can fix the routine by calling glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0) and setting all the pixel store unpack state to the initial state the + * loadTexture routine expects, but this is expensive. It also risks disturbing the state so when loadTexture returns to the application, the application + * doesn't realize the current texture object (for whatever texture unit the current active texture happens to be) and pixel store state has changed.
+ * + *We can more efficiently implement this routine without disturbing selector or latched state as follows:
+ * + *
+ * void loadTexture(GLint texobj, GLint width, GLint height, void *data)
+ * {
+ * glPushClientAttribDefaultEXT(GL_CLIENT_PIXEL_STORE_BIT);
+ * glTextureImage2D(texobj, GL_TEXTURE_2D, 0, GL_RGB8, width, height, GL_RGB, GL_FLOAT, data);
+ * glPopClientAttrib();
+ * }Now loadTexture does not have to worry about inappropriately configured pixel store state or a non-zero pixel unpack buffer binding. And loadTexture has + * no unintended side-effects for selector or latched state (assuming the client attrib state does not overflow).
+ */ +public class EXTDirectStateAccess { + + /** GetBooleani_v, GetIntegeri_v, GetFloati_vEXT, GetDoublei_vEXT. */ + public static final int + GL_PROGRAM_MATRIX_EXT = 0x8E2D, + GL_TRANSPOSE_PROGRAM_MATRIX_EXT = 0x8E2E, + GL_PROGRAM_MATRIX_STACK_DEPTH_EXT = 0x8E2F; + + static { GL.initialize(); } + + protected EXTDirectStateAccess() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetThis extension builds upon the ARB_draw_buffers extension and provides separate blend enables and color write masks for each color output. In + * ARB_draw_buffers (part of OpenGL 2.0), separate values can be written to each color buffer, but the blend enable and color write mask are global and + * apply to all color outputs.
+ * + *While this extension does provide separate blend enables, it does not provide separate blend functions or blend equations per color output.
+ * + *Requires {@link GL20 OpenGL 2.0}.
+ */ +public class EXTDrawBuffers2 { + + static { GL.initialize(); } + + protected EXTDrawBuffers2() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glColorMaskIndexedEXT, caps.glGetBooleanIndexedvEXT, caps.glGetIntegerIndexedvEXT, caps.glEnableIndexedEXT, caps.glDisableIndexedEXT, + caps.glIsEnabledIndexedEXT + ); + } + + // --- [ glColorMaskIndexedEXT ] --- + + public static native void glColorMaskIndexedEXT(@NativeType("GLuint") int index, @NativeType("GLboolean") boolean r, @NativeType("GLboolean") boolean g, @NativeType("GLboolean") boolean b, @NativeType("GLboolean") boolean a); + + // --- [ glGetBooleanIndexedvEXT ] --- + + public static native void nglGetBooleanIndexedvEXT(int target, int index, long data); + + public static void glGetBooleanIndexedvEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLboolean *") ByteBuffer data) { + if (CHECKS) { + check(data, 1); + } + nglGetBooleanIndexedvEXT(target, index, memAddress(data)); + } + + @NativeType("void") + public static boolean glGetBooleanIndexedEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + ByteBuffer data = stack.calloc(1); + nglGetBooleanIndexedvEXT(target, index, memAddress(data)); + return data.get(0) != 0; + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetIntegerIndexedvEXT ] --- + + public static native void nglGetIntegerIndexedvEXT(int target, int index, long data); + + public static void glGetIntegerIndexedvEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLint *") IntBuffer data) { + if (CHECKS) { + check(data, 1); + } + nglGetIntegerIndexedvEXT(target, index, memAddress(data)); + } + + @NativeType("void") + public static int glGetIntegerIndexedEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer data = stack.callocInt(1); + nglGetIntegerIndexedvEXT(target, index, memAddress(data)); + return data.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glEnableIndexedEXT ] --- + + public static native void glEnableIndexedEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index); + + // --- [ glDisableIndexedEXT ] --- + + public static native void glDisableIndexedEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index); + + // --- [ glIsEnabledIndexedEXT ] --- + + @NativeType("GLboolean") + public static native boolean glIsEnabledIndexedEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index); + + /** Array version of: {@link #glGetIntegerIndexedvEXT GetIntegerIndexedvEXT} */ + public static void glGetIntegerIndexedvEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLint *") int[] data) { + long __functionAddress = GL.getICD().glGetIntegerIndexedvEXT; + if (CHECKS) { + check(__functionAddress); + check(data, 1); + } + callPV(target, index, data, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDrawInstanced.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDrawInstanced.java new file mode 100644 index 00000000..4ee89030 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTDrawInstanced.java @@ -0,0 +1,65 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_draw_instanced extension. + * + *This extension provides the means to render multiple instances of an object with a single draw call, and an "instance ID" variable which can be used by + * the vertex program to compute per-instance values, typically an object's transform.
+ * + *Requires {@link GL20 OpenGL 2.0}.
+ */ +public class EXTDrawInstanced { + + static { GL.initialize(); } + + protected EXTDrawInstanced() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDrawArraysInstancedEXT, caps.glDrawElementsInstancedEXT + ); + } + + // --- [ glDrawArraysInstancedEXT ] --- + + public static native void glDrawArraysInstancedEXT(@NativeType("GLenum") int mode, @NativeType("GLint") int start, @NativeType("GLsizei") int count, @NativeType("GLsizei") int primcount); + + // --- [ glDrawElementsInstancedEXT ] --- + + public static native void nglDrawElementsInstancedEXT(int mode, int count, int type, long indices, int primcount); + + public static void glDrawElementsInstancedEXT(@NativeType("GLenum") int mode, @NativeType("GLsizei") int count, @NativeType("GLenum") int type, @NativeType("void const *") long indices, @NativeType("GLsizei") int primcount) { + nglDrawElementsInstancedEXT(mode, count, type, indices, primcount); + } + + public static void glDrawElementsInstancedEXT(@NativeType("GLenum") int mode, @NativeType("GLenum") int type, @NativeType("void const *") ByteBuffer indices, @NativeType("GLsizei") int primcount) { + nglDrawElementsInstancedEXT(mode, indices.remaining() >> GLChecks.typeToByteShift(type), type, memAddress(indices), primcount); + } + + public static void glDrawElementsInstancedEXT(@NativeType("GLenum") int mode, @NativeType("void const *") ByteBuffer indices, @NativeType("GLsizei") int primcount) { + nglDrawElementsInstancedEXT(mode, indices.remaining(), GL11.GL_UNSIGNED_BYTE, memAddress(indices), primcount); + } + + public static void glDrawElementsInstancedEXT(@NativeType("GLenum") int mode, @NativeType("void const *") ShortBuffer indices, @NativeType("GLsizei") int primcount) { + nglDrawElementsInstancedEXT(mode, indices.remaining(), GL11.GL_UNSIGNED_SHORT, memAddress(indices), primcount); + } + + public static void glDrawElementsInstancedEXT(@NativeType("GLenum") int mode, @NativeType("void const *") IntBuffer indices, @NativeType("GLsizei") int primcount) { + nglDrawElementsInstancedEXT(mode, indices.remaining(), GL11.GL_UNSIGNED_INT, memAddress(indices), primcount); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTEGLImageStorage.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTEGLImageStorage.java new file mode 100644 index 00000000..b1b65488 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTEGLImageStorage.java @@ -0,0 +1,93 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_EGL_image_storage extension. + * + *The OpenGL ES extension {@code OES_EGL_image} provides a mechanism for creating GL textures sharing storage with {@code EGLImage} objects (in other + * words, creating GL texture {@code EGLImage} targets). The extension was written against the OpenGL ES 2.0 specification, which does not have the + * concept of immutable textures. As a result, it specifies that respecification of a texture by calling {@code TexImage*} on a texture that is an + * {@code EGLImage} target causes it to be implicitly orphaned. In most cases, this is not the desired behavior, but rather a result of an application + * error.
+ * + *This extension provides a mechanism for creating texture objects that are both {@code EGLImage} targets and immutable. Since immutable textures cannot + * be respecified, they also cannot accidentally be orphaned, and attempts to do so generate errors instead of resulting in well-defined, but often + * undesirable and surprising behavior. It provides a strong guarantee that texture data that is intended to be shared will remain shared.
+ * + *Requires {@link GL42 OpenGL 4.2} or {@link ARBTextureStorage ARB_texture_storage}. Requires EGL 1.4 and either the {@code EGL_KHR_image} or {@code EGL_KHR_image_base} extensions.
+ */ +public class EXTEGLImageStorage { + + static { GL.initialize(); } + + protected EXTEGLImageStorage() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetExtension EXT_buffer_storage introduced immutable storage buffers to OpenGL ES. This extension allows the data store for an immutable buffer to be + * sourced from an external {@code EGLClientBuffer}, allowing sharing of EGL client buffers across APIs, across processes, and across different processing + * cores such as the GPU, CPU, and DSP.
+ * + *Operations can then be performed on the external buffer using standard GL buffer object procedures. The data in the allocation is not copied to the + * buffer object's data store; the external allocation represents a single memory allocation that can be shared across multiple GL objects -- this aspect + * is similar to EGL external images. On the other hand, the external buffer does not provide lifetime guarantees including orphaning and sibling behavior + * as provided by EGL external images.
+ * + *The {@code EGLClientBuffer} must be allocated in a way which permits this shared access. For example, on Android via a shareable Android hardware + * buffer. This extension does not enable support for arbitrary {@code EGLClientBuffers} to be used as an external buffer.
+ * + *It is the application's responsibility to ensure synchronization between operations performed by separate components (DSP / CPU / GPU) and processes on + * the external buffer. Additionally the application is responsible for avoiding violating existing GL spec requirements. For example, mapping a single + * shared allocation to two GL buffer objects and then performing {@code CopyBufferSubData} such that the read and write regions overlap would violate the + * existing {@code CopyBufferSubData} spec regarding copies performed with the same buffer set for source and destination.
+ * + *The application must take any steps necessary to ensure memory access to the external buffer behaves as required by the application. For example, + * preventing compilation differences in data padding from causing data to be inadvertently corrupted by using defined structure alignment methods such as + * the std140 layout qualifier. The application is responsible for managing the lifetime of the external buffer, ensuring that the external buffer is not + * deleted as long as there are any GL buffer objects referring to it.
+ * + *Requires {@link GL44 OpenGL 4.4}.
+ */ +public class EXTExternalBuffer { + + static { GL.initialize(); } + + protected EXTExternalBuffer() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetThis extension modifies EXT_framebuffer_object by splitting the framebuffer object binding point into separate DRAW and READ bindings. This allows + * copying directly from one framebuffer to another. In addition, a new high performance blit function is added to facilitate these blits and perform some + * data conversion where allowed.
+ * + *Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public class EXTFramebufferBlit { + + /** + * Accepted by the {@code target} parameter of BindFramebufferEXT, CheckFramebufferStatusEXT, FramebufferTexture{1D|2D|3D}EXT, FramebufferRenderbufferEXT, + * and GetFramebufferAttachmentParameterivEXT. + */ + public static final int + GL_READ_FRAMEBUFFER_EXT = 0x8CA8, + GL_DRAW_FRAMEBUFFER_EXT = 0x8CA9; + + /** Accepted by the {@code pname} parameters of GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_DRAW_FRAMEBUFFER_BINDING_EXT = 0x8CA6, + GL_READ_FRAMEBUFFER_BINDING_EXT = 0x8CAA; + + static { GL.initialize(); } + + protected EXTFramebufferBlit() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBlitFramebufferEXT + ); + } + + // --- [ glBlitFramebufferEXT ] --- + + public static native void glBlitFramebufferEXT(@NativeType("GLint") int srcX0, @NativeType("GLint") int srcY0, @NativeType("GLint") int srcX1, @NativeType("GLint") int srcY1, @NativeType("GLint") int dstX0, @NativeType("GLint") int dstY0, @NativeType("GLint") int dstX1, @NativeType("GLint") int dstY1, @NativeType("GLbitfield") int mask, @NativeType("GLenum") int filter); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTFramebufferMultisample.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTFramebufferMultisample.java new file mode 100644 index 00000000..5a303c80 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTFramebufferMultisample.java @@ -0,0 +1,84 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_framebuffer_multisample extension. + * + *This extension extends the EXT_framebuffer_object framework to enable multisample rendering.
+ * + *The new operation RenderbufferStorageMultisampleEXT() allocates storage for a renderbuffer object that can be used as a multisample buffer. A + * multisample render buffer image differs from a single-sample render buffer image in that a multisample image has a number of SAMPLES that is greater + * than zero. No method is provided for creating multisample texture images.
+ * + *All of the framebuffer-attachable images attached to a framebuffer object must have the same number of SAMPLES or else the framebuffer object is not + * "framebuffer complete". If a framebuffer object with multisample attachments is "framebuffer complete", then the framebuffer object behaves as if + * SAMPLE_BUFFERS is one.
+ * + *In traditional multisample rendering, where DRAW_FRAMEBUFFER_BINDING_EXT is zero and SAMPLE_BUFFERS is one, the GL spec states that "the color sample + * values are resolved to a single, displayable color each time a pixel is updated." There are, however, several modern hardware implementations that do + * not actually resolve for each sample update, but instead postpones the resolve operation to a later time and resolve a batch of sample updates at a + * time. This is OK as long as the implementation behaves "as if" it had resolved a sample-at-a-time. Unfortunately, however, honoring the "as if" rule can + * sometimes degrade performance.
+ * + *In contrast, when DRAW_FRAMEBUFFER_BINDING_EXT is an application-created framebuffer object, MULTISAMPLE is enabled, and SAMPLE_BUFFERS is one, there is + * no implicit per-sample-update resolve. Instead, the application explicitly controls when the resolve operation is performed. The resolve operation is + * affected by calling BlitFramebufferEXT (provided by the EXT_framebuffer_blit extension) where the source is a multisample application-created + * framebuffer object and the destination is a single-sample framebuffer object (either application-created or window-system provided).
+ * + *This design for multisample resolve more closely matches current hardware, but still permits implementations which choose to resolve a single sample at + * a time. If hardware that implementes the multisample resolution "one sample at a time" exposes EXT_framebuffer_multisample, it could perform the + * implicit resolve to a driver-managed hidden surface, then read from that surface when the application calls BlitFramebufferEXT.
+ * + *Another motivation for granting the application explicit control over the multisample resolve operation has to do with the flexibility afforded by + * EXT_framebuffer_object. Previously, a drawable (window or pbuffer) had exclusive access to all of its buffers. There was no mechanism for sharing a + * buffer across multiple drawables. Under EXT_framebuffer_object, however, a mechanism exists for sharing a framebuffer-attachable image across several + * framebuffer objects, as well as sharing an image between a framebuffer object and a texture. If we had retained the "implicit" + * resolve from traditional multisampled rendering, and allowed the creation of "multisample" format renderbuffers, then this type of sharing would have + * lead to two problematic situations:
+ * + *By using the BlitFramebufferEXT from EXT_framebuffer_blit as an explicit resolve to serialize access to the multisampled contents and eliminate the + * implicit per-sample resolve operation, we avoid both of these problems.
+ * + *Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public class EXTFramebufferMultisample { + + /** Accepted by the {@code pname} parameter of GetRenderbufferParameterivEXT. */ + public static final int GL_RENDERBUFFER_SAMPLES_EXT = 0x8CAB; + + /** Returned by CheckFramebufferStatusEXT. */ + public static final int GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = 0x8D56; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_MAX_SAMPLES_EXT = 0x8D57; + + static { GL.initialize(); } + + protected EXTFramebufferMultisample() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glRenderbufferStorageMultisampleEXT + ); + } + + // --- [ glRenderbufferStorageMultisampleEXT ] --- + + public static native void glRenderbufferStorageMultisampleEXT(@NativeType("GLenum") int target, @NativeType("GLsizei") int samples, @NativeType("GLenum") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTFramebufferMultisampleBlitScaled.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTFramebufferMultisampleBlitScaled.java new file mode 100644 index 00000000..605f2944 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTFramebufferMultisampleBlitScaled.java @@ -0,0 +1,38 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_framebuffer_multisample_blit_scaled extension. + * + *This extension relaxes some of the restrictions associated with multisample resolve operations, specifically to allow a combined resolve and scale + * operation through a single call to BlitFramebuffer. It also adds two new filter types to control the quality of the combined scaled resolve operation.
+ * + *In traditional multisampled framebuffer rendering, color samples must be explicitly resolved via BlitFramebuffer before any other operation on the + * resulting pixel values can be performed. This multisample resolve operation must be done using a BlitFramebuffer call where the dimensions of the source + * and destination rectangles are identical. If the resulting pixel values need to be copied to a texture with different dimensions, these resolved values + * can then be scaled with a second call to BlitFramebuffer.
+ * + *By requiring two separate calls to BlitFramebuffer, the quality of final image can be maintained to a certain degree. The samples are first resolved, + * and then these resolved values can be filtered to produce the final image. This image quality comes at the price of increased memory usage and lower + * performance. However, the scaling blit can still introduce artifacts, particularly if it is done with a simple bilinear filter.
+ * + *The new filter types introduced by this extension allow the scaled resolve to be done with a single call to BlitFramebuffer. Not all samples from the + * read framebuffer are required to be be used when producing the final pixel values, and there may be a loss in quality when compared to an image produced + * by a separate resolve and scale. However, the single-pass scaled resolve blit should be faster than the traditional two-pass resolve then scale blits.
+ * + *Requires {@link ARBFramebufferObject ARB_framebuffer_object}.
+ */ +public final class EXTFramebufferMultisampleBlitScaled { + + /** Accepted by the {@code filter} parameter of BlitFramebuffer. */ + public static final int + GL_SCALED_RESOLVE_FASTEST_EXT = 0x90BA, + GL_SCALED_RESOLVE_NICEST_EXT = 0x90BB; + + private EXTFramebufferMultisampleBlitScaled() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTFramebufferObject.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTFramebufferObject.java new file mode 100644 index 00000000..ad84518a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTFramebufferObject.java @@ -0,0 +1,384 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_framebuffer_object extension. + * + *This extension defines a simple interface for drawing to rendering destinations other than the buffers provided to the GL by the window-system.
+ * + *In this extension, these newly defined rendering destinations are known collectively as "framebuffer-attachable images". This extension provides a + * mechanism for attaching framebuffer-attachable images to the GL framebuffer as one of the standard GL logical buffers: color, depth, and stencil. + * (Attaching a framebuffer-attachable image to the accum logical buffer is left for a future extension to define). When a framebuffer-attachable image is + * attached to the framebuffer, it is used as the source and destination of fragment operations.
+ * + *By allowing the use of a framebuffer-attachable image as a rendering destination, this extension enables a form of "offscreen" rendering. Furthermore, + * "render to texture" is supported by allowing the images of a texture to be used as framebuffer-attachable images. A particular image of a texture object + * is selected for use as a framebuffer-attachable image by specifying the mipmap level, cube map face (for a cube map texture), and z-offset (for a 3D + * texture) that identifies the image. The "render to texture" semantics of this extension are similar to performing traditional rendering to the + * framebuffer, followed immediately by a call to CopyTexSubImage. However, by using this extension instead, an application can achieve the same effect, + * but with the advantage that the GL can usually eliminate the data copy that would have been incurred by calling CopyTexSubImage.
+ * + *This extension also defines a new GL object type, called a "renderbuffer", which encapsulates a single 2D pixel image. The image of renderbuffer can be + * used as a framebuffer-attachable image for generalized offscreen rendering and it also provides a means to support rendering to GL logical buffer types + * which have no corresponding texture format (stencil, accum, etc). A renderbuffer is similar to a texture in that both renderbuffers and textures can be + * independently allocated and shared among multiple contexts. The framework defined by this extension is general enough that support for attaching images + * from GL objects other than textures and renderbuffers could be added by layered extensions.
+ * + *To facilitate efficient switching between collections of framebuffer-attachable images, this extension introduces another new GL object, called a + * framebuffer object. A framebuffer object contains the state that defines the traditional GL framebuffer, including its set of images. Prior to this + * extension, it was the window-system which defined and managed this collection of images, traditionally by grouping them into a "drawable". The + * window-system API's would also provide a function (i.e., wglMakeCurrent, glXMakeCurrent, aglSetDrawable, etc.) to bind a drawable with a GL context (as + * is done in the WGL_ARB_pbuffer extension). In this extension however, this functionality is subsumed by the GL and the GL provides the function + * BindFramebufferEXT to bind a framebuffer object to the current context. Later, the context can bind back to the window-system-provided framebuffer in + * order to display rendered content.
+ * + *Previous extensions that enabled rendering to a texture have been much more complicated. One example is the combination of ARB_pbuffer and + * ARB_render_texture, both of which are window-system extensions. This combination requires calling MakeCurrent, an operation that may be expensive, to + * switch between the window and the pbuffer drawables. An application must create one pbuffer per renderable texture in order to portably use + * ARB_render_texture. An application must maintain at least one GL context per texture format, because each context can only operate on a single + * pixelformat or FBConfig. All of these characteristics make ARB_render_texture both inefficient and cumbersome to use.
+ * + *EXT_framebuffer_object, on the other hand, is both simpler to use and more efficient than ARB_render_texture. The EXT_framebuffer_object API is + * contained wholly within the GL API and has no (non-portable) window-system components. Under EXT_framebuffer_object, it is not necessary to create a + * second GL context when rendering to a texture image whose format differs from that of the window. Finally, unlike the pbuffers of ARB_render_texture, a + * single framebuffer object can facilitate rendering to an unlimited number of texture objects.
+ * + *Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public class EXTFramebufferObject { + + /** + * Accepted by the {@code target} parameter of BindFramebufferEXT, CheckFramebufferStatusEXT, FramebufferTexture{1D|2D|3D}EXT, FramebufferRenderbufferEXT, + * and GetFramebufferAttachmentParameterivEXT. + */ + public static final int GL_FRAMEBUFFER_EXT = 0x8D40; + + /** + * Accepted by the {@code target} parameter of BindRenderbufferEXT, RenderbufferStorageEXT, and GetRenderbufferParameterivEXT, and returned by + * GetFramebufferAttachmentParameterivEXT. + */ + public static final int GL_RENDERBUFFER_EXT = 0x8D41; + + /** Accepted by the {@code internalformat} parameter of RenderbufferStorageEXT. */ + public static final int + GL_STENCIL_INDEX1_EXT = 0x8D46, + GL_STENCIL_INDEX4_EXT = 0x8D47, + GL_STENCIL_INDEX8_EXT = 0x8D48, + GL_STENCIL_INDEX16_EXT = 0x8D49; + + /** Accepted by the {@code pname} parameter of GetRenderbufferParameterivEXT. */ + public static final int + GL_RENDERBUFFER_WIDTH_EXT = 0x8D42, + GL_RENDERBUFFER_HEIGHT_EXT = 0x8D43, + GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = 0x8D44, + GL_RENDERBUFFER_RED_SIZE_EXT = 0x8D50, + GL_RENDERBUFFER_GREEN_SIZE_EXT = 0x8D51, + GL_RENDERBUFFER_BLUE_SIZE_EXT = 0x8D52, + GL_RENDERBUFFER_ALPHA_SIZE_EXT = 0x8D53, + GL_RENDERBUFFER_DEPTH_SIZE_EXT = 0x8D54, + GL_RENDERBUFFER_STENCIL_SIZE_EXT = 0x8D55; + + /** Accepted by the {@code pname} parameter of GetFramebufferAttachmentParameterivEXT. */ + public static final int + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 0x8CD0, + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 0x8CD1, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 0x8CD2, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 0x8CD3, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 0x8CD4; + + /** Accepted by the {@code attachment} parameter of FramebufferTexture{1D|2D|3D}EXT, FramebufferRenderbufferEXT, and GetFramebufferAttachmentParameterivEXT. */ + public static final int + GL_COLOR_ATTACHMENT0_EXT = 0x8CE0, + GL_COLOR_ATTACHMENT1_EXT = 0x8CE1, + GL_COLOR_ATTACHMENT2_EXT = 0x8CE2, + GL_COLOR_ATTACHMENT3_EXT = 0x8CE3, + GL_COLOR_ATTACHMENT4_EXT = 0x8CE4, + GL_COLOR_ATTACHMENT5_EXT = 0x8CE5, + GL_COLOR_ATTACHMENT6_EXT = 0x8CE6, + GL_COLOR_ATTACHMENT7_EXT = 0x8CE7, + GL_COLOR_ATTACHMENT8_EXT = 0x8CE8, + GL_COLOR_ATTACHMENT9_EXT = 0x8CE9, + GL_COLOR_ATTACHMENT10_EXT = 0x8CEA, + GL_COLOR_ATTACHMENT11_EXT = 0x8CEB, + GL_COLOR_ATTACHMENT12_EXT = 0x8CEC, + GL_COLOR_ATTACHMENT13_EXT = 0x8CED, + GL_COLOR_ATTACHMENT14_EXT = 0x8CEE, + GL_COLOR_ATTACHMENT15_EXT = 0x8CEF, + GL_DEPTH_ATTACHMENT_EXT = 0x8D00, + GL_STENCIL_ATTACHMENT_EXT = 0x8D20; + + /** Returned by CheckFramebufferStatusEXT(). */ + public static final int + GL_FRAMEBUFFER_COMPLETE_EXT = 0x8CD5, + GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = 0x8CD6, + GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 0x8CD7, + GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 0x8CD9, + GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 0x8CDA, + GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 0x8CDB, + GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 0x8CDC, + GL_FRAMEBUFFER_UNSUPPORTED_EXT = 0x8CDD; + + /** Accepted by GetIntegerv(). */ + public static final int + GL_FRAMEBUFFER_BINDING_EXT = 0x8CA6, + GL_RENDERBUFFER_BINDING_EXT = 0x8CA7, + GL_MAX_COLOR_ATTACHMENTS_EXT = 0x8CDF, + GL_MAX_RENDERBUFFER_SIZE_EXT = 0x84E8; + + /** Returned by GetError(). */ + public static final int GL_INVALID_FRAMEBUFFER_OPERATION_EXT = 0x506; + + static { GL.initialize(); } + + protected EXTFramebufferObject() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glIsRenderbufferEXT, caps.glBindRenderbufferEXT, caps.glDeleteRenderbuffersEXT, caps.glGenRenderbuffersEXT, caps.glRenderbufferStorageEXT, + caps.glGetRenderbufferParameterivEXT, caps.glIsFramebufferEXT, caps.glBindFramebufferEXT, caps.glDeleteFramebuffersEXT, caps.glGenFramebuffersEXT, + caps.glCheckFramebufferStatusEXT, caps.glFramebufferTexture1DEXT, caps.glFramebufferTexture2DEXT, caps.glFramebufferTexture3DEXT, + caps.glFramebufferRenderbufferEXT, caps.glGetFramebufferAttachmentParameterivEXT, caps.glGenerateMipmapEXT + ); + } + + // --- [ glIsRenderbufferEXT ] --- + + @NativeType("GLboolean") + public static native boolean glIsRenderbufferEXT(@NativeType("GLuint") int renderbuffer); + + // --- [ glBindRenderbufferEXT ] --- + + public static native void glBindRenderbufferEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int renderbuffer); + + // --- [ glDeleteRenderbuffersEXT ] --- + + public static native void nglDeleteRenderbuffersEXT(int n, long renderbuffers); + + public static void glDeleteRenderbuffersEXT(@NativeType("GLuint const *") IntBuffer renderbuffers) { + nglDeleteRenderbuffersEXT(renderbuffers.remaining(), memAddress(renderbuffers)); + } + + public static void glDeleteRenderbuffersEXT(@NativeType("GLuint const *") int renderbuffer) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer renderbuffers = stack.ints(renderbuffer); + nglDeleteRenderbuffersEXT(1, memAddress(renderbuffers)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGenRenderbuffersEXT ] --- + + public static native void nglGenRenderbuffersEXT(int n, long renderbuffers); + + public static void glGenRenderbuffersEXT(@NativeType("GLuint *") IntBuffer renderbuffers) { + nglGenRenderbuffersEXT(renderbuffers.remaining(), memAddress(renderbuffers)); + } + + @NativeType("void") + public static int glGenRenderbuffersEXT() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer renderbuffers = stack.callocInt(1); + nglGenRenderbuffersEXT(1, memAddress(renderbuffers)); + return renderbuffers.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glRenderbufferStorageEXT ] --- + + public static native void glRenderbufferStorageEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height); + + // --- [ glGetRenderbufferParameterivEXT ] --- + + public static native void nglGetRenderbufferParameterivEXT(int target, int pname, long params); + + public static void glGetRenderbufferParameterivEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLint *") IntBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetRenderbufferParameterivEXT(target, pname, memAddress(params)); + } + + @NativeType("void") + public static int glGetRenderbufferParameteriEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer params = stack.callocInt(1); + nglGetRenderbufferParameterivEXT(target, pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glIsFramebufferEXT ] --- + + @NativeType("GLboolean") + public static native boolean glIsFramebufferEXT(@NativeType("GLuint") int framebuffer); + + // --- [ glBindFramebufferEXT ] --- + + public static native void glBindFramebufferEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int framebuffer); + + // --- [ glDeleteFramebuffersEXT ] --- + + public static native void nglDeleteFramebuffersEXT(int n, long framebuffers); + + public static void glDeleteFramebuffersEXT(@NativeType("GLuint const *") IntBuffer framebuffers) { + nglDeleteFramebuffersEXT(framebuffers.remaining(), memAddress(framebuffers)); + } + + public static void glDeleteFramebuffersEXT(@NativeType("GLuint const *") int framebuffer) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer framebuffers = stack.ints(framebuffer); + nglDeleteFramebuffersEXT(1, memAddress(framebuffers)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGenFramebuffersEXT ] --- + + public static native void nglGenFramebuffersEXT(int n, long framebuffers); + + public static void glGenFramebuffersEXT(@NativeType("GLuint *") IntBuffer framebuffers) { + nglGenFramebuffersEXT(framebuffers.remaining(), memAddress(framebuffers)); + } + + @NativeType("void") + public static int glGenFramebuffersEXT() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer framebuffers = stack.callocInt(1); + nglGenFramebuffersEXT(1, memAddress(framebuffers)); + return framebuffers.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glCheckFramebufferStatusEXT ] --- + + @NativeType("GLenum") + public static native int glCheckFramebufferStatusEXT(@NativeType("GLenum") int target); + + // --- [ glFramebufferTexture1DEXT ] --- + + public static native void glFramebufferTexture1DEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int attachment, @NativeType("GLenum") int textarget, @NativeType("GLuint") int texture, @NativeType("GLint") int level); + + // --- [ glFramebufferTexture2DEXT ] --- + + public static native void glFramebufferTexture2DEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int attachment, @NativeType("GLenum") int textarget, @NativeType("GLuint") int texture, @NativeType("GLint") int level); + + // --- [ glFramebufferTexture3DEXT ] --- + + public static native void glFramebufferTexture3DEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int attachment, @NativeType("GLenum") int textarget, @NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLint") int zoffset); + + // --- [ glFramebufferRenderbufferEXT ] --- + + public static native void glFramebufferRenderbufferEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int attachment, @NativeType("GLenum") int renderbuffertarget, @NativeType("GLuint") int renderbuffer); + + // --- [ glGetFramebufferAttachmentParameterivEXT ] --- + + public static native void nglGetFramebufferAttachmentParameterivEXT(int target, int attachment, int pname, long params); + + public static void glGetFramebufferAttachmentParameterivEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int attachment, @NativeType("GLenum") int pname, @NativeType("GLint *") IntBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetFramebufferAttachmentParameterivEXT(target, attachment, pname, memAddress(params)); + } + + @NativeType("void") + public static int glGetFramebufferAttachmentParameteriEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int attachment, @NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer params = stack.callocInt(1); + nglGetFramebufferAttachmentParameterivEXT(target, attachment, pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGenerateMipmapEXT ] --- + + public static native void glGenerateMipmapEXT(@NativeType("GLenum") int target); + + /** Array version of: {@link #glDeleteRenderbuffersEXT DeleteRenderbuffersEXT} */ + public static void glDeleteRenderbuffersEXT(@NativeType("GLuint const *") int[] renderbuffers) { + long __functionAddress = GL.getICD().glDeleteRenderbuffersEXT; + if (CHECKS) { + check(__functionAddress); + } + callPV(renderbuffers.length, renderbuffers, __functionAddress); + } + + /** Array version of: {@link #glGenRenderbuffersEXT GenRenderbuffersEXT} */ + public static void glGenRenderbuffersEXT(@NativeType("GLuint *") int[] renderbuffers) { + long __functionAddress = GL.getICD().glGenRenderbuffersEXT; + if (CHECKS) { + check(__functionAddress); + } + callPV(renderbuffers.length, renderbuffers, __functionAddress); + } + + /** Array version of: {@link #glGetRenderbufferParameterivEXT GetRenderbufferParameterivEXT} */ + public static void glGetRenderbufferParameterivEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] params) { + long __functionAddress = GL.getICD().glGetRenderbufferParameterivEXT; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(target, pname, params, __functionAddress); + } + + /** Array version of: {@link #glDeleteFramebuffersEXT DeleteFramebuffersEXT} */ + public static void glDeleteFramebuffersEXT(@NativeType("GLuint const *") int[] framebuffers) { + long __functionAddress = GL.getICD().glDeleteFramebuffersEXT; + if (CHECKS) { + check(__functionAddress); + } + callPV(framebuffers.length, framebuffers, __functionAddress); + } + + /** Array version of: {@link #glGenFramebuffersEXT GenFramebuffersEXT} */ + public static void glGenFramebuffersEXT(@NativeType("GLuint *") int[] framebuffers) { + long __functionAddress = GL.getICD().glGenFramebuffersEXT; + if (CHECKS) { + check(__functionAddress); + } + callPV(framebuffers.length, framebuffers, __functionAddress); + } + + /** Array version of: {@link #glGetFramebufferAttachmentParameterivEXT GetFramebufferAttachmentParameterivEXT} */ + public static void glGetFramebufferAttachmentParameterivEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int attachment, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] params) { + long __functionAddress = GL.getICD().glGetFramebufferAttachmentParameterivEXT; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(target, attachment, pname, params, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTFramebufferSRGB.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTFramebufferSRGB.java new file mode 100644 index 00000000..5ce5d0d9 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTFramebufferSRGB.java @@ -0,0 +1,42 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_framebuffer_sRGB extension. + * + *Conventionally, OpenGL assumes framebuffer color components are stored in a linear color space. In particular, framebuffer blending is a linear + * operation.
+ * + *The sRGB color space is based on typical (non-linear) monitor characteristics expected in a dimly lit office. It has been standardized by the + * International Electrotechnical Commission (IEC) as IEC 61966-2-1. The sRGB color space roughly corresponds to 2.2 gamma correction.
+ * + *This extension adds a framebuffer capability for sRGB framebuffer update and blending. When blending is disabled but the new sRGB updated mode is + * enabled (assume the framebuffer supports the capability), high-precision linear color component values for red, green, and blue generated by fragment + * coloring are encoded for sRGB prior to being written into the framebuffer. When blending is enabled along with the new sRGB update mode, red, green, and + * blue framebuffer color components are treated as sRGB values that are converted to linear color values, blended with the high-precision color values + * generated by fragment coloring, and then the blend result is encoded for sRGB just prior to being written into the framebuffer.
+ * + *The primary motivation for this extension is that it allows OpenGL applications to render into a framebuffer that is scanned to a monitor configured to + * assume framebuffer color values are sRGB encoded. This assumption is roughly true of most PC monitors with default gamma correction. This allows + * applications to achieve faithful color reproduction for OpenGL rendering without adjusting the monitor's gamma correction.
+ * + *Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public final class EXTFramebufferSRGB { + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_FRAMEBUFFER_SRGB_EXT = 0x8DB9; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x8DBA; + + private EXTFramebufferSRGB() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTGPUProgramParameters.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTGPUProgramParameters.java new file mode 100644 index 00000000..4b46f910 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTGPUProgramParameters.java @@ -0,0 +1,74 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_gpu_program_parameters extension. + * + *This extension provides a new set of procedures to load multiple consecutive program environment parameters more efficiently, via a single GL call + * instead of multiple calls. This will reduce the amount of CPU overhead involved in loading parameters.
+ * + *With the existing ARB_vertex_program and ARB_fragment_program APIs, program parameters must be loaded one at a time, via separate calls. While the + * NV_vertex_program extension provides a set of similar functions that can be used to load program environment parameters (which are equivalent to + * "program parameters" in NV_vertex_program), no such function exists for program local parameters.
+ */ +public class EXTGPUProgramParameters { + + static { GL.initialize(); } + + protected EXTGPUProgramParameters() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glProgramEnvParameters4fvEXT, caps.glProgramLocalParameters4fvEXT + ); + } + + // --- [ glProgramEnvParameters4fvEXT ] --- + + public static native void nglProgramEnvParameters4fvEXT(int target, int index, int count, long params); + + public static void glProgramEnvParameters4fvEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLfloat const *") FloatBuffer params) { + nglProgramEnvParameters4fvEXT(target, index, params.remaining() >> 2, memAddress(params)); + } + + // --- [ glProgramLocalParameters4fvEXT ] --- + + public static native void nglProgramLocalParameters4fvEXT(int target, int index, int count, long params); + + public static void glProgramLocalParameters4fvEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLfloat const *") FloatBuffer params) { + nglProgramLocalParameters4fvEXT(target, index, params.remaining() >> 2, memAddress(params)); + } + + /** Array version of: {@link #glProgramEnvParameters4fvEXT ProgramEnvParameters4fvEXT} */ + public static void glProgramEnvParameters4fvEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLfloat const *") float[] params) { + long __functionAddress = GL.getICD().glProgramEnvParameters4fvEXT; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, index, params.length >> 2, params, __functionAddress); + } + + /** Array version of: {@link #glProgramLocalParameters4fvEXT ProgramLocalParameters4fvEXT} */ + public static void glProgramLocalParameters4fvEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLfloat const *") float[] params) { + long __functionAddress = GL.getICD().glProgramLocalParameters4fvEXT; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, index, params.length >> 2, params, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTGPUShader4.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTGPUShader4.java new file mode 100644 index 00000000..7787f5f8 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTGPUShader4.java @@ -0,0 +1,874 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_gpu_shader4 extension. + * + *This extension provides a set of new features to the OpenGL Shading Language and related APIs to support capabilities of new hardware. In particular, + * this extension provides the following functionality:
+ * + *This extension also briefly mentions a new shader type, called a geometry shader. A geometry shader is run after vertices are transformed, but before + * clipping. A geometry shader begins with a single primitive (point, line, triangle. It can read the attributes of any of the vertices in the primitive + * and use them to generate new primitives. A geometry shader has a fixed output primitive type (point, line strip, or triangle strip) and emits vertices + * to define a new primitive. Geometry shaders are discussed in detail in the GL_EXT_geometry_shader4 specification.
+ * + *Requires {@link GL20 OpenGL 2.0}.
+ */ +public class EXTGPUShader4 { + + /** Accepted by the {@code pname} parameters of GetVertexAttribdv, GetVertexAttribfv, GetVertexAttribiv, GetVertexAttribIuivEXT and GetVertexAttribIivEXT. */ + public static final int GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT = 0x88FD; + + /** Returned by the {@code type} parameter of GetActiveUniform. */ + public static final int + GL_SAMPLER_1D_ARRAY_EXT = 0x8DC0, + GL_SAMPLER_2D_ARRAY_EXT = 0x8DC1, + GL_SAMPLER_BUFFER_EXT = 0x8DC2, + GL_SAMPLER_1D_ARRAY_SHADOW_EXT = 0x8DC3, + GL_SAMPLER_2D_ARRAY_SHADOW_EXT = 0x8DC4, + GL_SAMPLER_CUBE_SHADOW_EXT = 0x8DC5, + GL_UNSIGNED_INT_VEC2_EXT = 0x8DC6, + GL_UNSIGNED_INT_VEC3_EXT = 0x8DC7, + GL_UNSIGNED_INT_VEC4_EXT = 0x8DC8, + GL_INT_SAMPLER_1D_EXT = 0x8DC9, + GL_INT_SAMPLER_2D_EXT = 0x8DCA, + GL_INT_SAMPLER_3D_EXT = 0x8DCB, + GL_INT_SAMPLER_CUBE_EXT = 0x8DCC, + GL_INT_SAMPLER_2D_RECT_EXT = 0x8DCD, + GL_INT_SAMPLER_1D_ARRAY_EXT = 0x8DCE, + GL_INT_SAMPLER_2D_ARRAY_EXT = 0x8DCF, + GL_INT_SAMPLER_BUFFER_EXT = 0x8DD0, + GL_UNSIGNED_INT_SAMPLER_1D_EXT = 0x8DD1, + GL_UNSIGNED_INT_SAMPLER_2D_EXT = 0x8DD2, + GL_UNSIGNED_INT_SAMPLER_3D_EXT = 0x8DD3, + GL_UNSIGNED_INT_SAMPLER_CUBE_EXT = 0x8DD4, + GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = 0x8DD5, + GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = 0x8DD6, + GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = 0x8DD7, + GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = 0x8DD8; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_MIN_PROGRAM_TEXEL_OFFSET_EXT = 0x8904, + GL_MAX_PROGRAM_TEXEL_OFFSET_EXT = 0x8905; + + static { GL.initialize(); } + + protected EXTGPUShader4() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glVertexAttribI1iEXT, caps.glVertexAttribI2iEXT, caps.glVertexAttribI3iEXT, caps.glVertexAttribI4iEXT, caps.glVertexAttribI1uiEXT, + caps.glVertexAttribI2uiEXT, caps.glVertexAttribI3uiEXT, caps.glVertexAttribI4uiEXT, caps.glVertexAttribI1ivEXT, caps.glVertexAttribI2ivEXT, + caps.glVertexAttribI3ivEXT, caps.glVertexAttribI4ivEXT, caps.glVertexAttribI1uivEXT, caps.glVertexAttribI2uivEXT, caps.glVertexAttribI3uivEXT, + caps.glVertexAttribI4uivEXT, caps.glVertexAttribI4bvEXT, caps.glVertexAttribI4svEXT, caps.glVertexAttribI4ubvEXT, caps.glVertexAttribI4usvEXT, + caps.glVertexAttribIPointerEXT, caps.glGetVertexAttribIivEXT, caps.glGetVertexAttribIuivEXT, caps.glGetUniformuivEXT, + caps.glBindFragDataLocationEXT, caps.glGetFragDataLocationEXT, caps.glUniform1uiEXT, caps.glUniform2uiEXT, caps.glUniform3uiEXT, + caps.glUniform4uiEXT, caps.glUniform1uivEXT, caps.glUniform2uivEXT, caps.glUniform3uivEXT, caps.glUniform4uivEXT + ); + } + + // --- [ glVertexAttribI1iEXT ] --- + + /** + * Specifies the value of a pure integer generic vertex attribute. The y and z components are implicitly set to 0 and w to 1. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param x the vertex attribute x component + */ + public static native void glVertexAttribI1iEXT(@NativeType("GLuint") int index, @NativeType("GLint") int x); + + // --- [ glVertexAttribI2iEXT ] --- + + /** + * Specifies the value of a pure integer generic vertex attribute. The z component is implicitly set to 0 and w to 1. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param x the vertex attribute x component + * @param y the vertex attribute y component + */ + public static native void glVertexAttribI2iEXT(@NativeType("GLuint") int index, @NativeType("GLint") int x, @NativeType("GLint") int y); + + // --- [ glVertexAttribI3iEXT ] --- + + /** + * Specifies the value of a pure integer generic vertex attribute. The w component is implicitly set to 1. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param x the vertex attribute x component + * @param y the vertex attribute y component + * @param z the vertex attribute z component + */ + public static native void glVertexAttribI3iEXT(@NativeType("GLuint") int index, @NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLint") int z); + + // --- [ glVertexAttribI4iEXT ] --- + + /** + * Specifies the value of a pure integer generic vertex attribute. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param x the vertex attribute x component + * @param y the vertex attribute y component + * @param z the vertex attribute z component + * @param w the vertex attribute w component + */ + public static native void glVertexAttribI4iEXT(@NativeType("GLuint") int index, @NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLint") int z, @NativeType("GLint") int w); + + // --- [ glVertexAttribI1uiEXT ] --- + + /** + * Specifies the value of an unsigned pure integer generic vertex attribute. The y and z components are implicitly set to 0 and w to 1. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param x the vertex attribute x component + */ + public static native void glVertexAttribI1uiEXT(@NativeType("GLuint") int index, @NativeType("GLuint") int x); + + // --- [ glVertexAttribI2uiEXT ] --- + + /** + * Specifies the value of an unsigned pure integer generic vertex attribute. The z component is implicitly set to 0 and w to 1. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param x the vertex attribute x component + * @param y the vertex attribute y component + */ + public static native void glVertexAttribI2uiEXT(@NativeType("GLuint") int index, @NativeType("GLuint") int x, @NativeType("GLuint") int y); + + // --- [ glVertexAttribI3uiEXT ] --- + + /** + * Specifies the value of an unsigned pure integer generic vertex attribute. The w component is implicitly set to 1. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param x the vertex attribute x component + * @param y the vertex attribute y component + * @param z the vertex attribute z component + */ + public static native void glVertexAttribI3uiEXT(@NativeType("GLuint") int index, @NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLint") int z); + + // --- [ glVertexAttribI4uiEXT ] --- + + /** + * Specifies the value of an unsigned pure integer generic vertex attribute. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param x the vertex attribute x component + * @param y the vertex attribute y component + * @param z the vertex attribute z component + * @param w the vertex attribute w component + */ + public static native void glVertexAttribI4uiEXT(@NativeType("GLuint") int index, @NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLint") int z, @NativeType("GLint") int w); + + // --- [ glVertexAttribI1ivEXT ] --- + + /** Unsafe version of: {@link #glVertexAttribI1ivEXT VertexAttribI1ivEXT} */ + public static native void nglVertexAttribI1ivEXT(int index, long v); + + /** + * Pointer version of {@link #glVertexAttribI1iEXT VertexAttribI1iEXT}. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param v the pure integer vertex attribute buffer + */ + public static void glVertexAttribI1ivEXT(@NativeType("GLuint") int index, @NativeType("GLint const *") IntBuffer v) { + if (CHECKS) { + check(v, 1); + } + nglVertexAttribI1ivEXT(index, memAddress(v)); + } + + // --- [ glVertexAttribI2ivEXT ] --- + + /** Unsafe version of: {@link #glVertexAttribI2ivEXT VertexAttribI2ivEXT} */ + public static native void nglVertexAttribI2ivEXT(int index, long v); + + /** + * Pointer version of {@link #glVertexAttribI2iEXT VertexAttribI2iEXT}. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param v the pure integer vertex attribute buffer + */ + public static void glVertexAttribI2ivEXT(@NativeType("GLuint") int index, @NativeType("GLint const *") IntBuffer v) { + if (CHECKS) { + check(v, 2); + } + nglVertexAttribI2ivEXT(index, memAddress(v)); + } + + // --- [ glVertexAttribI3ivEXT ] --- + + /** Unsafe version of: {@link #glVertexAttribI3ivEXT VertexAttribI3ivEXT} */ + public static native void nglVertexAttribI3ivEXT(int index, long v); + + /** + * Pointer version of {@link #glVertexAttribI3iEXT VertexAttribI3iEXT}. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param v the pure integer vertex attribute buffer + */ + public static void glVertexAttribI3ivEXT(@NativeType("GLuint") int index, @NativeType("GLint const *") IntBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglVertexAttribI3ivEXT(index, memAddress(v)); + } + + // --- [ glVertexAttribI4ivEXT ] --- + + /** Unsafe version of: {@link #glVertexAttribI4ivEXT VertexAttribI4ivEXT} */ + public static native void nglVertexAttribI4ivEXT(int index, long v); + + /** + * Pointer version of {@link #glVertexAttribI4iEXT VertexAttribI4iEXT}. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param v the pure integer vertex attribute buffer + */ + public static void glVertexAttribI4ivEXT(@NativeType("GLuint") int index, @NativeType("GLint const *") IntBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttribI4ivEXT(index, memAddress(v)); + } + + // --- [ glVertexAttribI1uivEXT ] --- + + /** Unsafe version of: {@link #glVertexAttribI1uivEXT VertexAttribI1uivEXT} */ + public static native void nglVertexAttribI1uivEXT(int index, long v); + + /** + * Pointer version of {@link #glVertexAttribI1uiEXT VertexAttribI1uiEXT}. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param v the pure integer vertex attribute buffer + */ + public static void glVertexAttribI1uivEXT(@NativeType("GLuint") int index, @NativeType("GLuint const *") IntBuffer v) { + if (CHECKS) { + check(v, 1); + } + nglVertexAttribI1uivEXT(index, memAddress(v)); + } + + // --- [ glVertexAttribI2uivEXT ] --- + + /** Unsafe version of: {@link #glVertexAttribI2uivEXT VertexAttribI2uivEXT} */ + public static native void nglVertexAttribI2uivEXT(int index, long v); + + /** + * Pointer version of {@link #glVertexAttribI2uiEXT VertexAttribI2uiEXT}. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param v the pure integer vertex attribute buffer + */ + public static void glVertexAttribI2uivEXT(@NativeType("GLuint") int index, @NativeType("GLuint const *") IntBuffer v) { + if (CHECKS) { + check(v, 2); + } + nglVertexAttribI2uivEXT(index, memAddress(v)); + } + + // --- [ glVertexAttribI3uivEXT ] --- + + /** Unsafe version of: {@link #glVertexAttribI3uivEXT VertexAttribI3uivEXT} */ + public static native void nglVertexAttribI3uivEXT(int index, long v); + + /** + * Pointer version of {@link #glVertexAttribI3uiEXT VertexAttribI3uiEXT}. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param v the pure integer vertex attribute buffer + */ + public static void glVertexAttribI3uivEXT(@NativeType("GLuint") int index, @NativeType("GLuint const *") IntBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglVertexAttribI3uivEXT(index, memAddress(v)); + } + + // --- [ glVertexAttribI4uivEXT ] --- + + /** Unsafe version of: {@link #glVertexAttribI4uivEXT VertexAttribI4uivEXT} */ + public static native void nglVertexAttribI4uivEXT(int index, long v); + + /** + * Pointer version of {@link #glVertexAttribI4uiEXT VertexAttribI4uiEXT}. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param v the pure integer vertex attribute buffer + */ + public static void glVertexAttribI4uivEXT(@NativeType("GLuint") int index, @NativeType("GLuint const *") IntBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttribI4uivEXT(index, memAddress(v)); + } + + // --- [ glVertexAttribI4bvEXT ] --- + + /** Unsafe version of: {@link #glVertexAttribI4bvEXT VertexAttribI4bvEXT} */ + public static native void nglVertexAttribI4bvEXT(int index, long v); + + /** + * Byte version of {@link #glVertexAttribI4ivEXT VertexAttribI4ivEXT}. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param v the pure integer vertex attribute buffer + */ + public static void glVertexAttribI4bvEXT(@NativeType("GLuint") int index, @NativeType("GLbyte const *") ByteBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttribI4bvEXT(index, memAddress(v)); + } + + // --- [ glVertexAttribI4svEXT ] --- + + /** Unsafe version of: {@link #glVertexAttribI4svEXT VertexAttribI4svEXT} */ + public static native void nglVertexAttribI4svEXT(int index, long v); + + /** + * Short version of {@link #glVertexAttribI4ivEXT VertexAttribI4ivEXT}. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param v the pure integer vertex attribute buffer + */ + public static void glVertexAttribI4svEXT(@NativeType("GLuint") int index, @NativeType("GLshort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttribI4svEXT(index, memAddress(v)); + } + + // --- [ glVertexAttribI4ubvEXT ] --- + + /** Unsafe version of: {@link #glVertexAttribI4ubvEXT VertexAttribI4ubvEXT} */ + public static native void nglVertexAttribI4ubvEXT(int index, long v); + + /** + * Byte version of {@link #glVertexAttribI4uivEXT VertexAttribI4uivEXT}. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param v the pure integer vertex attribute buffer + */ + public static void glVertexAttribI4ubvEXT(@NativeType("GLuint") int index, @NativeType("GLbyte const *") ByteBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttribI4ubvEXT(index, memAddress(v)); + } + + // --- [ glVertexAttribI4usvEXT ] --- + + /** Unsafe version of: {@link #glVertexAttribI4usvEXT VertexAttribI4usvEXT} */ + public static native void nglVertexAttribI4usvEXT(int index, long v); + + /** + * Short version of {@link #glVertexAttribI4uivEXT VertexAttribI4uivEXT}. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param v the pure integer vertex attribute buffer + */ + public static void glVertexAttribI4usvEXT(@NativeType("GLuint") int index, @NativeType("GLshort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglVertexAttribI4usvEXT(index, memAddress(v)); + } + + // --- [ glVertexAttribIPointerEXT ] --- + + /** Unsafe version of: {@link #glVertexAttribIPointerEXT VertexAttribIPointerEXT} */ + public static native void nglVertexAttribIPointerEXT(int index, int size, int type, int stride, long pointer); + + /** + * Specifies the location and organization of a pure integer vertex attribute array. + * + * @param index the index of the pure integer generic vertex attribute to be modified + * @param size the number of values per vertex that are stored in the array. The initial value is 4. One of:| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
EXT_geometry_shader4 defines a new shader type available to be run on the GPU, called a geometry shader. Geometry shaders are run after vertices are + * transformed, but prior to color clamping, flat shading and clipping.
+ * + *A geometry shader begins with a single primitive (point, line, triangle). It can read the attributes of any of the vertices in the primitive and use + * them to generate new primitives. A geometry shader has a fixed output primitive type (point, line strip, or triangle strip) and emits vertices to + * define a new primitive. A geometry shader can emit multiple disconnected primitives. The primitives emitted by the geometry shader are clipped and then + * processed like an equivalent OpenGL primitive specified by the application.
+ * + *Furthermore, EXT_geometry_shader4 provides four additional primitive types: lines with adjacency, line strips with adjacency, separate triangles with + * adjacency, and triangle strips with adjacency. Some of the vertices specified in these new primitive types are not part of the ordinary primitives, + * instead they represent neighboring vertices that are adjacent to the two line segment end points (lines/strips) or the three triangle edges + * (triangles/tstrips). These vertices can be accessed by geometry shaders and used to match up the vertices emitted by the geometry shader with those of + * neighboring primitives.
+ * + *Since geometry shaders expect a specific input primitive type, an error will occur if the application presents primitives of a different type. For + * example, if a geometry shader expects points, an error will occur at Begin() time, if a primitive mode of TRIANGLES is specified.
+ */ +public class EXTGeometryShader4 { + + /** Accepted by the {@code type} parameter of CreateShader and returned by the {@code params} parameter of GetShaderiv. */ + public static final int GL_GEOMETRY_SHADER_EXT = 0x8DD9; + + /** Accepted by the {@code pname} parameter of ProgramParameteriEXT and GetProgramiv. */ + public static final int + GL_GEOMETRY_VERTICES_OUT_EXT = 0x8DDA, + GL_GEOMETRY_INPUT_TYPE_EXT = 0x8DDB, + GL_GEOMETRY_OUTPUT_TYPE_EXT = 0x8DDC; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = 0x8C29, + GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = 0x8DDD, + GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = 0x8DDE, + GL_MAX_VARYING_COMPONENTS_EXT = 0x8B4B, + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8DDF, + GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = 0x8DE0, + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8DE1; + + /** Accepted by the {@code mode} parameter of Begin, DrawArrays, MultiDrawArrays, DrawElements, MultiDrawElements, and DrawRangeElements. */ + public static final int + GL_LINES_ADJACENCY_EXT = 0xA, + GL_LINE_STRIP_ADJACENCY_EXT = 0xB, + GL_TRIANGLES_ADJACENCY_EXT = 0xC, + GL_TRIANGLE_STRIP_ADJACENCY_EXT = 0xD; + + /** Returned by CheckFramebufferStatusEXT. */ + public static final int + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = 0x8DA8, + GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = 0x8DA9; + + /** Accepted by the {@code pname} parameter of GetFramebufferAttachment- ParameterivEXT. */ + public static final int + GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = 0x8DA7, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 0x8CD4; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetIntegerv, GetFloatv, GetDoublev, and + * GetBooleanv. + */ + public static final int GL_PROGRAM_POINT_SIZE_EXT = 0x8642; + + static { GL.initialize(); } + + protected EXTGeometryShader4() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glProgramParameteriEXT, caps.glFramebufferTextureEXT, caps.glFramebufferTextureLayerEXT, caps.glFramebufferTextureFaceEXT + ); + } + + // --- [ glProgramParameteriEXT ] --- + + public static native void glProgramParameteriEXT(@NativeType("GLuint") int program, @NativeType("GLenum") int pname, @NativeType("GLint") int value); + + // --- [ glFramebufferTextureEXT ] --- + + public static native void glFramebufferTextureEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int attachment, @NativeType("GLuint") int texture, @NativeType("GLint") int level); + + // --- [ glFramebufferTextureLayerEXT ] --- + + public static void glFramebufferTextureLayerEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int attachment, @NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLint") int layer) { + EXTTextureArray.glFramebufferTextureLayerEXT(target, attachment, texture, level, layer); + } + + // --- [ glFramebufferTextureFaceEXT ] --- + + public static native void glFramebufferTextureFaceEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int attachment, @NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLenum") int face); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTMemoryObject.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTMemoryObject.java new file mode 100644 index 00000000..27fcbab3 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTMemoryObject.java @@ -0,0 +1,286 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_memory_object extension. + * + *The Vulkan API introduces the concept of explicit memory objects and reusable synchronization objects. This extension brings those concepts to the + * OpenGL API via two new object types:
+ * + *Rather than allocating memory as a response to object allocation, memory allocation and binding are two separate operations in Vulkan. This extension + * allows an OpenGL application to import a Vulkan memory object, and to bind textures and/or buffer objects to it.
+ * + *No methods to import memory objects are defined here. Separate platform-specific extensions are defined for this purpose.
+ * + *Semaphores are synchronization primitives that can be waited on and signaled only by the GPU, or in GL terms, in the GL server. They are similar in + * concept to GL's "sync" objects and EGL's "EGLSync" objects, but different enough that compatibilities between the two are difficult to derive.
+ * + *Rather than attempt to map Vulkan semaphores on to GL/EGL sync objects to achieve interoperability, this extension introduces a new object, GL + * semaphores, that map directly to the semantics of Vulkan semaphores. To achieve full image and buffer memory coherence with a Vulkan driver, the + * commands that manipulate semaphores also allow external usage information to be imported and exported.
+ * + *Requires {@link GL42 OpenGL 4.2} or {@link ARBTextureStorage ARB_texture_storage}.
+ */ +public class EXTMemoryObject { + + /** + * Accepted by the {@code pname} parameter of TexParameter{ifx}{v}, TexParameterI{i ui}v, TextureParameter{if}{v}, TextureParameterI{i ui}v, + * GetTexParameter{if}v, GetTexParameterI{i ui}v, GetTextureParameter{if}v, and GetTextureParameterI{i ui}v. + */ + public static final int GL_TEXTURE_TILING_EXT = 0x9580; + + /** Accepted by the {@code pname} parameter of {@link #glMemoryObjectParameterivEXT MemoryObjectParameterivEXT}, and {@link #glGetMemoryObjectParameterivEXT GetMemoryObjectParameterivEXT}. */ + public static final int GL_DEDICATED_MEMORY_OBJECT_EXT = 0x9581; + + /** Accepted by the {@code pname} parameter of GetInternalFormativ or GetInternalFormati64v. */ + public static final int + GL_NUM_TILING_TYPES_EXT = 0x9582, + GL_TILING_TYPES_EXT = 0x9583; + + /** + * Returned in the {@code params} parameter of GetInternalFormativ or GetInternalFormati64v when the {@code pname} parameter is {@link #GL_TILING_TYPES_EXT TILING_TYPES_EXT}, + * returned in the {@code params} parameter of GetTexParameter{if}v, GetTexParameterI{i ui}v, GetTextureParameter{if}v, and GetTextureParameterI{i ui}v + * when the {@code pname} parameter is {@link #GL_TEXTURE_TILING_EXT TEXTURE_TILING_EXT}, and accepted by the {@code params} parameter of TexParameter{ifx}{v}, TexParameterI{i ui}v, + * TextureParameter{if}{v}, TextureParameterI{i ui}v when the {@code pname} parameter is {@link #GL_TEXTURE_TILING_EXT TEXTURE_TILING_EXT}. + */ + public static final int + GL_OPTIMAL_TILING_EXT = 0x9584, + GL_LINEAR_TILING_EXT = 0x9585; + + /** + * Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetFloatv, GetIntegerv, GetInteger64v, {@link #glGetUnsignedBytevEXT GetUnsignedBytevEXT}, and the + * {@code target} parameter of GetBooleani_v, GetIntegeri_v,GetFloati_v, GetDoublei_v, GetInteger64i_v, and {@link #glGetUnsignedBytei_vEXT GetUnsignedBytei_vEXT}. + */ + public static final int + GL_NUM_DEVICE_UUIDS_EXT = 0x9596, + GL_DEVICE_UUID_EXT = 0x9597, + GL_DRIVER_UUID_EXT = 0x9598; + + /** Constant values. */ + public static final int GL_UUID_SIZE_EXT = 16; + + static { GL.initialize(); } + + protected EXTMemoryObject() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetBuilding upon the OpenGL memory object and semaphore framework defined in EXT_external_objects this extension enables an OpenGL + * application to import a memory object or semaphore from POSIX file descriptor external handles.
+ * + *Requires {@link EXTMemoryObject EXT_memory_object} and {@link ARBTextureStorage ARB_texture_storage} or a version of OpenGL that incorporates it.
+ */ +public class EXTMemoryObjectFD { + + /** Accepted by the {@code handleType} parameter of {@link #glImportMemoryFdEXT ImportMemoryFdEXT} */ + public static final int GL_HANDLE_TYPE_OPAQUE_FD_EXT = 0x9586; + + static { GL.initialize(); } + + protected EXTMemoryObjectFD() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glImportMemoryFdEXT + ); + } + + // --- [ glImportMemoryFdEXT ] --- + + public static native void glImportMemoryFdEXT(@NativeType("GLuint") int memory, @NativeType("GLuint64") long size, @NativeType("GLenum") int handleType, @NativeType("GLint") int fd); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTMemoryObjectWin32.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTMemoryObjectWin32.java new file mode 100644 index 00000000..f4377b56 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTMemoryObjectWin32.java @@ -0,0 +1,83 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_memory_object_win32 extension. + * + *Building upon the OpenGL memory object and semaphore framework defined in EXT_external_objects, this extension enables an + * OpenGL application to import a memory object or semaphore from a Win32 NT handle or a KMT share handle.
+ */ +public class EXTMemoryObjectWin32 { + + /** + * Accepted by the {@code handleType} parameter of {@link #glImportMemoryWin32HandleEXT ImportMemoryWin32HandleEXT}, {@link #glImportMemoryWin32NameEXT ImportMemoryWin32NameEXT}, {@link EXTSemaphoreWin32#glImportSemaphoreWin32HandleEXT ImportSemaphoreWin32HandleEXT}, and + * {@link EXTSemaphoreWin32#glImportSemaphoreWin32NameEXT ImportSemaphoreWin32NameEXT}. + */ + public static final int GL_HANDLE_TYPE_OPAQUE_WIN32_EXT = 0x9587; + + /** Accepted by the {@code handleType} parameter of {@link #glImportMemoryWin32HandleEXT ImportMemoryWin32HandleEXT} and {@link EXTSemaphoreWin32#glImportSemaphoreWin32HandleEXT ImportSemaphoreWin32HandleEXT}. */ + public static final int GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT = 0x9588; + + /** + * Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetFloatv, GetIntegerv, GetInteger64v, GetBooleani_v, GetIntegeri_v, GetFloati_v, + * GetDoublei_v, and GetInteger64i_v. + */ + public static final int + GL_DEVICE_LUID_EXT = 0x9599, + GL_DEVICE_NODE_MASK_EXT = 0x959A; + + /** Constant values. */ + public static final int GL_LUID_SIZE_EXT = 8; + + /** Accepted by the {@code handleType} parameter of {@link #glImportMemoryWin32HandleEXT ImportMemoryWin32HandleEXT} and {@link #glImportMemoryWin32NameEXT ImportMemoryWin32NameEXT}. */ + public static final int + GL_HANDLE_TYPE_D3D12_TILEPOOL_EXT = 0x9589, + GL_HANDLE_TYPE_D3D12_RESOURCE_EXT = 0x958A, + GL_HANDLE_TYPE_D3D11_IMAGE_EXT = 0x958B; + + /** Accepted by the {@code handleType} parameter of {@link #glImportMemoryWin32HandleEXT ImportMemoryWin32HandleEXT}. */ + public static final int GL_HANDLE_TYPE_D3D11_IMAGE_KMT_EXT = 0x958C; + + static { GL.initialize(); } + + protected EXTMemoryObjectWin32() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glImportMemoryWin32HandleEXT, caps.glImportMemoryWin32NameEXT + ); + } + + // --- [ glImportMemoryWin32HandleEXT ] --- + + public static native void nglImportMemoryWin32HandleEXT(int memory, long size, int handleType, long handle); + + public static void glImportMemoryWin32HandleEXT(@NativeType("GLuint") int memory, @NativeType("GLuint64") long size, @NativeType("GLenum") int handleType, @NativeType("void *") long handle) { + if (CHECKS) { + check(handle); + } + nglImportMemoryWin32HandleEXT(memory, size, handleType, handle); + } + + // --- [ glImportMemoryWin32NameEXT ] --- + + public static native void nglImportMemoryWin32NameEXT(int memory, long size, int handleType, long name); + + public static void glImportMemoryWin32NameEXT(@NativeType("GLuint") int memory, @NativeType("GLuint64") long size, @NativeType("GLenum") int handleType, @NativeType("void const *") long name) { + if (CHECKS) { + check(name); + } + nglImportMemoryWin32NameEXT(memory, size, handleType, name); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPackedDepthStencil.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPackedDepthStencil.java new file mode 100644 index 00000000..4d637c26 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPackedDepthStencil.java @@ -0,0 +1,84 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_packed_depth_stencil extension. + * + *Many OpenGL implementations have chosen to interleave the depth and stencil buffers into one buffer, often with 24 bits of depth precision and 8 bits + * of stencil data. 32 bits is more than is needed for the depth buffer much of the time; a 24-bit depth buffer, on the other hand, requires that reads + * and writes of depth data be unaligned with respect to power-of-two boundaries. On the other hand, 8 bits of stencil data is more than sufficient for + * most applications, so it is only natural to pack the two buffers into a single buffer with both depth and stencil data. OpenGL never provides direct + * access to the buffers, so the OpenGL implementation can provide an interface to applications where it appears the one merged buffer is composed of two + * logical buffers.
+ * + *One disadvantage of this scheme is that OpenGL lacks any means by which this packed data can be handled efficiently. For example, when an application + * reads from the 24-bit depth buffer, using the type GL_UNSIGNED_SHORT will lose 8 bits of data, while GL_UNSIGNED_INT has 8 too many. Both require + * expensive format conversion operations. A 24-bit format would be no more suitable, because it would also suffer from the unaligned memory accesses that + * made the standalone 24-bit depth buffer an unattractive proposition in the first place.
+ * + *Many applications, such as parallel rendering applications, may also wish to draw to or read back from both the depth and stencil buffers at the same + * time. Currently this requires two separate operations, reducing performance. Since the buffers are interleaved, drawing to or reading from both should + * be no more expensive than using just one; in some cases, it may even be cheaper.
+ * + *This extension provides a new data format, GL_DEPTH_STENCIL_EXT, that can be used with the glDrawPixels, glReadPixels, and glCopyPixels commands, as + * well as a packed data type, GL_UNSIGNED_INT_24_8_EXT, that is meant to be used with GL_DEPTH_STENCIL_EXT. No other data types are supported with + * GL_DEPTH_STENCIL_EXT. If ARB_depth_texture or SGIX_depth_texture is supported, GL_DEPTH_STENCIL_EXT/GL_UNSIGNED_INT_24_8_EXT data can also be used for + * textures; this provides a more efficient way to supply data for a 24-bit depth texture.
+ * + *GL_DEPTH_STENCIL_EXT data, when passed through the pixel path, undergoes both depth and stencil operations. The depth data is scaled and biased by the + * current GL_DEPTH_SCALE and GL_DEPTH_BIAS, while the stencil data is shifted and offset by the current GL_INDEX_SHIFT and GL_INDEX_OFFSET. The stencil + * data is also put through the stencil-to-stencil pixel map.
+ * + *glDrawPixels of GL_DEPTH_STENCIL_EXT data operates similarly to that of GL_STENCIL_INDEX data, bypassing the OpenGL fragment pipeline entirely, unlike + * the treatment of GL_DEPTH_COMPONENT data. The stencil and depth masks are applied, as are the pixel ownership and scissor tests, but all other + * operations are skipped.
+ * + *glReadPixels of GL_DEPTH_STENCIL_EXT data reads back a rectangle from both the depth and stencil buffers.
+ * + *glCopyPixels of GL_DEPTH_STENCIL_EXT data copies a rectangle from both the depth and stencil buffers. Like glDrawPixels, it applies both the stencil + * and depth masks but skips the remainder of the OpenGL fragment pipeline.
+ * + *glTex[Sub]Image[1,2,3]D of GL_DEPTH_STENCIL_EXT data loads depth and stencil data into a depth_stencil texture. glGetTexImage of GL_DEPTH_STENCIL_EXT + * data can be used to retrieve depth and stencil data from a depth/stencil texture.
+ * + *In addition, a new base internal format, GL_DEPTH_STENCIL_EXT, can be used by both texture images and renderbuffer storage. When an image with a + * DEPTH_STENCIL_EXT internal format is attached to both the depth and stencil attachment points of a framebuffer object (see EXT_framebuffer_object), + * then it becomes both the depth and stencil buffers of the framebuffer. This fits nicely with hardware that interleaves both depth and stencil data into + * a single buffer. When a texture with DEPTH_STENCIL_EXT data is bound for texturing, only the depth component is accessible through the texture fetcher. + * The stencil data can be written with TexImage or CopyTexImage, and can be read with GetTexImage. When a DEPTH_STENCIL_EXT image is attached to the + * stencil attachment of the bound framebuffer object, the stencil data can be accessed through any operation that reads from or writes to the + * framebuffer's stencil buffer.
+ * + *Requires {@link EXTFramebufferObject EXT_framebuffer_object}. Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public final class EXTPackedDepthStencil { + + /** + * Accepted by the {@code format} parameter of DrawPixels, ReadPixels, TexImage1D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, and + * GetTexImage, by the {@code type} parameter of CopyPixels, by the {@code internalformat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, + * CopyTexImage2D, and RenderbufferStorageEXT, and returned in the {@code data} parameter of GetTexLevelParameter and GetRenderbufferParameterivEXT. + */ + public static final int GL_DEPTH_STENCIL_EXT = 0x84F9; + + /** + * Accepted by the {@code type} parameter of DrawPixels, ReadPixels, TexImage1D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, and + * GetTexImage. + */ + public static final int GL_UNSIGNED_INT_24_8_EXT = 0x84FA; + + /** + * Accepted by the {@code internalformat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D, and RenderbufferStorageEXT, and + * returned in the {@code data} parameter of GetTexLevelParameter and GetRenderbufferParameterivEXT. + */ + public static final int GL_DEPTH24_STENCIL8_EXT = 0x88F0; + + /** Accepted by the {@code value} parameter of GetTexLevelParameter. */ + public static final int GL_TEXTURE_STENCIL_SIZE_EXT = 0x88F1; + + private EXTPackedDepthStencil() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPackedFloat.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPackedFloat.java new file mode 100644 index 00000000..2231ea6f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPackedFloat.java @@ -0,0 +1,41 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_packed_float extension. + * + *This extension adds a new 3-component floating-point texture format that fits within a single 32-bit word. This format stores 5 bits of biased exponent + * per component in the same manner as 16-bit floating-point formats, but rather than 10 mantissa bits, the red, green, and blue components have 6, 6, and + * 5 bits respectively. Each mantissa is assumed to have an implied leading one except in the denorm exponent case. There is no sign bit so only + * non-negative values can be represented. Positive infinity, positive denorms, and positive NaN values are representable. The value of the fourth + * component returned by a texture fetch is always 1.0.
+ * + *This extension also provides support for rendering into an unsigned floating-point rendering format with the assumption that the texture format + * described above could also be advertised as an unsigned floating-point format for rendering.
+ * + *The extension also provides a pixel external format for specifying packed float values directly.
+ * + *Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public final class EXTPackedFloat { + + /** Accepted by the {@code internalformat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D, and RenderbufferStorageEXT. */ + public static final int GL_R11F_G11F_B10F_EXT = 0x8C3A; + + /** + * Accepted by the {@code type} parameter of DrawPixels, ReadPixels, TexImage1D, TexImage2D, GetTexImage, TexImage3D, TexSubImage1D, TexSubImage2D, + * TexSubImage3D, GetHistogram, GetMinmax, ConvolutionFilter1D, ConvolutionFilter2D, ConvolutionFilter3D, GetConvolutionFilter, SeparableFilter2D, + * GetSeparableFilter, ColorTable, ColorSubTable, and GetColorTable. + */ + public static final int GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = 0x8C3B; + + /** Accepted by the {@code pname} parameters of GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_RGBA_SIGNED_COMPONENTS_EXT = 0x8C3C; + + private EXTPackedFloat() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPixelBufferObject.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPixelBufferObject.java new file mode 100644 index 00000000..06ac8a81 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPixelBufferObject.java @@ -0,0 +1,31 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_pixel_buffer_object extension. + * + *This extension expands on the interface provided by buffer objects. It is intended to permit buffer objects to be used not only with vertex array data, + * but also with pixel data. Buffer objects were promoted from the ARB_vertex_buffer_object extension in OpenGL 1.5.
+ */ +public final class EXTPixelBufferObject { + + /** + * Accepted by the {@code target} parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, GetBufferParameteriv, and + * GetBufferPointerv. + */ + public static final int + GL_PIXEL_PACK_BUFFER_EXT = 0x88EB, + GL_PIXEL_UNPACK_BUFFER_EXT = 0x88EC; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_PIXEL_PACK_BUFFER_BINDING_EXT = 0x88ED, + GL_PIXEL_UNPACK_BUFFER_BINDING_EXT = 0x88EF; + + private EXTPixelBufferObject() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPointParameters.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPointParameters.java new file mode 100644 index 00000000..bc355aeb --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPointParameters.java @@ -0,0 +1,106 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_point_parameters extension. + * + *This extension supports additional geometric characteristics of points. It can be used to render particles or tiny light sources, commonly referred as + * "Light points".
+ * + *The raster brightness of a point is a function of the point area, point color, point transparency, and the response of the display's electron gun and + * phosphor. The point area and the point transparency are derived from the point size, currently provided with the {@code size} parameter of + * {@link GL11C#glPointSize PointSize}.
+ * + *The primary motivation is to allow the size of a point to be affected by distance attenuation. When distance attenuation has an effect, the final point + * size decreases as the distance of the point from the eye increases.
+ * + *The secondary motivation is a mean to control the mapping from the point size to the raster point area and point transparency. This is done in order to + * increase the dynamic range of the raster brightness of points. In other words, the alpha component of a point may be decreased (and its transparency + * increased) as its area shrinks below a defined threshold.
+ * + *This extension defines a derived point size to be closely related to point brightness. The brightness of a point is given by:
+ * + *
+ * 1
+ * dist_atten(d) = -------------------
+ * a + b * d + c * d^2
+ *
+ * brightness(Pe) = Brightness * dist_atten(|Pe|)where 'Pe' is the point in eye coordinates, and 'Brightness' is some initial value proportional to the square of the size provided with glPointSize. + * Here we simplify the raster brightness to be a function of the rasterized point area and point transparency.
+ * + *
+ * brightness(Pe) brightness(Pe) >= Threshold_Area
+ * area(Pe) =
+ * Threshold_Area Otherwise
+ *
+ * factor(Pe) = brightness(Pe)/Threshold_Area
+ *
+ * alpha(Pe) = Alpha * factor(Pe)where 'Alpha' comes with the point color (possibly modified by lighting).
+ * + *'Threshold_Area' above is in area units. Thus, it is proportional to the square of the threshold provided by the programmer through this extension.
+ * + *The new point size derivation method applies to all points, while the threshold applies to multisample points only.
+ */ +public class EXTPointParameters { + + /** Accepted by the {@code pname} parameter of glPointParameterfvEXT, and the {@code pname} of glGet. */ + public static final int + GL_POINT_SIZE_MIN_EXT = 0x8126, + GL_POINT_SIZE_MAX_EXT = 0x8127, + GL_POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128, + GL_DISTANCE_ATTENUATION_EXT = 0x8129; + + static { GL.initialize(); } + + protected EXTPointParameters() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glPointParameterfEXT, caps.glPointParameterfvEXT + ); + } + + // --- [ glPointParameterfEXT ] --- + + public static native void glPointParameterfEXT(@NativeType("GLenum") int pname, @NativeType("GLfloat") float param); + + // --- [ glPointParameterfvEXT ] --- + + public static native void nglPointParameterfvEXT(int pname, long params); + + public static void glPointParameterfvEXT(@NativeType("GLenum") int pname, @NativeType("GLfloat const *") FloatBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglPointParameterfvEXT(pname, memAddress(params)); + } + + /** Array version of: {@link #glPointParameterfvEXT PointParameterfvEXT} */ + public static void glPointParameterfvEXT(@NativeType("GLenum") int pname, @NativeType("GLfloat const *") float[] params) { + long __functionAddress = GL.getICD().glPointParameterfvEXT; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(pname, params, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPolygonOffsetClamp.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPolygonOffsetClamp.java new file mode 100644 index 00000000..00884d4c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTPolygonOffsetClamp.java @@ -0,0 +1,56 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_polygon_offset_clamp extension. + * + *This extension adds a new parameter to the polygon offset function that clamps the calculated offset to a minimum or maximum value. The clamping + * functionality is useful when polygons are nearly parallel to the view direction because their high slopes can result in arbitrarily large polygon + * offsets. In the particular case of shadow mapping, the lack of clamping can produce the appearance of unwanted holes when the shadow casting polygons + * are offset beyond the shadow receiving polygons, and this problem can be alleviated by enforcing a maximum offset value.
+ * + *Requires {@link GL33 OpenGL 3.3}.
+ */ +public class EXTPolygonOffsetClamp { + + /** Accepted by the {@code pname} parameters of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int GL_POLYGON_OFFSET_CLAMP_EXT = 0x8E1B; + + static { GL.initialize(); } + + protected EXTPolygonOffsetClamp() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glPolygonOffsetClampEXT + ); + } + + // --- [ glPolygonOffsetClampEXT ] --- + + /** + * The depth values of all fragments generated by the rasterization of a polygon may be offset by a single value that is computed for that polygon. The + * function that determines this value is specified with this command. + * + *{@code factor} scales the maximum depth slope of the polygon, and {@code units} scales an implementation-dependent constant that relates to the usable + * resolution of the depth buffer. The resulting values are summed to produce the polygon offset value, which may then be clamped to a minimum or maximum + * value specified by {@code clamp}. The values {@code factor}, {@code units}, and {@code clamp} may each be positive, negative, or zero. Calling the + * command {@link GL11C#glPolygonOffset PolygonOffset} is equivalent to calling the command PolygonOffsetClampEXT with {@code clamp} equal to zero.
+ * + * @param factor scales the maximum depth slope of the polygon + * @param units scales an implementation-dependent constant that relates to the usable resolution of the depth buffer + * @param clamp the minimum or maximum clamp value + */ + public static native void glPolygonOffsetClampEXT(@NativeType("GLfloat") float factor, @NativeType("GLfloat") float units, @NativeType("GLfloat") float clamp); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTProvokingVertex.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTProvokingVertex.java new file mode 100644 index 00000000..3a3eacef --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTProvokingVertex.java @@ -0,0 +1,61 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_provoking_vertex extension. + * + *This extension provides an alternative provoking vertex convention for rendering lines, triangles, and (optionally depending on the implementation) + * quads.
+ * + *The provoking vertex of a primitive is the vertex that determines the constant primary and secondary colors when flat shading is enabled.
+ * + *In OpenGL, the provoking vertex for triangle, quad, line, and (trivially) point primitives is the last vertex used to assemble the primitive. The + * polygon primitive is an exception in OpenGL where the first vertex of a polygon primitive determines the color of the polygon, even if actually broken + * into triangles and/or quads.
+ * + *See section 2.14.7 (Flatshading) of the OpenGL 2.1 specification, particularly Table 2.12 for more details.
+ * + *Alternatively the provoking vertex could be the first vertex of the primitive. Other APIs with flat-shading functionality such as Reality Lab and + * Direct3D have adopted the "first vertex of the primitive" convention to determine the provoking vertex. However, these APIs lack quads so do not have a + * defined provoking vertex convention for quads.
+ * + *The motivation for this extension is to allow applications developed for APIs with a "first vertex of the primitive" provoking vertex to be easily + * converted to OpenGL.
+ */ +public class EXTProvokingVertex { + + /** Accepted by the {@code mode} parameter of ProvokingVertexEXT. */ + public static final int + GL_FIRST_VERTEX_CONVENTION_EXT = 0x8E4D, + GL_LAST_VERTEX_CONVENTION_EXT = 0x8E4E; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_PROVOKING_VERTEX_EXT = 0x8E4F, + GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT = 0x8E4C; + + static { GL.initialize(); } + + protected EXTProvokingVertex() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glProvokingVertexEXT + ); + } + + // --- [ glProvokingVertexEXT ] --- + + public static native void glProvokingVertexEXT(@NativeType("GLenum") int mode); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTRasterMultisample.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTRasterMultisample.java new file mode 100644 index 00000000..d5d6c96b --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTRasterMultisample.java @@ -0,0 +1,86 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_raster_multisample extension. + * + *This extension allows rendering to a non-multisample color buffer while rasterizing with more than one sample. The result of rasterization (coverage) + * is available in the {@code gl_SampleMaskIn[]} fragment shader input, multisample rasterization is enabled for all primitives, and several per- fragment + * operations operate at the raster sample rate.
+ * + *When using the functionality provided by this extension, depth, stencil, and depth bounds tests must be disabled, and a multisample draw framebuffer + * must not be used.
+ * + *A fragment's "coverage", or "effective raster samples" is considered to have "N bits" (as opposed to "one bit" corresponding to the single color + * sample) through the fragment shader, in the sample mask output, through the multisample fragment operations and occlusion query, until the coverage is + * finally "reduced" to a single bit in a new "Coverage Reduction" stage that occurs before blending.
+ */ +public class EXTRasterMultisample { + + /** Accepted by the {@code cap} parameter of Enable, Disable, IsEnabled. */ + public static final int GL_RASTER_MULTISAMPLE_EXT = 0x9327; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int + GL_RASTER_SAMPLES_EXT = 0x9328, + GL_MAX_RASTER_SAMPLES_EXT = 0x9329, + GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT = 0x932A, + GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT = 0x932B, + GL_EFFECTIVE_RASTER_SAMPLES_EXT = 0x932C; + + static { GL.initialize(); } + + protected EXTRasterMultisample() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glRasterSamplesEXT + ); + } + + // --- [ glRasterSamplesEXT ] --- + + /** + * Selects the number of samples to be used for rasterization. {@code samples} represents a request for a desired minimum number of samples. Since + * different implementations may support different sample counts, the actual sample pattern used is implementation-dependent. However, the resulting value + * for {@link #GL_RASTER_SAMPLES_EXT RASTER_SAMPLES_EXT} is guaranteed to be greater than or equal to {@code samples} and no more than the next larger sample count supported by the + * implementation. If {@code fixedsamplelocations} is {@link GL11#GL_TRUE TRUE}, identical sample locations will be used for all pixels. The sample locations chosen are a + * function of only the parameters to RasterSamplesEXT and not of any other state. + * + *If {@link #GL_RASTER_MULTISAMPLE_EXT RASTER_MULTISAMPLE_EXT} is enabled, then the sample pattern chosen by RasterSamplesEXT will be used instead of sampling at the center of the pixel. + * The sample locations can be queried with {@link GL32C#glGetMultisamplefv GetMultisamplefv} with a {@code pname} of {@link GL32#GL_SAMPLE_POSITION SAMPLE_POSITION}, similar to normal multisample sample + * locations.
+ * + *The value {@link #GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT MULTISAMPLE_RASTERIZATION_ALLOWED_EXT} is {@link GL11#GL_TRUE TRUE} if {@link GL13#GL_SAMPLE_BUFFERS SAMPLE_BUFFERS} is one or if {@link #GL_RASTER_MULTISAMPLE_EXT RASTER_MULTISAMPLE_EXT} is enabled. The value + * {@link #GL_EFFECTIVE_RASTER_SAMPLES_EXT EFFECTIVE_RASTER_SAMPLES_EXT} is equal to {@link #GL_RASTER_SAMPLES_EXT RASTER_SAMPLES_EXT} if {@link #GL_RASTER_MULTISAMPLE_EXT RASTER_MULTISAMPLE_EXT} is enabled, otherwise is equal to {@link GL13#GL_SAMPLES SAMPLES}.
+ * + *Explicit multisample rasterization can not be used in conjunction with depth, stencil, or depth bounds tests, multisample framebuffers, or if + * {@link #GL_RASTER_SAMPLES_EXT RASTER_SAMPLES_EXT} is zero. If {@link #GL_RASTER_MULTISAMPLE_EXT RASTER_MULTISAMPLE_EXT} is enabled, the error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} will be generated by Draw commands if
+ * + *An {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if {@code samples} is greater than the value of {@link #GL_MAX_RASTER_SAMPLES_EXT MAX_RASTER_SAMPLES_EXT} (the implementation-dependent maximum + * number of samples).
+ * + * @param samples the number of samples to be used for rasterization + * @param fixedsamplelocations if {@link GL11#GL_TRUE TRUE}, identical sample locations will be used for all pixels + */ + public static native void glRasterSamplesEXT(@NativeType("GLuint") int samples, @NativeType("GLboolean") boolean fixedsamplelocations); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSecondaryColor.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSecondaryColor.java new file mode 100644 index 00000000..040cc876 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSecondaryColor.java @@ -0,0 +1,434 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_secondary_color extension. + * + *This extension allows specifying the RGB components of the secondary color used in the Color Sum stage, instead of using the default (0,0,0,0) color. + * It applies only in RGBA mode and when LIGHTING is disabled.
+ */ +public class EXTSecondaryColor { + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_COLOR_SUM_EXT = 0x8458; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_CURRENT_SECONDARY_COLOR_EXT = 0x8459, + GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = 0x845A, + GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = 0x845B, + GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = 0x845C; + + /** Accepted by the {@code pname} parameter of GetPointerv. */ + public static final int GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = 0x845D; + + /** Accepted by the {@code array} parameter of EnableClientState and DisableClientState. */ + public static final int GL_SECONDARY_COLOR_ARRAY_EXT = 0x845E; + + static { GL.initialize(); } + + protected EXTSecondaryColor() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glSecondaryColor3bEXT, caps.glSecondaryColor3sEXT, caps.glSecondaryColor3iEXT, caps.glSecondaryColor3fEXT, caps.glSecondaryColor3dEXT, + caps.glSecondaryColor3ubEXT, caps.glSecondaryColor3usEXT, caps.glSecondaryColor3uiEXT, caps.glSecondaryColor3bvEXT, caps.glSecondaryColor3svEXT, + caps.glSecondaryColor3ivEXT, caps.glSecondaryColor3fvEXT, caps.glSecondaryColor3dvEXT, caps.glSecondaryColor3ubvEXT, caps.glSecondaryColor3usvEXT, + caps.glSecondaryColor3uivEXT, caps.glSecondaryColorPointerEXT + ); + } + + // --- [ glSecondaryColor3bEXT ] --- + + /** + * Sets the R, G, and B components of the current secondary color. + * + * @param red the red component of the current secondary color + * @param green the green component of the current secondary color + * @param blue the blue component of the current secondary color + */ + public static native void glSecondaryColor3bEXT(@NativeType("GLbyte") byte red, @NativeType("GLbyte") byte green, @NativeType("GLbyte") byte blue); + + // --- [ glSecondaryColor3sEXT ] --- + + /** + * Short version of {@link #glSecondaryColor3bEXT SecondaryColor3bEXT} + * + * @param red the red component of the current secondary color + * @param green the green component of the current secondary color + * @param blue the blue component of the current secondary color + */ + public static native void glSecondaryColor3sEXT(@NativeType("GLshort") short red, @NativeType("GLshort") short green, @NativeType("GLshort") short blue); + + // --- [ glSecondaryColor3iEXT ] --- + + /** + * Integer version of {@link #glSecondaryColor3bEXT SecondaryColor3bEXT} + * + * @param red the red component of the current secondary color + * @param green the green component of the current secondary color + * @param blue the blue component of the current secondary color + */ + public static native void glSecondaryColor3iEXT(@NativeType("GLint") int red, @NativeType("GLint") int green, @NativeType("GLint") int blue); + + // --- [ glSecondaryColor3fEXT ] --- + + /** + * Float version of {@link #glSecondaryColor3bEXT SecondaryColor3bEXT} + * + * @param red the red component of the current secondary color + * @param green the green component of the current secondary color + * @param blue the blue component of the current secondary color + */ + public static native void glSecondaryColor3fEXT(@NativeType("GLfloat") float red, @NativeType("GLfloat") float green, @NativeType("GLfloat") float blue); + + // --- [ glSecondaryColor3dEXT ] --- + + /** + * Double version of {@link #glSecondaryColor3bEXT SecondaryColor3bEXT} + * + * @param red the red component of the current secondary color + * @param green the green component of the current secondary color + * @param blue the blue component of the current secondary color + */ + public static native void glSecondaryColor3dEXT(@NativeType("GLdouble") double red, @NativeType("GLdouble") double green, @NativeType("GLdouble") double blue); + + // --- [ glSecondaryColor3ubEXT ] --- + + /** + * Unsigned version of {@link #glSecondaryColor3bEXT SecondaryColor3bEXT} + * + * @param red the red component of the current secondary color + * @param green the green component of the current secondary color + * @param blue the blue component of the current secondary color + */ + public static native void glSecondaryColor3ubEXT(@NativeType("GLubyte") byte red, @NativeType("GLubyte") byte green, @NativeType("GLubyte") byte blue); + + // --- [ glSecondaryColor3usEXT ] --- + + /** + * Unsigned short version of {@link #glSecondaryColor3bEXT SecondaryColor3bEXT} + * + * @param red the red component of the current secondary color + * @param green the green component of the current secondary color + * @param blue the blue component of the current secondary color + */ + public static native void glSecondaryColor3usEXT(@NativeType("GLushort") short red, @NativeType("GLushort") short green, @NativeType("GLushort") short blue); + + // --- [ glSecondaryColor3uiEXT ] --- + + /** + * Unsigned int version of {@link #glSecondaryColor3bEXT SecondaryColor3bEXT} + * + * @param red the red component of the current secondary color + * @param green the green component of the current secondary color + * @param blue the blue component of the current secondary color + */ + public static native void glSecondaryColor3uiEXT(@NativeType("GLint") int red, @NativeType("GLint") int green, @NativeType("GLint") int blue); + + // --- [ glSecondaryColor3bvEXT ] --- + + /** Unsafe version of: {@link #glSecondaryColor3bvEXT SecondaryColor3bvEXT} */ + public static native void nglSecondaryColor3bvEXT(long v); + + /** + * Pointer version of {@link #glSecondaryColor3bEXT SecondaryColor3bEXT}. + * + * @param v the secondary color buffer + */ + public static void glSecondaryColor3bvEXT(@NativeType("GLbyte const *") ByteBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglSecondaryColor3bvEXT(memAddress(v)); + } + + // --- [ glSecondaryColor3svEXT ] --- + + /** Unsafe version of: {@link #glSecondaryColor3svEXT SecondaryColor3svEXT} */ + public static native void nglSecondaryColor3svEXT(long v); + + /** + * Pointer version of {@link #glSecondaryColor3sEXT SecondaryColor3sEXT}. + * + * @param v the secondary color buffer + */ + public static void glSecondaryColor3svEXT(@NativeType("GLshort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglSecondaryColor3svEXT(memAddress(v)); + } + + // --- [ glSecondaryColor3ivEXT ] --- + + /** Unsafe version of: {@link #glSecondaryColor3ivEXT SecondaryColor3ivEXT} */ + public static native void nglSecondaryColor3ivEXT(long v); + + /** + * Pointer version of {@link #glSecondaryColor3iEXT SecondaryColor3iEXT}. + * + * @param v the secondary color buffer + */ + public static void glSecondaryColor3ivEXT(@NativeType("GLint const *") IntBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglSecondaryColor3ivEXT(memAddress(v)); + } + + // --- [ glSecondaryColor3fvEXT ] --- + + /** Unsafe version of: {@link #glSecondaryColor3fvEXT SecondaryColor3fvEXT} */ + public static native void nglSecondaryColor3fvEXT(long v); + + /** + * Pointer version of {@link #glSecondaryColor3fEXT SecondaryColor3fEXT}. + * + * @param v the secondary color buffer + */ + public static void glSecondaryColor3fvEXT(@NativeType("GLfloat const *") FloatBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglSecondaryColor3fvEXT(memAddress(v)); + } + + // --- [ glSecondaryColor3dvEXT ] --- + + /** Unsafe version of: {@link #glSecondaryColor3dvEXT SecondaryColor3dvEXT} */ + public static native void nglSecondaryColor3dvEXT(long v); + + /** + * Pointer version of {@link #glSecondaryColor3dEXT SecondaryColor3dEXT}. + * + * @param v the secondary color buffer + */ + public static void glSecondaryColor3dvEXT(@NativeType("GLdouble const *") DoubleBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglSecondaryColor3dvEXT(memAddress(v)); + } + + // --- [ glSecondaryColor3ubvEXT ] --- + + /** Unsafe version of: {@link #glSecondaryColor3ubvEXT SecondaryColor3ubvEXT} */ + public static native void nglSecondaryColor3ubvEXT(long v); + + /** + * Pointer version of {@link #glSecondaryColor3ubEXT SecondaryColor3ubEXT}. + * + * @param v the secondary color buffer + */ + public static void glSecondaryColor3ubvEXT(@NativeType("GLubyte const *") ByteBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglSecondaryColor3ubvEXT(memAddress(v)); + } + + // --- [ glSecondaryColor3usvEXT ] --- + + /** Unsafe version of: {@link #glSecondaryColor3usvEXT SecondaryColor3usvEXT} */ + public static native void nglSecondaryColor3usvEXT(long v); + + /** + * Pointer version of {@link #glSecondaryColor3usEXT SecondaryColor3usEXT}. + * + * @param v the secondary color buffer + */ + public static void glSecondaryColor3usvEXT(@NativeType("GLushort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglSecondaryColor3usvEXT(memAddress(v)); + } + + // --- [ glSecondaryColor3uivEXT ] --- + + /** Unsafe version of: {@link #glSecondaryColor3uivEXT SecondaryColor3uivEXT} */ + public static native void nglSecondaryColor3uivEXT(long v); + + /** + * Pointer version of {@link #glSecondaryColor3uiEXT SecondaryColor3uiEXT}. + * + * @param v the secondary color buffer + */ + public static void glSecondaryColor3uivEXT(@NativeType("GLuint const *") IntBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglSecondaryColor3uivEXT(memAddress(v)); + } + + // --- [ glSecondaryColorPointerEXT ] --- + + /** Unsafe version of: {@link #glSecondaryColorPointerEXT SecondaryColorPointerEXT} */ + public static native void nglSecondaryColorPointerEXT(int size, int type, int stride, long pointer); + + /** + * Specifies the location and organization of a secondary color array. + * + * @param size the number of values per vertex that are stored in the array, as well as their component ordering. Must be:| 3 |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 3 |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 3 |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 3 |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 3 |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
The Vulkan API introduces the concept of explicit memory objects and reusable synchronization objects. This extension brings those concepts to the + * OpenGL API via two new object types:
+ * + *Rather than allocating memory as a response to object allocation, memory allocation and binding are two separate operations in Vulkan. This extension + * allows an OpenGL application to import a Vulkan memory object, and to bind textures and/or buffer objects to it.
+ * + *No methods to import memory objects are defined here. Separate platform-specific extensions are defined for this purpose.
+ * + *Semaphores are synchronization primitives that can be waited on and signaled only by the GPU, or in GL terms, in the GL server. They are similar in + * concept to GL's "sync" objects and EGL's "EGLSync" objects, but different enough that compatibilities between the two are difficult to derive.
+ * + *Rather than attempt to map Vulkan semaphores on to GL/EGL sync objects to achieve interoperability, this extension introduces a new object, GL + * semaphores, that map directly to the semantics of Vulkan semaphores. To achieve full image and buffer memory coherence with a Vulkan driver, the + * commands that manipulate semaphores also allow external usage information to be imported and exported.
+ */ +public class EXTSemaphore { + + /** + * Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetFloatv, GetIntegerv, GetInteger64v, {@link #glGetUnsignedBytevEXT GetUnsignedBytevEXT}, and the + * {@code target} parameter of GetBooleani_v, GetIntegeri_v,GetFloati_v, GetDoublei_v, GetInteger64i_v, and {@link #glGetUnsignedBytei_vEXT GetUnsignedBytei_vEXT}. + */ + public static final int + GL_NUM_DEVICE_UUIDS_EXT = 0x9596, + GL_DEVICE_UUID_EXT = 0x9597, + GL_DRIVER_UUID_EXT = 0x9598; + + /** Constant values. */ + public static final int GL_UUID_SIZE_EXT = 16; + + /** Accepted by the {@code dstLayouts} parameter of {@link #glSignalSemaphoreEXT SignalSemaphoreEXT} and the {@code srcLayouts} parameter of {@link #glWaitSemaphoreEXT WaitSemaphoreEXT}. */ + public static final int + GL_LAYOUT_GENERAL_EXT = 0x958D, + GL_LAYOUT_COLOR_ATTACHMENT_EXT = 0x958E, + GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT = 0x958F, + GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT = 0x9590, + GL_LAYOUT_SHADER_READ_ONLY_EXT = 0x9591, + GL_LAYOUT_TRANSFER_SRC_EXT = 0x9592, + GL_LAYOUT_TRANSFER_DST_EXT = 0x9593, + GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT = 0x9530, + GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT = 0x9531; + + static { GL.initialize(); } + + protected EXTSemaphore() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetUnsignedBytevEXT, caps.glGetUnsignedBytei_vEXT, caps.glGenSemaphoresEXT, caps.glDeleteSemaphoresEXT, caps.glIsSemaphoreEXT, + caps.glSemaphoreParameterui64vEXT, caps.glGetSemaphoreParameterui64vEXT, caps.glWaitSemaphoreEXT, caps.glSignalSemaphoreEXT + ); + } + + // --- [ glGetUnsignedBytevEXT ] --- + + public static void nglGetUnsignedBytevEXT(int pname, long data) { + EXTMemoryObject.nglGetUnsignedBytevEXT(pname, data); + } + + public static void glGetUnsignedBytevEXT(@NativeType("GLenum") int pname, @NativeType("GLubyte *") ByteBuffer data) { + EXTMemoryObject.glGetUnsignedBytevEXT(pname, data); + } + + // --- [ glGetUnsignedBytei_vEXT ] --- + + public static void nglGetUnsignedBytei_vEXT(int target, int index, long data) { + EXTMemoryObject.nglGetUnsignedBytei_vEXT(target, index, data); + } + + public static void glGetUnsignedBytei_vEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLubyte *") ByteBuffer data) { + EXTMemoryObject.glGetUnsignedBytei_vEXT(target, index, data); + } + + // --- [ glGenSemaphoresEXT ] --- + + public static native void nglGenSemaphoresEXT(int n, long semaphores); + + public static void glGenSemaphoresEXT(@NativeType("GLuint *") IntBuffer semaphores) { + nglGenSemaphoresEXT(semaphores.remaining(), memAddress(semaphores)); + } + + @NativeType("void") + public static int glGenSemaphoresEXT() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer semaphores = stack.callocInt(1); + nglGenSemaphoresEXT(1, memAddress(semaphores)); + return semaphores.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glDeleteSemaphoresEXT ] --- + + public static native void nglDeleteSemaphoresEXT(int n, long semaphores); + + public static void glDeleteSemaphoresEXT(@NativeType("GLuint const *") IntBuffer semaphores) { + nglDeleteSemaphoresEXT(semaphores.remaining(), memAddress(semaphores)); + } + + public static void glDeleteSemaphoresEXT(@NativeType("GLuint const *") int semaphore) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer semaphores = stack.ints(semaphore); + nglDeleteSemaphoresEXT(1, memAddress(semaphores)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glIsSemaphoreEXT ] --- + + @NativeType("GLboolean") + public static native boolean glIsSemaphoreEXT(@NativeType("GLuint") int semaphore); + + // --- [ glSemaphoreParameterui64vEXT ] --- + + public static native void nglSemaphoreParameterui64vEXT(int semaphore, int pname, long params); + + public static void glSemaphoreParameterui64vEXT(@NativeType("GLuint") int semaphore, @NativeType("GLenum") int pname, @NativeType("GLuint64 const *") LongBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglSemaphoreParameterui64vEXT(semaphore, pname, memAddress(params)); + } + + public static void glSemaphoreParameterui64EXT(@NativeType("GLuint") int semaphore, @NativeType("GLenum") int pname, @NativeType("GLuint64 const *") long param) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer params = stack.longs(param); + nglSemaphoreParameterui64vEXT(semaphore, pname, memAddress(params)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetSemaphoreParameterui64vEXT ] --- + + public static native void nglGetSemaphoreParameterui64vEXT(int semaphore, int pname, long params); + + public static void glGetSemaphoreParameterui64vEXT(@NativeType("GLuint") int semaphore, @NativeType("GLenum") int pname, @NativeType("GLuint64 *") LongBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetSemaphoreParameterui64vEXT(semaphore, pname, memAddress(params)); + } + + @NativeType("void") + public static long glGetSemaphoreParameterui64EXT(@NativeType("GLuint") int semaphore, @NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer params = stack.callocLong(1); + nglGetSemaphoreParameterui64vEXT(semaphore, pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glWaitSemaphoreEXT ] --- + + public static native void nglWaitSemaphoreEXT(int semaphore, int numBufferBarriers, long buffers, int numTextureBarriers, long textures, long srcLayouts); + + public static void glWaitSemaphoreEXT(@NativeType("GLuint") int semaphore, @NativeType("GLuint const *") IntBuffer buffers, @NativeType("GLuint const *") IntBuffer textures, @NativeType("GLenum const *") IntBuffer srcLayouts) { + if (CHECKS) { + check(srcLayouts, textures.remaining()); + } + nglWaitSemaphoreEXT(semaphore, buffers.remaining(), memAddress(buffers), textures.remaining(), memAddress(textures), memAddress(srcLayouts)); + } + + // --- [ glSignalSemaphoreEXT ] --- + + public static native void nglSignalSemaphoreEXT(int semaphore, int numBufferBarriers, long buffers, int numTextureBarriers, long textures, long dstLayouts); + + public static void glSignalSemaphoreEXT(@NativeType("GLuint") int semaphore, @NativeType("GLuint const *") IntBuffer buffers, @NativeType("GLuint const *") IntBuffer textures, @NativeType("GLenum const *") IntBuffer dstLayouts) { + if (CHECKS) { + check(dstLayouts, textures.remaining()); + } + nglSignalSemaphoreEXT(semaphore, buffers.remaining(), memAddress(buffers), textures.remaining(), memAddress(textures), memAddress(dstLayouts)); + } + + /** Array version of: {@link #glGenSemaphoresEXT GenSemaphoresEXT} */ + public static void glGenSemaphoresEXT(@NativeType("GLuint *") int[] semaphores) { + long __functionAddress = GL.getICD().glGenSemaphoresEXT; + if (CHECKS) { + check(__functionAddress); + } + callPV(semaphores.length, semaphores, __functionAddress); + } + + /** Array version of: {@link #glDeleteSemaphoresEXT DeleteSemaphoresEXT} */ + public static void glDeleteSemaphoresEXT(@NativeType("GLuint const *") int[] semaphores) { + long __functionAddress = GL.getICD().glDeleteSemaphoresEXT; + if (CHECKS) { + check(__functionAddress); + } + callPV(semaphores.length, semaphores, __functionAddress); + } + + /** Array version of: {@link #glSemaphoreParameterui64vEXT SemaphoreParameterui64vEXT} */ + public static void glSemaphoreParameterui64vEXT(@NativeType("GLuint") int semaphore, @NativeType("GLenum") int pname, @NativeType("GLuint64 const *") long[] params) { + long __functionAddress = GL.getICD().glSemaphoreParameterui64vEXT; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(semaphore, pname, params, __functionAddress); + } + + /** Array version of: {@link #glGetSemaphoreParameterui64vEXT GetSemaphoreParameterui64vEXT} */ + public static void glGetSemaphoreParameterui64vEXT(@NativeType("GLuint") int semaphore, @NativeType("GLenum") int pname, @NativeType("GLuint64 *") long[] params) { + long __functionAddress = GL.getICD().glGetSemaphoreParameterui64vEXT; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(semaphore, pname, params, __functionAddress); + } + + /** Array version of: {@link #glWaitSemaphoreEXT WaitSemaphoreEXT} */ + public static void glWaitSemaphoreEXT(@NativeType("GLuint") int semaphore, @NativeType("GLuint const *") int[] buffers, @NativeType("GLuint const *") int[] textures, @NativeType("GLenum const *") int[] srcLayouts) { + long __functionAddress = GL.getICD().glWaitSemaphoreEXT; + if (CHECKS) { + check(__functionAddress); + check(srcLayouts, textures.length); + } + callPPPV(semaphore, buffers.length, buffers, textures.length, textures, srcLayouts, __functionAddress); + } + + /** Array version of: {@link #glSignalSemaphoreEXT SignalSemaphoreEXT} */ + public static void glSignalSemaphoreEXT(@NativeType("GLuint") int semaphore, @NativeType("GLuint const *") int[] buffers, @NativeType("GLuint const *") int[] textures, @NativeType("GLenum const *") int[] dstLayouts) { + long __functionAddress = GL.getICD().glSignalSemaphoreEXT; + if (CHECKS) { + check(__functionAddress); + check(dstLayouts, textures.length); + } + callPPPV(semaphore, buffers.length, buffers, textures.length, textures, dstLayouts, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSemaphoreFD.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSemaphoreFD.java new file mode 100644 index 00000000..28224f35 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSemaphoreFD.java @@ -0,0 +1,41 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_semaphore_fd extension. + * + *Building upon the OpenGL memory object and semaphore framework defined in EXT_external_objects this extension enables an OpenGL + * application to import a memory object or semaphore from POSIX file descriptor external handles.
+ * + *Requires {@link EXTSemaphore EXT_semaphore} and {@link ARBTextureStorage ARB_texture_storage} or a version of OpenGL that incorporates it.
+ */ +public class EXTSemaphoreFD { + + /** Accepted by the {@code handleType} parameter of {@link #glImportSemaphoreFdEXT ImportSemaphoreFdEXT}. */ + public static final int GL_HANDLE_TYPE_OPAQUE_FD_EXT = 0x9586; + + static { GL.initialize(); } + + protected EXTSemaphoreFD() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glImportSemaphoreFdEXT + ); + } + + // --- [ glImportSemaphoreFdEXT ] --- + + public static native void glImportSemaphoreFdEXT(@NativeType("GLuint") int semaphore, @NativeType("GLenum") int handleType, @NativeType("GLint") int fd); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSemaphoreWin32.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSemaphoreWin32.java new file mode 100644 index 00000000..381c4b24 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSemaphoreWin32.java @@ -0,0 +1,80 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_semaphore_win32 extension. + * + *Building upon the OpenGL memory object and semaphore framework defined in EXT_external_objects, this extension enables an + * OpenGL application to import a memory object or semaphore from a Win32 NT handle or a KMT share handle.
+ */ +public class EXTSemaphoreWin32 { + + /** + * Accepted by the {@code handleType} parameter of {@link EXTMemoryObjectWin32#glImportMemoryWin32HandleEXT ImportMemoryWin32HandleEXT}, {@link EXTMemoryObjectWin32#glImportMemoryWin32NameEXT ImportMemoryWin32NameEXT}, {@link #glImportSemaphoreWin32HandleEXT ImportSemaphoreWin32HandleEXT}, and + * {@link #glImportSemaphoreWin32NameEXT ImportSemaphoreWin32NameEXT}. + */ + public static final int GL_HANDLE_TYPE_OPAQUE_WIN32_EXT = 0x9587; + + /** Accepted by the {@code handleType} parameter of {@link EXTMemoryObjectWin32#glImportMemoryWin32HandleEXT ImportMemoryWin32HandleEXT} and {@link #glImportSemaphoreWin32HandleEXT ImportSemaphoreWin32HandleEXT}. */ + public static final int GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT = 0x9588; + + /** + * Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetFloatv, GetIntegerv, GetInteger64v, GetBooleani_v, GetIntegeri_v, GetFloati_v, + * GetDoublei_v, and GetInteger64i_v. + */ + public static final int + GL_DEVICE_LUID_EXT = 0x9599, + GL_DEVICE_NODE_MASK_EXT = 0x959A; + + /** Constant values. */ + public static final int GL_LUID_SIZE_EXT = 8; + + /** Accepted by the {@code handleType} parameter of {@link #glImportSemaphoreWin32HandleEXT ImportSemaphoreWin32HandleEXT}. */ + public static final int GL_HANDLE_TYPE_D3D12_FENCE_EXT = 0x9594; + + /** Accepted by the {@code pname} parameter of {@link EXTSemaphore#glSemaphoreParameterui64vEXT SemaphoreParameterui64vEXT} and {@link EXTSemaphore#glGetSemaphoreParameterui64vEXT GetSemaphoreParameterui64vEXT}. */ + public static final int GL_D3D12_FENCE_VALUE_EXT = 0x9595; + + static { GL.initialize(); } + + protected EXTSemaphoreWin32() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glImportSemaphoreWin32HandleEXT, caps.glImportSemaphoreWin32NameEXT + ); + } + + // --- [ glImportSemaphoreWin32HandleEXT ] --- + + public static native void nglImportSemaphoreWin32HandleEXT(int semaphore, int handleType, long handle); + + public static void glImportSemaphoreWin32HandleEXT(@NativeType("GLuint") int semaphore, @NativeType("GLenum") int handleType, @NativeType("void *") long handle) { + if (CHECKS) { + check(handle); + } + nglImportSemaphoreWin32HandleEXT(semaphore, handleType, handle); + } + + // --- [ glImportSemaphoreWin32NameEXT ] --- + + public static native void nglImportSemaphoreWin32NameEXT(int semaphore, int handleType, long name); + + public static void glImportSemaphoreWin32NameEXT(@NativeType("GLuint") int semaphore, @NativeType("GLenum") int handleType, @NativeType("void const *") long name) { + if (CHECKS) { + check(name); + } + nglImportSemaphoreWin32NameEXT(semaphore, handleType, name); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSeparateShaderObjects.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSeparateShaderObjects.java new file mode 100644 index 00000000..87067cd0 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSeparateShaderObjects.java @@ -0,0 +1,102 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_separate_shader_objects extension. + * + *rior to this extension, GLSL requires multiple shader domains (vertex, fragment, geometry) to be linked into a single monolithic program object to + * specify a GLSL shader for each domain.
+ * + *While GLSL's monolithic approach has some advantages for optimizing shaders as a unit that span multiple domains, all existing GPU hardware supports + * the more flexible mix-and-match approach.
+ * + *HLSL9, Cg, the prior OpenGL assembly program extensions, and game console programmers favor a more flexible "mix-and-match" approach to specifying + * shaders independently for these different shader domains. Many developers build their shader content around the mix-and-match approach where they can + * use a single vertex shader with multiple fragment shaders (or vice versa).
+ * + *This keep-it-simple extension adapts the "mix-and-match" shader domain model for GLSL so different GLSL program objects can be bound to different + * shader domains.
+ * + *This extension redefines the operation of glUseProgram(GLenum program) to be equivalent to:
+ * + *
+ * glUseShaderProgramEXT(GL_VERTEX_SHADER, program);
+ * glUseShaderProgramEXT(GL_GEOMETRY_SHADER_EXT, program);
+ * glUseShaderProgramEXT(GL_FRAGMENT_SHADER, program);
+ * glActiveProgramEXT(program);You can also call these commands separately to bind each respective domain. The GL_VERTEX_SHADER, GL_GEOMETRY_SHADER_EXT, and GL_FRAGMENT_SHADER tokens + * refer to the conventional vertex, geometry, and fragment domains respectively. glActiveProgramEXT specifies the program that glUniform* commands will + * update.
+ * + *Separate linking creates the possibility that certain output varyings of a shader may go unread by the subsequent shader inputting varyings. In this + * case, the output varyings are simply ignored. It is also possible input varyings from a shader may not be written as output varyings of a preceding + * shader. In this case, the unwritten input varying values are undefined. Implementations are encouraged to zero these undefined input varying values.
+ * + *This extension is a proof-of-concept that separate shader objects can work for GLSL and a response to repeated requests for this functionality. There + * are various loose ends, particularly when dealing with user-defined varyings. The hope is a future extension will improve this situation.
+ * + *Requires {@link GL20 OpenGL 2.0} or {@link ARBShaderObjects ARB_shader_objects}.
+ */ +public class EXTSeparateShaderObjects { + + /** Accepted by {@code type} parameter to GetIntegerv and GetFloatv. */ + public static final int GL_ACTIVE_PROGRAM_EXT = 0x8B8D; + + static { GL.initialize(); } + + protected EXTSeparateShaderObjects() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glUseShaderProgramEXT, caps.glActiveProgramEXT, caps.glCreateShaderProgramEXT + ); + } + + // --- [ glUseShaderProgramEXT ] --- + + public static native void glUseShaderProgramEXT(@NativeType("GLenum") int type, @NativeType("GLuint") int program); + + // --- [ glActiveProgramEXT ] --- + + public static native void glActiveProgramEXT(@NativeType("GLuint") int program); + + // --- [ glCreateShaderProgramEXT ] --- + + public static native int nglCreateShaderProgramEXT(int type, long string); + + @NativeType("GLuint") + public static int glCreateShaderProgramEXT(@NativeType("GLenum") int type, @NativeType("GLchar const *") ByteBuffer string) { + if (CHECKS) { + checkNT1(string); + } + return nglCreateShaderProgramEXT(type, memAddress(string)); + } + + @NativeType("GLuint") + public static int glCreateShaderProgramEXT(@NativeType("GLenum") int type, @NativeType("GLchar const *") CharSequence string) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8(string, true); + long stringEncoded = stack.getPointerAddress(); + return nglCreateShaderProgramEXT(type, stringEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTShaderFramebufferFetch.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTShaderFramebufferFetch.java new file mode 100644 index 00000000..612314a3 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTShaderFramebufferFetch.java @@ -0,0 +1,42 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_shader_framebuffer_fetch extension. + * + *Conventional OpenGL blending provides a configurable series of operations that can be used to combine the output values from a fragment shader with the + * values already in the framebuffer. While these operations are suitable for basic image compositing, other compositing operations or operations that + * treat fragment output as something other than a color (normals, for instance) may not be expressible without multiple passes or render-to-texture + * operations.
+ * + *This extension provides a mechanism whereby a fragment shader may read existing framebuffer data as input. This can be used to implement compositing + * operations that would have been inconvenient or impossible with fixed-function blending. It can also be used to apply a function to the framebuffer + * color, by writing a shader which uses the existing framebuffer color as its only input.
+ * + *This extension provides two alternative name strings:
+ * + *Requires {@link GL20 OpenGL 2.0}.
+ */ +public final class EXTShaderFramebufferFetch { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT = 0x8A52; + + private EXTShaderFramebufferFetch() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTShaderFramebufferFetchNonCoherent.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTShaderFramebufferFetchNonCoherent.java new file mode 100644 index 00000000..76044e0f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTShaderFramebufferFetchNonCoherent.java @@ -0,0 +1,45 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_shader_framebuffer_fetch_non_coherent extension. + * + *See {@link EXTShaderFramebufferFetch EXT_shader_framebuffer_fetch}.
+ */ +public class EXTShaderFramebufferFetchNonCoherent { + + static { GL.initialize(); } + + protected EXTShaderFramebufferFetchNonCoherent() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glFramebufferFetchBarrierEXT + ); + } + + // --- [ glFramebufferFetchBarrierEXT ] --- + + /** + * Specifies a boundary between passes when reading existing framebuffer data from fragment shaders via the {@code gl_LastFragData} built-in variable. + * Previous framebuffer object writes regardless of the mechanism (including clears, blits and primitive rendering) are guaranteed to be visible to + * subsequent fragment shader invocations that read from the framebuffer once {@code FramebufferFetchBarrierEXT} is executed. + * + *If {@code EXT_shader_framebuffer_fetch} is also supported: Because the implementation guarantees coherency of framebuffer reads and writes for color + * outputs not explicitly marked with the noncoherent layout qualifier, calling the {@code FramebufferFetchBarrierEXT} command is not required unless the + * application wishes to manage memory ordering of framebuffer reads and writes explicitly, which may provide better performance on some implementations + * in cases where rendering can be split into multiple passes with non-self-overlapping geometry.
+ */ + public static native void glFramebufferFetchBarrierEXT(); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTShaderImageLoadStore.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTShaderImageLoadStore.java new file mode 100644 index 00000000..d2516e09 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTShaderImageLoadStore.java @@ -0,0 +1,130 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_shader_image_load_store extension. + * + *This extension provides GLSL built-in functions allowing shaders to load from, store to, and perform atomic read-modify-write operations to a single + * level of a texture object from any shader stage. These built-in functions are named imageLoad(), imageStore(), and imageAtomic*(), respectively, and + * accept integer texel coordinates to identify the texel accessed. The extension adds the notion of "image units" to the OpenGL API, to which texture + * levels are bound for access by the GLSL built-in functions. To allow shaders to specify the image unit to access, GLSL provides a new set of data types + * ("image*") similar to samplers. Each image variable is assigned an integer value to identify an image unit to access, which is specified using + * Uniform*() APIs in a manner similar to samplers. For implementations supporting the NV_gpu_program5 extensions, assembly language instructions to + * perform image loads, stores, and atomics are also provided.
+ * + *This extension also provides the capability to explicitly enable "early" per-fragment tests, where operations like depth and stencil testing are + * performed prior to fragment shader execution. In unextended OpenGL, fragment shaders never have any side effects and implementations can sometimes + * perform per-fragment tests and discard some fragments prior to executing the fragment shader. Since this extension allows fragment shaders to write to + * texture and buffer object memory using the built-in image functions, such optimizations could lead to non-deterministic results. To avoid this, + * implementations supporting this extension may not perform such optimizations on shaders having such side effects. However, enabling early per-fragment + * tests guarantees that such tests will be performed prior to fragment shader execution, and ensures that image stores and atomics will not be performed + * by fragment shader invocations where these per-fragment tests fail.
+ * + *Finally, this extension provides both a GLSL built-in function and an OpenGL API function allowing applications some control over the ordering of image + * loads, stores, and atomics relative to other OpenGL pipeline operations accessing the same memory. Because the extension provides the ability to + * perform random accesses to texture or buffer object memory, such accesses are not easily tracked by the OpenGL driver. To avoid the need for + * heavy-handed synchronization at the driver level, this extension requires manual synchronization. The MemoryBarrierEXT() OpenGL API function allows + * applications to specify a bitfield indicating the set of OpenGL API operations to synchronize relative to shader memory access. The memoryBarrier() + * GLSL built-in function provides a synchronization point within a given shader invocation to ensure that all memory accesses performed prior to the + * synchronization point complete prior to any started after the synchronization point.
+ * + *Requires {@link GL30 OpenGL 3.0}.
+ */ +public class EXTShaderImageLoadStore { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_MAX_IMAGE_UNITS_EXT = 0x8F38, + GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT = 0x8F39, + GL_MAX_IMAGE_SAMPLES_EXT = 0x906D; + + /** Accepted by the {@code target} parameter of GetIntegeri_v and GetBooleani_v. */ + public static final int + GL_IMAGE_BINDING_NAME_EXT = 0x8F3A, + GL_IMAGE_BINDING_LEVEL_EXT = 0x8F3B, + GL_IMAGE_BINDING_LAYERED_EXT = 0x8F3C, + GL_IMAGE_BINDING_LAYER_EXT = 0x8F3D, + GL_IMAGE_BINDING_ACCESS_EXT = 0x8F3E, + GL_IMAGE_BINDING_FORMAT_EXT = 0x906E; + + /** Accepted by the {@code barriers} parameter of MemoryBarrierEXT. */ + public static final int + GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT = 0x1, + GL_ELEMENT_ARRAY_BARRIER_BIT_EXT = 0x2, + GL_UNIFORM_BARRIER_BIT_EXT = 0x4, + GL_TEXTURE_FETCH_BARRIER_BIT_EXT = 0x8, + GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT = 0x20, + GL_COMMAND_BARRIER_BIT_EXT = 0x40, + GL_PIXEL_BUFFER_BARRIER_BIT_EXT = 0x80, + GL_TEXTURE_UPDATE_BARRIER_BIT_EXT = 0x100, + GL_BUFFER_UPDATE_BARRIER_BIT_EXT = 0x200, + GL_FRAMEBUFFER_BARRIER_BIT_EXT = 0x400, + GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT = 0x800, + GL_ATOMIC_COUNTER_BARRIER_BIT_EXT = 0x1000, + GL_ALL_BARRIER_BITS_EXT = 0xFFFFFFFF; + + /** Returned by the {@code type} parameter of GetActiveUniform. */ + public static final int + GL_IMAGE_1D_EXT = 0x904C, + GL_IMAGE_2D_EXT = 0x904D, + GL_IMAGE_3D_EXT = 0x904E, + GL_IMAGE_2D_RECT_EXT = 0x904F, + GL_IMAGE_CUBE_EXT = 0x9050, + GL_IMAGE_BUFFER_EXT = 0x9051, + GL_IMAGE_1D_ARRAY_EXT = 0x9052, + GL_IMAGE_2D_ARRAY_EXT = 0x9053, + GL_IMAGE_CUBE_MAP_ARRAY_EXT = 0x9054, + GL_IMAGE_2D_MULTISAMPLE_EXT = 0x9055, + GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x9056, + GL_INT_IMAGE_1D_EXT = 0x9057, + GL_INT_IMAGE_2D_EXT = 0x9058, + GL_INT_IMAGE_3D_EXT = 0x9059, + GL_INT_IMAGE_2D_RECT_EXT = 0x905A, + GL_INT_IMAGE_CUBE_EXT = 0x905B, + GL_INT_IMAGE_BUFFER_EXT = 0x905C, + GL_INT_IMAGE_1D_ARRAY_EXT = 0x905D, + GL_INT_IMAGE_2D_ARRAY_EXT = 0x905E, + GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT = 0x905F, + GL_INT_IMAGE_2D_MULTISAMPLE_EXT = 0x9060, + GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x9061, + GL_UNSIGNED_INT_IMAGE_1D_EXT = 0x9062, + GL_UNSIGNED_INT_IMAGE_2D_EXT = 0x9063, + GL_UNSIGNED_INT_IMAGE_3D_EXT = 0x9064, + GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT = 0x9065, + GL_UNSIGNED_INT_IMAGE_CUBE_EXT = 0x9066, + GL_UNSIGNED_INT_IMAGE_BUFFER_EXT = 0x9067, + GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT = 0x9068, + GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT = 0x9069, + GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT = 0x906A, + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT = 0x906B, + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x906C; + + static { GL.initialize(); } + + protected EXTShaderImageLoadStore() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBindImageTextureEXT, caps.glMemoryBarrierEXT + ); + } + + // --- [ glBindImageTextureEXT ] --- + + public static native void glBindImageTextureEXT(@NativeType("GLuint") int index, @NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLboolean") boolean layered, @NativeType("GLint") int layer, @NativeType("GLenum") int access, @NativeType("GLint") int format); + + // --- [ glMemoryBarrierEXT ] --- + + public static native void glMemoryBarrierEXT(@NativeType("GLbitfield") int barriers); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSharedTexturePalette.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSharedTexturePalette.java new file mode 100644 index 00000000..b0263737 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTSharedTexturePalette.java @@ -0,0 +1,28 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_shared_texture_palette extension. + * + *EXT_shared_texture_palette defines a shared texture palette which may be used in place of the texture object palettes provided by + * EXT_paletted_texture. This is useful for rapidly changing a palette common to many textures, rather than having to reload the + * new palette for each texture. The extension acts as a switch, causing all lookups that would normally be done on the texture's palette to instead use + * the shared palette.
+ * + *Requires EXT_paletted_texture.
+ */ +public final class EXTSharedTexturePalette { + + /** + * Accepted by the {@code pname} parameters of GetBooleanv, GetIntegerv, GetFloatv, GetDoublev, IsEnabled, Enable, Disable, ColorTableEXT, + * ColorSubTableEXT, GetColorTableEXT, GetColorTableParameterivEXT, and GetColorTableParameterfd EXT. + */ + public static final int GL_SHARED_TEXTURE_PALETTE_EXT = 0x81FB; + + private EXTSharedTexturePalette() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTStencilClearTag.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTStencilClearTag.java new file mode 100644 index 00000000..7e2d37ca --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTStencilClearTag.java @@ -0,0 +1,71 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_stencil_clear_tag extension. + * + *Stencil-only framebuffer clears are increasingly common as 3D applications are now using rendering algorithms such as stenciled shadow volume rendering + * for multiple light sources in a single frame, recent "soft" stenciled shadow volume techniques, and stencil-based constructive solid geometry + * techniques. In such algorithms there are multiple stencil buffer clears for each depth buffer clear. Additionally in most cases, these algorithms do + * not require all of the 8 typical stencil bitplanes for their stencil requirements. In such cases, there is the potential for unused stencil bitplanes + * to encode a "stencil clear tag" in such a way to reduce the number of actual stencil clears. The idea is that switching to an unused stencil clear tag + * logically corresponds to when an application would otherwise perform a framebuffer-wide stencil clear.
+ * + *This extension exposes an inexpensive hardware mechanism for amortizing the cost of multiple stencil-only clears by using a client-specified number of + * upper bits of the stencil buffer to maintain a per-pixel stencil tag.
+ * + *The upper bits of each stencil value is treated as a tag that indicates the state of the upper bits of the "stencil clear tag" state when the stencil + * value was last written. If a stencil value is read and its upper bits containing its tag do NOT match the current upper bits of the stencil clear tag + * state, the stencil value is substituted with the lower bits of the stencil clear tag (the reset value). Either way, the upper tag bits of the stencil + * value are ignored by subsequent stencil function and operation processing of the stencil value.
+ * + *When a stencil value is written to the stencil buffer, its upper bits are overridden with the upper bits of the current stencil clear tag state so + * subsequent reads, prior to any subsequent stencil clear tag state change, properly return the updated lower bits.
+ * + *In this way, the stencil clear tag functionality provides a way to replace multiple bandwidth-intensive stencil clears with very inexpensive update of + * the stencil clear tag state.
+ * + *If used as expected with the client specifying 3 bits for the stencil tag, every 7 of 8 stencil-only clears of the entire stencil buffer can be + * substituted for an update of the current stencil clear tag rather than an actual update of all the framebuffer's stencil values. Still, every 8th clear + * must be an actual stencil clear. The net effect is that the aggregate cost of stencil clears is reduced by a factor of 1/(2^n) where n is the number of + * bits devoted to the stencil tag.
+ * + *The application specifies two new pieces of state: 1) the number of upper stencil bits, n, assigned to maintain the tag bits for each stencil value + * within the stencil buffer, and 2) a stencil clear tag value that packs the current tag and a reset value into a single integer values. The upper n bits + * of the stencil clear tag value specify the current tag while the lower s-min(n,s) bits specify the current reset value, where s is the number of + * bitplanes in the stencil buffer and n is the current number of stencil tag bits.
+ * + *If zero stencil clear tag bits are assigned to the stencil tag encoding, then the stencil buffer operates in the conventional manner.
+ */ +public class EXTStencilClearTag { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_STENCIL_TAG_BITS_EXT = 0x88F2, + GL_STENCIL_CLEAR_TAG_VALUE_EXT = 0x88F3; + + static { GL.initialize(); } + + protected EXTStencilClearTag() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glStencilClearTagEXT + ); + } + + // --- [ glStencilClearTagEXT ] --- + + public static native void glStencilClearTagEXT(@NativeType("GLsizei") int stencilTagBits, @NativeType("GLuint") int stencilClearTag); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTStencilTwoSide.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTStencilTwoSide.java new file mode 100644 index 00000000..6aabe388 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTStencilTwoSide.java @@ -0,0 +1,46 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_stencil_two_side extension. + * + *This extension provides two-sided stencil testing where the stencil-related state (stencil operations, reference value, compare mask, and write mask) + * may be different for front- and back-facing polygons. Two-sided stencil testing may improve the performance of stenciled shadow volume and Constructive + * Solid Geometry (CSG) rendering algorithms.
+ */ +public class EXTStencilTwoSide { + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_STENCIL_TEST_TWO_SIDE_EXT = 0x8910; + + /** Accepted by the {@code pname} parameters of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_ACTIVE_STENCIL_FACE_EXT = 0x8911; + + static { GL.initialize(); } + + protected EXTStencilTwoSide() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glActiveStencilFaceEXT + ); + } + + // --- [ glActiveStencilFaceEXT ] --- + + public static native void glActiveStencilFaceEXT(@NativeType("GLenum") int face); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTStencilWrap.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTStencilWrap.java new file mode 100644 index 00000000..37f79079 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTStencilWrap.java @@ -0,0 +1,33 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_stencil_wrap extension. + * + *Various algorithms use the stencil buffer to "count" the number of surfaces that a ray passes through. As the ray passes into an object, the stencil + * buffer is incremented. As the ray passes out of an object, the stencil buffer is decremented.
+ * + *GL requires that the stencil increment operation clamps to its maximum value. For algorithms that depend on the difference between the sum of the + * increments and the sum of the decrements, clamping causes an erroneous result.
+ * + *This extension provides an enable for both maximum and minimum wrapping of stencil values. Instead, the stencil value wraps in both directions.
+ * + *Two additional stencil operations are specified. These new operations are similiar to the existing INCR and DECR operations, but they wrap their result + * instead of saturating it. This functionality matches the new stencil operations introduced by DirectX 6.
+ * + *Promoted to core in {@link GL14 OpenGL 1.4}.
+ */ +public final class EXTStencilWrap { + + /** Accepted by the {@code sfail}, {@code dpfail}, and {@code dppass} parameter of StencilOp. */ + public static final int + GL_INCR_WRAP_EXT = 0x8507, + GL_DECR_WRAP_EXT = 0x8508; + + private EXTStencilWrap() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureArray.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureArray.java new file mode 100644 index 00000000..88ac0a0e --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureArray.java @@ -0,0 +1,96 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_texture_array extension. + * + *This extension introduces the notion of one- and two-dimensional array textures. An array texture is a collection of one- and two-dimensional images of + * identical size and format, arranged in layers. A one-dimensional array texture is specified using TexImage2D; a two-dimensional array texture is + * specified using TexImage3D. The height (1D array) or depth (2D array) specify the number of layers in the image.
+ * + *An array texture is accessed as a single unit in a programmable shader, using a single coordinate vector. A single layer is selected, and that layer is
+ * then accessed as though it were a one- or two-dimensional texture. The layer used is specified using the "t" or "r" texture coordinate for 1D and 2D
+ * array textures, respectively. The layer coordinate is provided as an unnormalized floating-point value in the range {@code [0,
Array textures can be rendered to by binding them to a framebuffer object (EXT_framebuffer_object). A single layer of an array texture can be bound + * using normal framebuffer object mechanisms, or an entire array texture can be bound and rendered to using the layered rendering mechanisms provided by + * NV_geometry_program4.
+ * + *This extension does not provide for the use of array textures with fixed-function fragment processing. Such support could be added by providing an + * additional extension allowing applications to pass the new target enumerants (TEXTURE_1D_ARRAY_EXT and TEXTURE_2D_ARRAY_EXT) to Enable and Disable.
+ * + *Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public class EXTTextureArray { + + /** Accepted by the {@code target} parameter of TexParameteri, TexParameteriv, TexParameterf, TexParameterfv, GenerateMipmapEXT, and BindTexture. */ + public static final int + GL_TEXTURE_1D_ARRAY_EXT = 0x8C18, + GL_TEXTURE_2D_ARRAY_EXT = 0x8C1A; + + /** Accepted by the {@code target} parameter of TexImage3D, TexSubImage3D, CopyTexSubImage3D, CompressedTexImage3D, and CompressedTexSubImage3D. */ + public static final int GL_PROXY_TEXTURE_2D_ARRAY_EXT = 0x8C1B; + + /** + * Accepted by the {@code target} parameter of TexImage2D, TexSubImage2D, CopyTexImage2D, CopyTexSubImage2D, CompressedTexImage2D, and + * CompressedTexSubImage2D. + */ + public static final int GL_PROXY_TEXTURE_1D_ARRAY_EXT = 0x8C19; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv and GetFloatv. */ + public static final int + GL_TEXTURE_BINDING_1D_ARRAY_EXT = 0x8C1C, + GL_TEXTURE_BINDING_2D_ARRAY_EXT = 0x8C1D, + GL_MAX_ARRAY_TEXTURE_LAYERS_EXT = 0x88FF; + + /** + * Accepted by the {@code param} parameter of TexParameterf, TexParameteri, TexParameterfv, and TexParameteriv when the {@code pname} parameter is + * TEXTURE_COMPARE_MODE_ARB. + */ + public static final int GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = 0x884E; + + /** + * COMPARE_REF_DEPTH_TO_TEXTURE_EXT is simply an alias for the existing COMPARE_R_TO_TEXTURE token in OpenGL 2.0; the alternate name reflects the fact that + * the R coordinate is not always used.) Accepted by the {@code pname} parameter of GetFramebufferAttachmentParameterivEXT. + */ + public static final int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 0x8CD4; + + /** + * FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER is simply an alias for the FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT token provided in EXT_framebuffer_object. + * This extension generalizes the notion of "{@code zoffset}" to include layers of an array texture.) Returned by the {@code type} parameter of + * GetActiveUniform. + */ + public static final int + GL_SAMPLER_1D_ARRAY_EXT = 0x8DC0, + GL_SAMPLER_2D_ARRAY_EXT = 0x8DC1, + GL_SAMPLER_1D_ARRAY_SHADOW_EXT = 0x8DC3, + GL_SAMPLER_2D_ARRAY_SHADOW_EXT = 0x8DC4; + + static { GL.initialize(); } + + protected EXTTextureArray() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glFramebufferTextureLayerEXT + ); + } + + // --- [ glFramebufferTextureLayerEXT ] --- + + public static native void glFramebufferTextureLayerEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int attachment, @NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLint") int layer); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureBufferObject.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureBufferObject.java new file mode 100644 index 00000000..cac6c724 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureBufferObject.java @@ -0,0 +1,67 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the EXT_texture_buffer_object extension. + * + *This extension provides a new texture type, called a buffer texture. Buffer textures are one-dimensional arrays of texels whose storage comes from an + * attached buffer object. When a buffer object is bound to a buffer texture, a format is specified, and the data in the buffer object is treated as an + * array of texels of the specified format.
+ * + *The use of a buffer object to provide storage allows the texture data to be specified in a number of different ways: via buffer object loads + * (BufferData), direct CPU writes (MapBuffer), framebuffer readbacks (EXT_pixel_buffer_object extension). A buffer object can also be loaded by transform + * feedback (NV_transform_feedback extension), which captures selected transformed attributes of vertices processed by the GL. Several of these mechanisms + * do not require an extra data copy, which would be required when using conventional TexImage-like entry points.
+ * + *Buffer textures do not support mipmapping, texture lookups with normalized floating-point texture coordinates, and texture filtering of any sort, and + * may not be used in fixed-function fragment processing. They can be accessed via single texel fetch operations in programmable shaders. For assembly + * shaders (NV_gpu_program4), the TXF instruction is used. For GLSL (EXT_gpu_shader4), a new sampler type and texel fetch function are used.
+ * + *Buffer textures can be substantially larger than equivalent one-dimensional textures; the maximum texture size supported for buffer textures in the + * initial implementation of this extension is 2^27 texels, versus 2^13 (8192) texels for otherwise equivalent one-dimensional textures. (Note that this + * extension only guarantees support for buffer textures with 2^16 texels, but we expect most implementations to exceed that substantially.) When a buffer + * object is attached to a buffer texture, a size is not specified; rather, the number of texels in the texture is taken by dividing the size of the + * buffer object by the size of each texel.
+ * + *Requires {@link GL20 OpenGL 2.0} and {@link EXTGPUShader4 EXT_gpu_shader4} or NV_gpu_program4.
+ */ +public class EXTTextureBufferObject { + + /** + * Accepted by the {@code target} parameter of BindBuffer, BufferData, BufferSubData, MapBuffer, BindTexture, UnmapBuffer, GetBufferSubData, + * GetBufferParameteriv, GetBufferPointerv, and TexBufferEXT, and the {@code pname} parameter of GetBooleanv, GetDoublev, GetFloatv, and GetIntegerv. + */ + public static final int GL_TEXTURE_BUFFER_EXT = 0x8C2A; + + /** Accepted by the {@code pname} parameters of GetBooleanv, GetDoublev, GetFloatv, and GetIntegerv. */ + public static final int + GL_MAX_TEXTURE_BUFFER_SIZE_EXT = 0x8C2B, + GL_TEXTURE_BINDING_BUFFER_EXT = 0x8C2C, + GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = 0x8C2D, + GL_TEXTURE_BUFFER_FORMAT_EXT = 0x8C2E; + + static { GL.initialize(); } + + protected EXTTextureBufferObject() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glTexBufferEXT + ); + } + + // --- [ glTexBufferEXT ] --- + + public static native void glTexBufferEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int internalformat, @NativeType("GLuint") int buffer); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureCompressionLATC.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureCompressionLATC.java new file mode 100644 index 00000000..ec113f53 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureCompressionLATC.java @@ -0,0 +1,35 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_texture_compression_latc extension. + * + *This extension introduces four new block-based texture compression formats suited for unsigned and signed luminance and luminance-alpha textures (hence + * the name "latc" for Luminance-Alpha Texture Compression).
+ * + *These formats are designed to reduce the storage requirements and memory bandwidth required for luminance and luminance-alpha textures by a factor of + * 2-to-1 over conventional uncompressed luminance and luminance-alpha textures with 8-bit components ({@link GL11#GL_LUMINANCE8 LUMINANCE8} and {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8}).
+ * + *The compressed signed luminance-alpha format is reasonably suited for storing compressed normal maps.
+ * + *Requires {@link GL13 OpenGL 1.3} or {@link ARBTextureCompression ARB_texture_compression}.
+ */ +public final class EXTTextureCompressionLATC { + + /** + * Accepted by the {@code internalformat} parameter of TexImage2D, CopyTexImage2D, and CompressedTexImage2D and the {@code format} parameter of + * CompressedTexSubImage2D. + */ + public static final int + GL_COMPRESSED_LUMINANCE_LATC1_EXT = 0x8C70, + GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = 0x8C71, + GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C72, + GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C73; + + private EXTTextureCompressionLATC() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureCompressionRGTC.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureCompressionRGTC.java new file mode 100644 index 00000000..a1c0725c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureCompressionRGTC.java @@ -0,0 +1,39 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_texture_compression_rgtc extension. + * + *This extension introduces four new block-based texture compression formats suited for unsigned and signed red and red-green textures (hence the name + * "rgtc" for Red-Green Texture Compression).
+ * + *These formats are designed to reduce the storage requirements and memory bandwidth required for red and red-green textures by a factor of 2-to-1 over + * conventional uncompressed luminance and luminance-alpha textures with 8-bit components ({@link GL11#GL_LUMINANCE8 LUMINANCE8} and {@link GL11#GL_LUMINANCE8_ALPHA8 LUMINANCE8_ALPHA8}).
+ * + *The compressed signed red-green format is reasonably suited for storing compressed normal maps.
+ * + *This extension uses the same compression format as the EXT_texture_compression_latc extension except the color data is stored in the red and green + * components rather than luminance and alpha. Representing compressed red and green components is consistent with the BC4 and BC5 compressed formats + * supported by DirectX 10.
+ * + *Requires {@link GL13 OpenGL 1.3} or {@link ARBTextureCompression ARB_texture_compression}.
+ */ +public final class EXTTextureCompressionRGTC { + + /** + * Accepted by the {@code internalformat} parameter of TexImage2D, CopyTexImage2D, and CompressedTexImage2D and the {@code format} parameter of + * CompressedTexSubImage2D. + */ + public static final int + GL_COMPRESSED_RED_RGTC1_EXT = 0x8DBB, + GL_COMPRESSED_SIGNED_RED_RGTC1_EXT = 0x8DBC, + GL_COMPRESSED_RED_GREEN_RGTC2_EXT = 0x8DBD, + GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 0x8DBE; + + private EXTTextureCompressionRGTC() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureCompressionS3TC.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureCompressionS3TC.java new file mode 100644 index 00000000..90d71af3 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureCompressionS3TC.java @@ -0,0 +1,33 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_texture_compression_s3tc extension. + * + *This extension provides additional texture compression functionality specific to S3's S3TC format (called DXTC in Microsoft's DirectX API), subject to + * all the requirements and limitations described by the extension {@link ARBTextureCompression ARB_texture_compression}.
+ * + *This extension supports DXT1, DXT3, and DXT5 texture compression formats. For the DXT1 image format, this specification supports an RGB-only mode and a + * special RGBA mode with single-bit "transparent" alpha.
+ * + *Requires {@link ARBTextureCompression ARB_texture_compression}.
+ */ +public final class EXTTextureCompressionS3TC { + + /** + * Accepted by the {@code internalformat} parameter of TexImage2D, CopyTexImage2D, and CompressedTexImage2D and the {@code format} parameter of + * CompressedTexSubImage2D. + */ + public static final int + GL_COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0, + GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1, + GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2, + GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3; + + private EXTTextureCompressionS3TC() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureFilterAnisotropic.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureFilterAnisotropic.java new file mode 100644 index 00000000..2c347b55 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureFilterAnisotropic.java @@ -0,0 +1,44 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_texture_filter_anisotropic extension. + * + *Texture mapping using OpenGL's existing mipmap texture filtering modes assumes that the projection of the pixel filter footprint into texture space is a + * square (ie, isotropic). In practice however, the footprint may be long and narrow (ie, anisotropic). Consequently, mipmap filtering severely blurs + * images on surfaces angled obliquely away from the viewer.
+ * + *Several approaches exist for improving texture sampling by accounting for the anisotropic nature of the pixel filter footprint into texture space. This + * extension provides a general mechanism for supporting anisotropic texturing filtering schemes without specifying a particular formulation of anisotropic + * filtering.
+ * + *The extension permits the OpenGL application to specify on a per-texture object basis the maximum degree of anisotropy to account for in texture + * filtering.
+ * + *Increasing a texture object's maximum degree of anisotropy may improve texture filtering but may also significantly reduce the implementation's texture + * filtering rate. Implementations are free to clamp the specified degree of anisotropy to the implementation's maximum supported degree of anisotropy.
+ * + *A texture's maximum degree of anisotropy is specified independent from the texture's minification and magnification filter (as opposed to being + * supported as an entirely new filtering mode). Implementations are free to use the specified minification and magnification filter to select a particular + * anisotropic texture filtering scheme. For example, a NEAREST filter with a maximum degree of anisotropy of two could be treated as a 2-tap filter that + * accounts for the direction of anisotropy. Implementations are also permitted to ignore the minification or magnification filter and implement the + * highest quality of anisotropic filtering possible.
+ * + *Applications seeking the highest quality anisotropic filtering available are advised to request a {@link GL11#GL_LINEAR_MIPMAP_LINEAR LINEAR_MIPMAP_LINEAR} minification filter, a + * {@link GL11#GL_LINEAR LINEAR} magnification filter, and a large maximum degree of anisotropy.
+ */ +public final class EXTTextureFilterAnisotropic { + + /** Accepted by the {@code pname} parameters of GetTexParameterfv, GetTexParameteriv, TexParameterf, TexParameterfv, TexParameteri, and TexParameteriv. */ + public static final int GL_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE; + + /** Accepted by the {@code pname} parameters of GetBooleanv, GetDoublev, GetFloatv, and GetIntegerv. */ + public static final int GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF; + + private EXTTextureFilterAnisotropic() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureFilterMinmax.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureFilterMinmax.java new file mode 100644 index 00000000..adb84443 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureFilterMinmax.java @@ -0,0 +1,38 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_texture_filter_minmax extension. + * + *In unextended OpenGL 4.3, minification and magnification filters such as {@link GL11#GL_LINEAR LINEAR} allow texture lookups to returned a filtered texel value produced + * by computing an weighted average of a collection of texels in the neighborhood of the texture coordinate provided.
+ * + *This extension provides a new texture and sampler parameter ({@link #GL_TEXTURE_REDUCTION_MODE_EXT TEXTURE_REDUCTION_MODE_EXT}) which allows applications to produce a filtered texel value + * by computing a component-wise minimum ({@link GL14#GL_MIN MIN}) or maximum ({@link GL14#GL_MAX MAX}) of the texels that would normally be averaged. The reduction mode is orthogonal + * to the minification and magnification filter parameters. The filter parameters are used to identify the set of texels used to produce a final filtered + * value; the reduction mode identifies how these texels are combined.
+ */ +public final class EXTTextureFilterMinmax { + + /** + * Accepted by the {@code pname} parameter to SamplerParameter{i f}{v}, SamplerParameterI{u}iv, GetSamplerParameter{i f}v, GetSamplerParameterI{u}iv, + * TexParameter{i f}{v}, TexParameterI{u}iv, GetTexParameter{i f}v, GetTexParameterI{u}iv, TextureParameter{i f}{v}EXT, TextureParameterI{u}ivEXT, + * GetTextureParameter{i f}vEXT, GetTextureParameterI{u}ivEXT, MultiTexParameter{i f}{v}EXT, MultiTexParameterI{u}ivEXT, GetMultiTexParameter{i f}vEXT, and + * GetMultiTexParameterI{u}ivEXT. + */ + public static final int GL_TEXTURE_REDUCTION_MODE_EXT = 0x9366; + + /** + * Accepted by the {@code param} or {@code params} parameter to SamplerParameter{i f}{v}, SamplerParameterI{u}iv, TexParameter{i f}{v}, TexParameterI{u}iv, + * TextureParameter{i f}{v}EXT, TextureParameterI{u}ivEXT, MultiTexParameter{i f}{v}EXT, or MultiTexParameterI{u}ivEXT when {@code pname} is + * TEXTURE_REDUCTION_MODE_EXT. + */ + public static final int GL_WEIGHTED_AVERAGE_EXT = 0x9367; + + private EXTTextureFilterMinmax() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureInteger.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureInteger.java new file mode 100644 index 00000000..6fe9bceb --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureInteger.java @@ -0,0 +1,260 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_texture_integer extension. + * + *Fixed-point textures in unextended OpenGL have integer components, but those values are taken to represent floating-point values in the range [0,1]. + * These integer components are considered "normalized" integers. When such a texture is accessed by a shader or by fixed-function fragment processing, + * floating-point values are returned.
+ * + *This extension provides a set of new "unnormalized" integer texture formats. Formats with both signed and unsigned integers are provided. In these + * formats, the components are treated as true integers. When such textures are accessed by a shader, actual integer values are returned.
+ * + *Pixel operations that read from or write to a texture or color buffer with unnormalized integer components follow a path similar to that used for color + * index pixel operations, except that more than one component may be provided at once. Integer values flow through the pixel processing pipe, and no pixel + * transfer operations are performed. Integer format enumerants used for such operations indicate unnormalized integer data.
+ * + *Textures or render buffers with unnormalized integer formats may also be attached to framebuffer objects to receive fragment color values written by a + * fragment shader. Per-fragment operations that require floating-point color components, including multisample alpha operations, alpha test, blending, and + * dithering, have no effect when the corresponding colors are written to an integer color buffer. The NV_gpu_program4 and + * {@link EXTGPUShader4 EXT_gpu_shader4} extensions add the capability to fragment programs and fragment shaders to write signed and unsigned integer output values.
+ * + *This extension does not enforce type consistency for texture accesses or between fragment shaders and the corresponding framebuffer attachments. The + * results of a texture lookup from an integer texture are undefined:
+ * + *The color components used for per-fragment operations and written into a color buffer are undefined:
+ * + *Requires {@link GL20 OpenGL 2.0} and NV_gpu_program4 or {@link EXTGPUShader4 EXT_gpu_shader4}. Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public class EXTTextureInteger { + + /** Accepted by the {@code pname} parameters of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_RGBA_INTEGER_MODE_EXT = 0x8D9E; + + /** Accepted by the {@code internalFormat} parameter of TexImage1D, TexImage2D, and TexImage3D. */ + public static final int + GL_RGBA32UI_EXT = 0x8D70, + GL_RGB32UI_EXT = 0x8D71, + GL_ALPHA32UI_EXT = 0x8D72, + GL_INTENSITY32UI_EXT = 0x8D73, + GL_LUMINANCE32UI_EXT = 0x8D74, + GL_LUMINANCE_ALPHA32UI_EXT = 0x8D75, + GL_RGBA16UI_EXT = 0x8D76, + GL_RGB16UI_EXT = 0x8D77, + GL_ALPHA16UI_EXT = 0x8D78, + GL_INTENSITY16UI_EXT = 0x8D79, + GL_LUMINANCE16UI_EXT = 0x8D7A, + GL_LUMINANCE_ALPHA16UI_EXT = 0x8D7B, + GL_RGBA8UI_EXT = 0x8D7C, + GL_RGB8UI_EXT = 0x8D7D, + GL_ALPHA8UI_EXT = 0x8D7E, + GL_INTENSITY8UI_EXT = 0x8D7F, + GL_LUMINANCE8UI_EXT = 0x8D80, + GL_LUMINANCE_ALPHA8UI_EXT = 0x8D81, + GL_RGBA32I_EXT = 0x8D82, + GL_RGB32I_EXT = 0x8D83, + GL_ALPHA32I_EXT = 0x8D84, + GL_INTENSITY32I_EXT = 0x8D85, + GL_LUMINANCE32I_EXT = 0x8D86, + GL_LUMINANCE_ALPHA32I_EXT = 0x8D87, + GL_RGBA16I_EXT = 0x8D88, + GL_RGB16I_EXT = 0x8D89, + GL_ALPHA16I_EXT = 0x8D8A, + GL_INTENSITY16I_EXT = 0x8D8B, + GL_LUMINANCE16I_EXT = 0x8D8C, + GL_LUMINANCE_ALPHA16I_EXT = 0x8D8D, + GL_RGBA8I_EXT = 0x8D8E, + GL_RGB8I_EXT = 0x8D8F, + GL_ALPHA8I_EXT = 0x8D90, + GL_INTENSITY8I_EXT = 0x8D91, + GL_LUMINANCE8I_EXT = 0x8D92, + GL_LUMINANCE_ALPHA8I_EXT = 0x8D93; + + /** Accepted by the {@code format} parameter of TexImage1D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, DrawPixels and ReadPixels. */ + public static final int + GL_RED_INTEGER_EXT = 0x8D94, + GL_GREEN_INTEGER_EXT = 0x8D95, + GL_BLUE_INTEGER_EXT = 0x8D96, + GL_ALPHA_INTEGER_EXT = 0x8D97, + GL_RGB_INTEGER_EXT = 0x8D98, + GL_RGBA_INTEGER_EXT = 0x8D99, + GL_BGR_INTEGER_EXT = 0x8D9A, + GL_BGRA_INTEGER_EXT = 0x8D9B, + GL_LUMINANCE_INTEGER_EXT = 0x8D9C, + GL_LUMINANCE_ALPHA_INTEGER_EXT = 0x8D9D; + + static { GL.initialize(); } + + protected EXTTextureInteger() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glClearColorIiEXT, caps.glClearColorIuiEXT, caps.glTexParameterIivEXT, caps.glTexParameterIuivEXT, caps.glGetTexParameterIivEXT, + caps.glGetTexParameterIuivEXT + ); + } + + // --- [ glClearColorIiEXT ] --- + + public static native void glClearColorIiEXT(@NativeType("GLint") int r, @NativeType("GLint") int g, @NativeType("GLint") int b, @NativeType("GLint") int a); + + // --- [ glClearColorIuiEXT ] --- + + public static native void glClearColorIuiEXT(@NativeType("GLuint") int r, @NativeType("GLuint") int g, @NativeType("GLuint") int b, @NativeType("GLuint") int a); + + // --- [ glTexParameterIivEXT ] --- + + public static native void nglTexParameterIivEXT(int target, int pname, long params); + + public static void glTexParameterIivEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLint *") IntBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglTexParameterIivEXT(target, pname, memAddress(params)); + } + + public static void glTexParameterIiEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLint *") int param) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer params = stack.ints(param); + nglTexParameterIivEXT(target, pname, memAddress(params)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glTexParameterIuivEXT ] --- + + public static native void nglTexParameterIuivEXT(int target, int pname, long params); + + public static void glTexParameterIuivEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLuint *") IntBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglTexParameterIuivEXT(target, pname, memAddress(params)); + } + + public static void glTexParameterIuiEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLuint *") int param) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer params = stack.ints(param); + nglTexParameterIuivEXT(target, pname, memAddress(params)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetTexParameterIivEXT ] --- + + public static native void nglGetTexParameterIivEXT(int target, int pname, long params); + + public static void glGetTexParameterIivEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLint *") IntBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetTexParameterIivEXT(target, pname, memAddress(params)); + } + + @NativeType("void") + public static int glGetTexParameterIiEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer params = stack.callocInt(1); + nglGetTexParameterIivEXT(target, pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetTexParameterIuivEXT ] --- + + public static native void nglGetTexParameterIuivEXT(int target, int pname, long params); + + public static void glGetTexParameterIuivEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLuint *") IntBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetTexParameterIuivEXT(target, pname, memAddress(params)); + } + + @NativeType("void") + public static int glGetTexParameterIuiEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer params = stack.callocInt(1); + nglGetTexParameterIuivEXT(target, pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + /** Array version of: {@link #glTexParameterIivEXT TexParameterIivEXT} */ + public static void glTexParameterIivEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] params) { + long __functionAddress = GL.getICD().glTexParameterIivEXT; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(target, pname, params, __functionAddress); + } + + /** Array version of: {@link #glTexParameterIuivEXT TexParameterIuivEXT} */ + public static void glTexParameterIuivEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLuint *") int[] params) { + long __functionAddress = GL.getICD().glTexParameterIuivEXT; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(target, pname, params, __functionAddress); + } + + /** Array version of: {@link #glGetTexParameterIivEXT GetTexParameterIivEXT} */ + public static void glGetTexParameterIivEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] params) { + long __functionAddress = GL.getICD().glGetTexParameterIivEXT; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(target, pname, params, __functionAddress); + } + + /** Array version of: {@link #glGetTexParameterIuivEXT GetTexParameterIuivEXT} */ + public static void glGetTexParameterIuivEXT(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLuint *") int[] params) { + long __functionAddress = GL.getICD().glGetTexParameterIuivEXT; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(target, pname, params, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureMirrorClamp.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureMirrorClamp.java new file mode 100644 index 00000000..a27f1b51 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureMirrorClamp.java @@ -0,0 +1,31 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_texture_mirror_clamp extension. + * + *EXT_texture_mirror_clamp extends the set of texture wrap modes to include three modes ({@link #GL_MIRROR_CLAMP_EXT MIRROR_CLAMP_EXT}, {@link #GL_MIRROR_CLAMP_TO_EDGE_EXT MIRROR_CLAMP_TO_EDGE_EXT}, + * {@link #GL_MIRROR_CLAMP_TO_BORDER_EXT MIRROR_CLAMP_TO_BORDER_EXT}) that effectively use a texture map twice as large as the original image in which the additional half of the new image is + * a mirror image of the original image.
+ * + *This new mode relaxes the need to generate images whose opposite edges match by using the original image to generate a matching "mirror image". This + * mode allows the texture to be mirrored only once in the negative s, t, and r directions.
+ */ +public final class EXTTextureMirrorClamp { + + /** + * Accepted by the {@code param} parameter of TexParameteri and TexParameterf, and by the {@code params} parameter of TexParameteriv and TexParameterfv, + * when their {@code pname} parameter is TEXTURE_WRAP_S, TEXTURE_WRAP_T, or TEXTURE_WRAP_R. + */ + public static final int + GL_MIRROR_CLAMP_EXT = 0x8742, + GL_MIRROR_CLAMP_TO_EDGE_EXT = 0x8743, + GL_MIRROR_CLAMP_TO_BORDER_EXT = 0x8912; + + private EXTTextureMirrorClamp() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSRGB.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSRGB.java new file mode 100644 index 00000000..a57ec825 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSRGB.java @@ -0,0 +1,50 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_texture_sRGB extension. + * + *Conventional texture formats assume a linear color space. So for a conventional internal texture format such as GL_RGB8, the 256 discrete values for + * each 8-bit color component map linearly and uniformly to the [0,1] range.
+ * + *The sRGB color space is based on typical (non-linear) monitor characteristics expected in a dimly lit office. It has been standardized by the + * International Electrotechnical Commission (IEC) as IEC 61966-2-1. The sRGB color space roughly corresponds to 2.2 gamma correction.
+ * + *This extension adds a few new uncompressed and compressed color texture formats with sRGB color components.
+ * + *Promoted to core in {@link GL21 OpenGL 2.1}.
+ */ +public final class EXTTextureSRGB { + + /** Accepted by the {@code internalformat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D. */ + public static final int + GL_SRGB_EXT = 0x8C40, + GL_SRGB8_EXT = 0x8C41, + GL_SRGB_ALPHA_EXT = 0x8C42, + GL_SRGB8_ALPHA8_EXT = 0x8C43, + GL_SLUMINANCE_ALPHA_EXT = 0x8C44, + GL_SLUMINANCE8_ALPHA8_EXT = 0x8C45, + GL_SLUMINANCE_EXT = 0x8C46, + GL_SLUMINANCE8_EXT = 0x8C47, + GL_COMPRESSED_SRGB_EXT = 0x8C48, + GL_COMPRESSED_SRGB_ALPHA_EXT = 0x8C49, + GL_COMPRESSED_SLUMINANCE_EXT = 0x8C4A, + GL_COMPRESSED_SLUMINANCE_ALPHA_EXT = 0x8C4B; + + /** + * Accepted by the {@code internalformat} parameter of TexImage2D, CopyTexImage2D, and CompressedTexImage2DARB and the {@code format} parameter of + * CompressedTexSubImage2DARB. + */ + public static final int + GL_COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8C4C, + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8C4D, + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8C4E, + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8C4F; + + private EXTTextureSRGB() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSRGBDecode.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSRGBDecode.java new file mode 100644 index 00000000..09c7d9bf --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSRGBDecode.java @@ -0,0 +1,50 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_texture_sRGB_decode extension. + * + *The EXT_texture_sRGB extension (promoted to core in OpenGL 2.1) provides a texture format stored in the sRGB color space. Sampling one of these + * textures will always return the color value decoded into a linear color space. However, an application may wish to sample and retrieve the undecoded + * sRGB data from the texture and manipulate that directly.
+ * + *This extension adds a Texture Parameter and Sampler Object parameter to allow sRGB textures to be read directly, without decoding.
+ * + *The new parameter, {@link #GL_TEXTURE_SRGB_DECODE_EXT TEXTURE_SRGB_DECODE_EXT} controls whether the decoding happens at sample time. It only applies to textures with an internal format + * that is sRGB and is ignored for all other textures. This value defaults to {@link #GL_DECODE_EXT DECODE_EXT}, which indicates the texture should be decoded to linear color + * space.
+ * + *Requires {@link GL21 OpenGL 2.1} or {@link EXTTextureSRGB EXT_texture_sRGB}.
+ */ +public final class EXTTextureSRGBDecode { + + /** + * Accepted by the {@code pname} parameter of TexParameterf, TexParameteri, TexParameterfv, TexParameteriv, TexParameterIiv, TexParameterIuiv, + * TexParameterIivEXT, TexParameterIuivEXT, TextureParameterfEXT, TextureParameterfvEXT, TextureParameteriEXT, TextureParameterivEXT, + * TextureParameterIivEXT, TextureParameterIuivEXT, MultiTexParameterfEXT, MultiTexParameterfvEXT, MultiTexParameteriEXT, MultiTexParameterivEXT, + * MultiTexParameterIivEXT, MultiTexParameterIuivEXT, GetTexParameterfv, GetTexParameteriv, GetTexParameterIiv, GetTexParameterIuiv, GetTexParameterIivEXT, + * GetTexParameterIuivEXT, GetTextureParameterfEXT, GetTextureParameterfvEXT, GetTextureParameteriEXT, GetTextureParameterivEXT, GetTextureParameterIivEXT, + * GetTextureParameterIuivEXT, GetMultiTexParameterfEXT, GetMultiTexParameterfvEXT, GetMultiTexParameteriEXT, GetMultiTexParameterivEXT, + * GetMultiTexParameterIivEXT, GetMultiTexParameterIuivEXT, SamplerParameteri, SamplerParameterf, SamplerParameteriv, SamplerParameterfv, + * SamplerParameterIiv, SamplerParameterIuiv, GetSamplerParameteriv, GetSamplerParameterfv, GetSamplerParameterIiv, and GetSamplerParameterIuiv. + */ + public static final int GL_TEXTURE_SRGB_DECODE_EXT = 0x8A48; + + /** + * Accepted by the {@code param} parameter of TexParameterf, TexParameteri, TexParameterfv, TexParameteriv, TexParameterIiv, TexParameterIuiv, + * TexParameterIivEXT, TexParameterIuivEXT, TextureParameterfEXT, TextureParameterfvEXT, TextureParameteriEXT, TextureParameterivEXT, + * TextureParameterIivEXT, TextureParameterIuivEXT, MultiTexParameterfEXT, MultiTexParameterfvEXT, MultiTexParameteriEXT, MultiTexParameterivEXT, + * MultiTexParameterIivEXT, MultiTexParameterIuivEXT, SamplerParameteri, SamplerParameterf, SamplerParameteriv, SamplerParameterfv, SamplerParameterIiv, + * and SamplerParameterIuiv. + */ + public static final int + GL_DECODE_EXT = 0x8A49, + GL_SKIP_DECODE_EXT = 0x8A4A; + + private EXTTextureSRGBDecode() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSRGBR8.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSRGBR8.java new file mode 100644 index 00000000..f8390312 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSRGBR8.java @@ -0,0 +1,26 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_texture_sRGB_R8 extension. + * + *This extension introduces {@link #GL_SR8_EXT SR8_EXT} as an acceptable internal format. This allows efficient sRGB sampling for source images stored as a separate texture + * per channel.
+ * + *Requires {@link GL12 OpenGL 1.2}.
+ */ +public final class EXTTextureSRGBR8 { + + /** + * Accepted by the {@code internalformat} parameters of {@link GL12C#glTexImage3D TexImage3D}, {@link GL11C#glTexImage2D TexImage2D}, {@link GL11C#glTexImage1D TexImage1D}, {@link GL42C#glTexStorage3D TexStorage3D}, {@link GL42C#glTexStorage2D TexStorage2D}, {@link GL42C#glTexStorage1D TexStorage1D}, + * {@link GL45C#glTextureStorage3D TextureStorage3D}, {@link GL45C#glTextureStorage2D TextureStorage2D}, and {@link GL45C#glTextureStorage1D TextureStorage1D}. + */ + public static final int GL_SR8_EXT = 0x8FBD; + + private EXTTextureSRGBR8() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSharedExponent.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSharedExponent.java new file mode 100644 index 00000000..cffb6d74 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSharedExponent.java @@ -0,0 +1,42 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_texture_shared_exponent extension. + * + *Existing texture formats provide either fixed-point formats with limited range and precision but with compact encodings (allowing 32 or fewer bits per + * multi-component texel), or floating-point formats with tremendous range and precision but without compact encodings (typically 16 or 32 bits per + * component).
+ * + *This extension adds a new packed format and new internal texture format for encoding 3-component vectors (typically RGB colors) with a single 5-bit + * exponent (biased up by 15) and three 9-bit mantissas for each respective component. There is no sign bit so all three components must be non-negative. + * The fractional mantissas are stored without an implied 1 to the left of the decimal point. Neither infinity nor not-a-number (NaN) are representable in + * this shared exponent format.
+ * + *This 32 bits/texel shared exponent format is particularly well-suited to high dynamic range (HDR) applications where light intensity is typically stored + * as non-negative red, green, and blue components with considerable range.
+ * + *Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public final class EXTTextureSharedExponent { + + /** Accepted by the {@code internalformat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D, and RenderbufferStorageEXT. */ + public static final int GL_RGB9_E5_EXT = 0x8C3D; + + /** + * Accepted by the {@code type} parameter of DrawPixels, ReadPixels, TexImage1D, TexImage2D, GetTexImage, TexImage3D, TexSubImage1D, TexSubImage2D, + * TexSubImage3D, GetHistogram, GetMinmax, ConvolutionFilter1D, ConvolutionFilter2D, ConvolutionFilter3D, GetConvolutionFilter, SeparableFilter2D, + * GetSeparableFilter, ColorTable, ColorSubTable, and GetColorTable. + */ + public static final int GL_UNSIGNED_INT_5_9_9_9_REV_EXT = 0x8C3E; + + /** Accepted by the {@code pname} parameter of GetTexLevelParameterfv and GetTexLevelParameteriv. */ + public static final int GL_TEXTURE_SHARED_SIZE_EXT = 0x8C3F; + + private EXTTextureSharedExponent() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSnorm.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSnorm.java new file mode 100644 index 00000000..184764c5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSnorm.java @@ -0,0 +1,54 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_texture_snorm extension. + * + *Fixed-point textures in unextended OpenGL have integer components, but those values are taken to represent floating-point values in the range + * [0.0,1.0]. These integer components are considered "unsigned normalized" integers. When such a texture is accessed by a shader or by fixed-function + * fragment processing, floating-point values are returned in the range [0.0,1.0].
+ * + *This extension provides a set of new "signed normalized" integer texture formats. These are taken to represent a floating-point value in the range + * [-1.0,1.0] with an exact 0.0.
+ * + *Requires {@link GL30 OpenGL 3.0}.
+ */ +public final class EXTTextureSnorm { + + /** ccepted by the {@code internalFormat} parameter of TexImage1D, TexImage2D, and TexImage3D. */ + public static final int + GL_RED_SNORM = 0x8F90, + GL_RG_SNORM = 0x8F91, + GL_RGB_SNORM = 0x8F92, + GL_RGBA_SNORM = 0x8F93, + GL_ALPHA_SNORM = 0x9010, + GL_LUMINANCE_SNORM = 0x9011, + GL_LUMINANCE_ALPHA_SNORM = 0x9012, + GL_INTENSITY_SNORM = 0x9013, + GL_R8_SNORM = 0x8F94, + GL_RG8_SNORM = 0x8F95, + GL_RGB8_SNORM = 0x8F96, + GL_RGBA8_SNORM = 0x8F97, + GL_ALPHA8_SNORM = 0x9014, + GL_LUMINANCE8_SNORM = 0x9015, + GL_LUMINANCE8_ALPHA8_SNORM = 0x9016, + GL_INTENSITY8_SNORM = 0x9017, + GL_R16_SNORM = 0x8F98, + GL_RG16_SNORM = 0x8F99, + GL_RGB16_SNORM = 0x8F9A, + GL_RGBA16_SNORM = 0x8F9B, + GL_ALPHA16_SNORM = 0x9018, + GL_LUMINANCE16_SNORM = 0x9019, + GL_LUMINANCE16_ALPHA16_SNORM = 0x901A, + GL_INTENSITY16_SNORM = 0x901B; + + /** Returned by GetTexLevelParmeter. */ + public static final int GL_SIGNED_NORMALIZED = 0x8F9C; + + private EXTTextureSnorm() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSwizzle.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSwizzle.java new file mode 100644 index 00000000..fef96270 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTextureSwizzle.java @@ -0,0 +1,37 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the EXT_texture_swizzle extension. + * + *Classic OpenGL texture formats conflate texture storage and interpretation, and assume that textures represent color. In modern applications, a + * significant quantity of textures don't represent color, but rather data like shadow maps, normal maps, page tables, occlusion data, etc.. For the + * latter class of data, calling the data "RGBA" is just a convenient mapping of what the data is onto the current model, but isn't an accurate reflection + * of the reality of the data.
+ * + *The existing texture formats provide an almost orthogonal set of data types, sizes, and number of components, but the mappings of this storage into + * what the shader or fixed-function pipeline fetches is very much non-orthogonal. Previous extensions have added some of the most demanded missing + * formats, but the problem has not been solved once and for all.
+ * + *This extension provides a mechanism to swizzle the components of a texture before they are applied according to the texture environment in + * fixed-function or as they are returned to the shader.
+ */ +public final class EXTTextureSwizzle { + + /** Accepted by the {@code pname} parameters of TexParameteri, TexParameterf, TexParameteriv, TexParameterfv, GetTexParameterfv, and GetTexParameteriv. */ + public static final int + GL_TEXTURE_SWIZZLE_R_EXT = 0x8E42, + GL_TEXTURE_SWIZZLE_G_EXT = 0x8E43, + GL_TEXTURE_SWIZZLE_B_EXT = 0x8E44, + GL_TEXTURE_SWIZZLE_A_EXT = 0x8E45; + + /** Accepted by the {@code pname} parameters of TexParameteriv, TexParameterfv, GetTexParameterfv, and GetTexParameteriv. */ + public static final int GL_TEXTURE_SWIZZLE_RGBA_EXT = 0x8E46; + + private EXTTextureSwizzle() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTimerQuery.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTimerQuery.java new file mode 100644 index 00000000..f208e759 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTimerQuery.java @@ -0,0 +1,117 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_timer_query extension. + * + *Applications can benefit from accurate timing information in a number of different ways. During application development, timing information can help + * identify application or driver bottlenecks. At run time, applications can use timing information to dynamically adjust the amount of detail in a scene + * to achieve constant frame rates. OpenGL implementations have historically provided little to no useful timing information. Applications can get some + * idea of timing by reading timers on the CPU, but these timers are not synchronized with the graphics rendering pipeline. Reading a CPU timer does not + * guarantee the completion of a potentially large amount of graphics work accumulated before the timer is read, and will thus produce wildly inaccurate + * results. glFinish() can be used to determine when previous rendering commands have been completed, but will idle the graphics pipeline and adversely + * affect application performance.
+ * + *This extension provides a query mechanism that can be used to determine the amount of time it takes to fully complete a set of GL commands, and without + * stalling the rendering pipeline. It uses the query object mechanisms first introduced in the occlusion query extension, which allow time intervals to + * be polled asynchronously by the application.
+ * + *Requires {@link GL15 OpenGL 1.5}.
+ */ +public class EXTTimerQuery { + + /** Accepted by the {@code target} parameter of BeginQuery, EndQuery, and GetQueryiv. */ + public static final int GL_TIME_ELAPSED_EXT = 0x88BF; + + static { GL.initialize(); } + + protected EXTTimerQuery() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetQueryObjecti64vEXT, caps.glGetQueryObjectui64vEXT + ); + } + + // --- [ glGetQueryObjecti64vEXT ] --- + + public static native void nglGetQueryObjecti64vEXT(int id, int pname, long params); + + public static void glGetQueryObjecti64vEXT(@NativeType("GLuint") int id, @NativeType("GLenum") int pname, @NativeType("GLint64 *") LongBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetQueryObjecti64vEXT(id, pname, memAddress(params)); + } + + @NativeType("void") + public static long glGetQueryObjecti64EXT(@NativeType("GLuint") int id, @NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer params = stack.callocLong(1); + nglGetQueryObjecti64vEXT(id, pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetQueryObjectui64vEXT ] --- + + public static native void nglGetQueryObjectui64vEXT(int id, int pname, long params); + + public static void glGetQueryObjectui64vEXT(@NativeType("GLuint") int id, @NativeType("GLenum") int pname, @NativeType("GLuint64 *") LongBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetQueryObjectui64vEXT(id, pname, memAddress(params)); + } + + @NativeType("void") + public static long glGetQueryObjectui64EXT(@NativeType("GLuint") int id, @NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer params = stack.callocLong(1); + nglGetQueryObjectui64vEXT(id, pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + /** Array version of: {@link #glGetQueryObjecti64vEXT GetQueryObjecti64vEXT} */ + public static void glGetQueryObjecti64vEXT(@NativeType("GLuint") int id, @NativeType("GLenum") int pname, @NativeType("GLint64 *") long[] params) { + long __functionAddress = GL.getICD().glGetQueryObjecti64vEXT; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(id, pname, params, __functionAddress); + } + + /** Array version of: {@link #glGetQueryObjectui64vEXT GetQueryObjectui64vEXT} */ + public static void glGetQueryObjectui64vEXT(@NativeType("GLuint") int id, @NativeType("GLenum") int pname, @NativeType("GLuint64 *") long[] params) { + long __functionAddress = GL.getICD().glGetQueryObjectui64vEXT; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(id, pname, params, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTransformFeedback.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTransformFeedback.java new file mode 100644 index 00000000..b596b921 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTTransformFeedback.java @@ -0,0 +1,237 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_transform_feedback extension. + * + *This extension provides a new mode to the GL, called transform feedback, which records selected vertex attributes for each primitive processed by the + * GL. The selected attributes are written into buffer objects, and can be written with each attribute in a separate buffer object or with all attributes + * interleaved into a single buffer object. If a geometry shader is active, the primitives recorded are those emitted by the geometry shader. Otherwise, + * transform feedback captures primitives whose vertices are transformed by a vertex shader. In either case, the primitives captured are those generated + * prior to clipping. Transform feedback mode captures the values of specified varying variables emitted from GLSL vertex or geometry shaders.
+ * + *The vertex data recorded in transform feedback mode is stored into buffer objects as an array of vertex attributes. The regular representation and the + * use of buffer objects allows the recorded data to be processed directly by the GL without requiring CPU intervention to copy data. In particular, + * transform feedback data can be used for vertex arrays (via vertex buffer objects), as the source for pixel data (via pixel buffer objects), as shader + * constant data (via the NV_parameter_buffer_object or {@link EXTBindableUniform EXT_bindable_uniform} extensions), or via any other extension that + * makes use of buffer objects.
+ * + *This extension introduces new query object support to allow transform feedback mode to operate asynchronously. Query objects allow applications to + * determine when transform feedback results are complete, as well as the number of primitives processed and written back to buffer objects while in + * transform feedback mode. This extension also provides a new rasterizer discard enable, which allows applications to use transform feedback to capture + * vertex attributes without rendering anything.
+ * + *Requires {@link GL20 OpenGL 2.0} or {@link ARBShaderObjects ARB_shader_objects}. Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ +public class EXTTransformFeedback { + + /** + * Accepted by the {@code target} parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, GetBufferPointerv, + * BindBufferRangeEXT, BindBufferOffsetEXT and BindBufferBaseEXT. + */ + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_EXT = 0x8C8E; + + /** Accepted by the {@code param} parameter of GetIntegerIndexedvEXT and GetBooleanIndexedvEXT. */ + public static final int + GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT = 0x8C84, + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT = 0x8C85; + + /** + * Accepted by the {@code param} parameter of GetIntegerIndexedvEXT and GetBooleanIndexedvEXT, and by the {@code pname} parameter of GetBooleanv, + * GetDoublev, GetIntegerv, and GetFloatv. + */ + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT = 0x8C8F; + + /** Accepted by the {@code bufferMode} parameter of TransformFeedbackVaryingsEXT. */ + public static final int + GL_INTERLEAVED_ATTRIBS_EXT = 0x8C8C, + GL_SEPARATE_ATTRIBS_EXT = 0x8C8D; + + /** Accepted by the {@code target} parameter of BeginQuery, EndQuery, and GetQueryiv. */ + public static final int + GL_PRIMITIVES_GENERATED_EXT = 0x8C87, + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT = 0x8C88; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_RASTERIZER_DISCARD_EXT = 0x8C89; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT = 0x8C8A, + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT = 0x8C8B, + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT = 0x8C80; + + /** Accepted by the {@code pname} parameter of GetProgramiv. */ + public static final int + GL_TRANSFORM_FEEDBACK_VARYINGS_EXT = 0x8C83, + GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT = 0x8C7F, + GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT = 0x8C76; + + static { GL.initialize(); } + + protected EXTTransformFeedback() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBindBufferRangeEXT, caps.glBindBufferOffsetEXT, caps.glBindBufferBaseEXT, caps.glBeginTransformFeedbackEXT, caps.glEndTransformFeedbackEXT, + caps.glTransformFeedbackVaryingsEXT, caps.glGetTransformFeedbackVaryingEXT, caps.glGetIntegerIndexedvEXT, caps.glGetBooleanIndexedvEXT + ); + } + + // --- [ glBindBufferRangeEXT ] --- + + public static native void glBindBufferRangeEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLuint") int buffer, @NativeType("GLintptr") long offset, @NativeType("GLsizeiptr") long size); + + // --- [ glBindBufferOffsetEXT ] --- + + public static native void glBindBufferOffsetEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLuint") int buffer, @NativeType("GLintptr") long offset); + + // --- [ glBindBufferBaseEXT ] --- + + public static native void glBindBufferBaseEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLuint") int buffer); + + // --- [ glBeginTransformFeedbackEXT ] --- + + public static native void glBeginTransformFeedbackEXT(@NativeType("GLenum") int primitiveMode); + + // --- [ glEndTransformFeedbackEXT ] --- + + public static native void glEndTransformFeedbackEXT(); + + // --- [ glTransformFeedbackVaryingsEXT ] --- + + public static native void nglTransformFeedbackVaryingsEXT(int program, int count, long varyings, int bufferMode); + + public static void glTransformFeedbackVaryingsEXT(@NativeType("GLuint") int program, @NativeType("GLchar const * const *") PointerBuffer varyings, @NativeType("GLenum") int bufferMode) { + nglTransformFeedbackVaryingsEXT(program, varyings.remaining(), memAddress(varyings), bufferMode); + } + + public static void glTransformFeedbackVaryingsEXT(@NativeType("GLuint") int program, @NativeType("GLchar const * const *") CharSequence[] varyings, @NativeType("GLenum") int bufferMode) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + long varyingsAddress = org.lwjgl.system.APIUtil.apiArray(stack, MemoryUtil::memASCII, varyings); + nglTransformFeedbackVaryingsEXT(program, varyings.length, varyingsAddress, bufferMode); + org.lwjgl.system.APIUtil.apiArrayFree(varyingsAddress, varyings.length); + } finally { + stack.setPointer(stackPointer); + } + } + + public static void glTransformFeedbackVaryingsEXT(@NativeType("GLuint") int program, @NativeType("GLchar const * const *") CharSequence varying, @NativeType("GLenum") int bufferMode) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + long varyingsAddress = org.lwjgl.system.APIUtil.apiArray(stack, MemoryUtil::memASCII, varying); + nglTransformFeedbackVaryingsEXT(program, 1, varyingsAddress, bufferMode); + org.lwjgl.system.APIUtil.apiArrayFree(varyingsAddress, 1); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetTransformFeedbackVaryingEXT ] --- + + public static native void nglGetTransformFeedbackVaryingEXT(int program, int index, int bufSize, long length, long size, long type, long name); + + public static void glGetTransformFeedbackVaryingEXT(@NativeType("GLuint") int program, @NativeType("GLuint") int index, @Nullable @NativeType("GLsizei *") IntBuffer length, @NativeType("GLsizei *") IntBuffer size, @NativeType("GLenum *") IntBuffer type, @NativeType("GLchar *") ByteBuffer name) { + if (CHECKS) { + checkSafe(length, 1); + check(size, 1); + check(type, 1); + } + nglGetTransformFeedbackVaryingEXT(program, index, name.remaining(), memAddressSafe(length), memAddress(size), memAddress(type), memAddress(name)); + } + + @NativeType("void") + public static String glGetTransformFeedbackVaryingEXT(@NativeType("GLuint") int program, @NativeType("GLuint") int index, @NativeType("GLsizei") int bufSize, @NativeType("GLsizei *") IntBuffer size, @NativeType("GLenum *") IntBuffer type) { + if (CHECKS) { + check(size, 1); + check(type, 1); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer length = stack.ints(0); + ByteBuffer name = stack.malloc(bufSize); + nglGetTransformFeedbackVaryingEXT(program, index, bufSize, memAddress(length), memAddress(size), memAddress(type), memAddress(name)); + return memASCII(name, length.get(0)); + } finally { + stack.setPointer(stackPointer); + } + } + + @NativeType("void") + public static String glGetTransformFeedbackVaryingEXT(@NativeType("GLuint") int program, @NativeType("GLuint") int index, @NativeType("GLsizei *") IntBuffer size, @NativeType("GLenum *") IntBuffer type) { + return glGetTransformFeedbackVaryingEXT(program, index, GL.getCapabilities().OpenGL20 + ? GL20.glGetProgrami(program, GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT) + : ARBShaderObjects.glGetObjectParameteriARB(program, GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT), size, type); + } + + // --- [ glGetIntegerIndexedvEXT ] --- + + public static void nglGetIntegerIndexedvEXT(int target, int index, long data) { + EXTDrawBuffers2.nglGetIntegerIndexedvEXT(target, index, data); + } + + public static void glGetIntegerIndexedvEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLint *") IntBuffer data) { + EXTDrawBuffers2.glGetIntegerIndexedvEXT(target, index, data); + } + + @NativeType("void") + public static int glGetIntegerIndexedEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index) { + return EXTDrawBuffers2.glGetIntegerIndexedEXT(target, index); + } + + // --- [ glGetBooleanIndexedvEXT ] --- + + public static void nglGetBooleanIndexedvEXT(int target, int index, long data) { + EXTDrawBuffers2.nglGetBooleanIndexedvEXT(target, index, data); + } + + public static void glGetBooleanIndexedvEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLboolean *") ByteBuffer data) { + EXTDrawBuffers2.glGetBooleanIndexedvEXT(target, index, data); + } + + @NativeType("void") + public static boolean glGetBooleanIndexedEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index) { + return EXTDrawBuffers2.glGetBooleanIndexedEXT(target, index); + } + + /** Array version of: {@link #glGetTransformFeedbackVaryingEXT GetTransformFeedbackVaryingEXT} */ + public static void glGetTransformFeedbackVaryingEXT(@NativeType("GLuint") int program, @NativeType("GLuint") int index, @Nullable @NativeType("GLsizei *") int[] length, @NativeType("GLsizei *") int[] size, @NativeType("GLenum *") int[] type, @NativeType("GLchar *") ByteBuffer name) { + long __functionAddress = GL.getICD().glGetTransformFeedbackVaryingEXT; + if (CHECKS) { + check(__functionAddress); + checkSafe(length, 1); + check(size, 1); + check(type, 1); + } + callPPPPV(program, index, name.remaining(), length, size, type, memAddress(name), __functionAddress); + } + + /** Array version of: {@link #glGetIntegerIndexedvEXT GetIntegerIndexedvEXT} */ + public static void glGetIntegerIndexedvEXT(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLint *") int[] data) { + EXTDrawBuffers2.glGetIntegerIndexedvEXT(target, index, data); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTVertexAttrib64bit.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTVertexAttrib64bit.java new file mode 100644 index 00000000..e5bd1011 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTVertexAttrib64bit.java @@ -0,0 +1,230 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_vertex_attrib_64bit extension. + * + *This extension provides OpenGL shading language support for vertex shader inputs with 64-bit floating-point components and OpenGL API support for + * specifying the value of those inputs using vertex array or immediate mode entry points. This builds on the support for general-purpose support for + * 64-bit floating-point values in the ARB_gpu_shader_fp64 extension.
+ * + *This extension provides a new class of vertex attribute functions, beginning with "VertexAttribL" ("L" for "long"), that can be used to specify + * attributes with 64-bit floating-point components. This extension provides no automatic type conversion between attribute and shader variables; + * single-precision attributes are not automatically converted to double-precision or vice versa. For shader variables with 64-bit component types, the + * "VertexAttribL" functions must be used to specify attribute values. For other shader variables, the "VertexAttribL" functions must not be used. If a + * vertex attribute is specified using the wrong attribute function, the values of the corresponding shader input are undefined. This approach requiring + * matching types is identical to that used for the "VertexAttribI" functions provided by OpenGL 3.0 and the EXT_gpu_shader4 extension.
+ * + *Additionally, some vertex shader inputs using the wider 64-bit components may count double against the implementation-dependent limit on the number of + * vertex shader attribute vectors. A 64-bit scalar or a two-component vector consumes only a single generic vertex attribute; three- and four-component + * "long" may count as two. This approach is similar to the one used in the current GL where matrix attributes consume multiple attributes.
+ * + *Note that 64-bit generic vertex attributes were nominally supported beginning with the introduction of vertex shaders in OpenGL 2.0. However, the + * OpenGL Shading Language at the time had no support for 64-bit data types, so any such values were automatically converted to 32-bit.
+ * + *Support for 64-bit floating-point vertex attributes in this extension can be combined with other extensions. In particular, this extension provides an + * entry point that can be used with EXT_direct_state_access to directly set state for any vertex array object. Also, the related + * NV_vertex_attrib_integer_64bit extension provides an entry point to specify bindless vertex attribute arrays with 64-bit components, integer or + * floating-point.
+ * + *Requires {@link GL30 OpenGL 3.0} and {@link ARBGPUShaderFP64 ARB_gpu_shader_fp64} (or equivalent functionality).
+ */ +public class EXTVertexAttrib64bit { + + /** Returned in the {@code type} parameter of GetActiveAttrib. */ + public static final int + GL_DOUBLE_VEC2_EXT = 0x8FFC, + GL_DOUBLE_VEC3_EXT = 0x8FFD, + GL_DOUBLE_VEC4_EXT = 0x8FFE, + GL_DOUBLE_MAT2_EXT = 0x8F46, + GL_DOUBLE_MAT3_EXT = 0x8F47, + GL_DOUBLE_MAT4_EXT = 0x8F48, + GL_DOUBLE_MAT2x3_EXT = 0x8F49, + GL_DOUBLE_MAT2x4_EXT = 0x8F4A, + GL_DOUBLE_MAT3x2_EXT = 0x8F4B, + GL_DOUBLE_MAT3x4_EXT = 0x8F4C, + GL_DOUBLE_MAT4x2_EXT = 0x8F4D, + GL_DOUBLE_MAT4x3_EXT = 0x8F4E; + + static { GL.initialize(); } + + protected EXTVertexAttrib64bit() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.Set| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_DOUBLE DOUBLE} |
Direct3D image objects may have a built-in synchronization primitive associated with them that can be used to synchronize access to their contents + * across process and API boundaries. This extension provides access to that synchronization primitive via two new commands that operate on GL memory + * objects.
+ * + *Requires {@link EXTMemoryObject EXT_memory_object}.
+ */ +public class EXTWin32KeyedMutex { + + static { GL.initialize(); } + + protected EXTWin32KeyedMutex() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glAcquireKeyedMutexWin32EXT, caps.glReleaseKeyedMutexWin32EXT + ); + } + + // --- [ glAcquireKeyedMutexWin32EXT ] --- + + /** + * Blocks GL command processing until a keyed mutex is acquired. + * + * @param memory identifies which keyed mutex to acquire + * @param key is the mutex value to wait for + * @param timeout the time, in milliseconds, to wait before failing the acquire operation + */ + @NativeType("GLboolean") + public static native boolean glAcquireKeyedMutexWin32EXT(@NativeType("GLuint") int memory, @NativeType("GLuint64") long key, @NativeType("GLuint") int timeout); + + // --- [ glReleaseKeyedMutexWin32EXT ] --- + + /** + * Releases a keyed mutex after all prior GL command processing has completed. + * + * @param memory identifies the keyed mutex to release + * @param key the mutex value set by the release operation + */ + @NativeType("GLboolean") + public static native boolean glReleaseKeyedMutexWin32EXT(@NativeType("GLuint") int memory, @NativeType("GLuint64") long key); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTWindowRectangles.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTWindowRectangles.java new file mode 100644 index 00000000..29f052e9 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/EXTWindowRectangles.java @@ -0,0 +1,122 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the EXT_window_rectangles extension. + * + *This extension provides additional orthogonally aligned "window rectangles" specified in window-space coordinates that restrict rasterization of all + * primitive types (geometry, images, paths) and framebuffer clears.
+ * + *When rendering to the framebuffer of an on-screen window, these window rectangles are ignored so these window rectangles apply to rendering to non-zero + * framebuffer objects only.
+ * + *From zero to an implementation-dependent limit (specified by {@link #GL_MAX_WINDOW_RECTANGLES_EXT MAX_WINDOW_RECTANGLES_EXT}) number of window rectangles can be operational at once. When + * one or more window rectangles are active, rasterized fragments can either survive if the fragment is within any of the operational window rectangles + * ({@link #GL_INCLUSIVE_EXT INCLUSIVE_EXT} mode) or be rejected if the fragment is within any of the operational window rectangles ({@link #GL_EXCLUSIVE_EXT EXCLUSIVE_EXT} mode).
+ * + *These window rectangles operate orthogonally to the existing scissor test functionality.
+ * + *This extension has specification language for both OpenGL and ES so {@code EXT_window_rectangles} can be implemented and advertised for either or both + * API contexts.
+ * + *Requires {@link GL30 GL30} or {@link EXTDrawBuffers2 EXT_draw_buffers2}.
+ */ +public class EXTWindowRectangles { + + /** Accepted by the {@code mode} parameter of {@link #glWindowRectanglesEXT WindowRectanglesEXT}. */ + public static final int + GL_INCLUSIVE_EXT = 0x8F10, + GL_EXCLUSIVE_EXT = 0x8F11; + + /** + * Accepted by the {@code pname} parameter of GetIntegeri_v, GetInteger64i_v, GetBooleani_v, GetFloati_v, GetDoublei_v, GetIntegerIndexedvEXT, + * GetFloatIndexedvEXT, GetDoubleIndexedvEXT, GetBooleanIndexedvEXT, and GetIntegeri_vEXT. + */ + public static final int GL_WINDOW_RECTANGLE_EXT = 0x8F12; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int + GL_WINDOW_RECTANGLE_MODE_EXT = 0x8F13, + GL_MAX_WINDOW_RECTANGLES_EXT = 0x8F14, + GL_NUM_WINDOW_RECTANGLES_EXT = 0x8F15; + + static { GL.initialize(); } + + protected EXTWindowRectangles() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glWindowRectanglesEXT + ); + } + + // --- [ glWindowRectanglesEXT ] --- + + /** + * Unsafe version of: {@link #glWindowRectanglesEXT WindowRectanglesEXT} + * + * @param count the number of active window rectangles. Must be between zero and the value of {@link #GL_MAX_WINDOW_RECTANGLES_EXT MAX_WINDOW_RECTANGLES_EXT}. + */ + public static native void nglWindowRectanglesEXT(int mode, int count, long box); + + /** + * Sets the active window rectangles. + * + *When the {@code WindowRectanglesEXT} command is processed without error, the ith window rectangle box is set to the corresponding four + * parameters for values of {@code i} less then {@code n}. For values of {@code i} greater than {@code n}, each window rectangle box is set to (0,0,0,0).
+ * + *Each four elements corresponds to the ith window rectangle indicating a box of pixels specified with window-space coordinates. Each window + * rectangle box {@code i} has a lower-left origin at {@code (x_i,y_i)} and upper-right corner at {@code (x_i+w_i,y_i+h_i)}.
+ * + *The {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if any element {@code w_i} or {@code h_i}, corresponding to each box's respective width and height, is negative.
+ * + *Each rasterized or cleared fragment with a window-space position {@code (xw,yw)} is within the ith window rectangle box when both of these + * equations are satisfied for all {@code i} less than {@code n}:
+ * + *
+ * x_i <= xw < x_i+w_i
+ * y_i <= yw < y_i+h_iWhen the window rectangles mode is {@link #GL_INCLUSIVE_EXT INCLUSIVE_EXT} mode and the bound framebuffer object is non-zero, a fragment passes the window rectangles test if + * the fragment's window-space position is within at least one of the current {@code n} active window rectangles; otherwise the window rectangles test + * fails and the fragment is discarded.
+ * + *When the window rectangles mode is {@link #GL_EXCLUSIVE_EXT EXCLUSIVE_EXT} mode and the bound framebuffer object is non-zero, a fragment fails the window rectangles test and is + * discarded if the fragment's window-space position is within at least one of the current {@code n} active window rectangles; otherwise the window + * rectangles test passes and the fragment passes the window rectangles test.
+ * + *When the bound framebuffer object is zero, the window rectangles test always passes.
+ * + * @param mode the rectangle mode. One of:| {@link #GL_INCLUSIVE_EXT INCLUSIVE_EXT} | {@link #GL_EXCLUSIVE_EXT EXCLUSIVE_EXT} |
Synchronization objects added the ability to better coordinate operations between multiple GL command streams. However, it is desirable to have the + * same level of coordination between GL command streams and external rendering APIs. This extension introduces two new concepts to build upon the + * synchronization infrastructure provided by {@link ARBSync ARB_sync}:
+ * + *The latter is necessary because the import operation is expensive and performing it every time a synchronization point was reached would make the + * synchronization prohibitively slow.
+ * + *This extension stops short of allowing the GL to change the state of imported/reusable sync objects, but does not add any language that would prohibit + * such functionality from being added in a subsequent extension.
+ * + *Requires {@link GL32 OpenGL 3.2} or {@link ARBSync ARB_sync}.
+ */ +public class EXTX11SyncObject { + + /** Accepted by the {@code external_sync_type} parameter of ImportSyncEXT. */ + public static final int GL_SYNC_X11_FENCE_EXT = 0x90E1; + + static { GL.initialize(); } + + protected EXTX11SyncObject() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glImportSyncEXT + ); + } + + // --- [ glImportSyncEXT ] --- + + /** + * Creates a GL sync object of the type {@code external_sync_type} based on the object referred to by {@code external_sync}. + * + * @param external_sync_type the external sync object type. Must be:| {@link #GL_SYNC_X11_FENCE_EXT SYNC_X11_FENCE_EXT} |
The OpenGL library is loaded automatically when this class is initialized. Set the {@link Configuration#OPENGL_EXPLICIT_INIT} option to override this + * behavior. Manual loading/unloading can be achieved with the {@link #create} and {@link #destroy} functions. The name of the library loaded can be overridden + * with the {@link Configuration#OPENGL_LIBRARY_NAME} option. The maximum OpenGL version loaded can be set with the {@link Configuration#OPENGL_MAXVERSION} + * option. This can be useful to ensure that no functionality above a specific version is used during development.
+ * + *Instances of {@code GLCapabilities} can be created with the {@link #createCapabilities} method. An OpenGL context must be current in the current thread + * before it is called. Calling this method is expensive, so the {@code GLCapabilities} instance should be associated with the OpenGL context and reused as + * necessary.
+ * + *Before a function for a given OpenGL context can be called, the corresponding {@code GLCapabilities} instance must be passed to the + * {@link #setCapabilities} method. The user is also responsible for clearing the current {@code GLCapabilities} instance when the context is destroyed or made + * current in another thread.
+ * + *Note that the {@link #createCapabilities} method implicitly calls {@link #setCapabilities} with the newly created instance.
+ */ +public final class GL { + + @Nullable + private static final APIVersion MAX_VERSION; + + @Nullable + private static FunctionProvider functionProvider; + + private static final ThreadLocalThis {@code GLCapabilities} instance will be used by any OpenGL call in the current thread, until {@code setCapabilities} is called again with a + * different value.
+ */ + public static void setCapabilities(@Nullable GLCapabilities caps) { + capabilitiesTLS.set(caps); + ThreadLocalUtil.setEnv(caps == null ? NULL : memAddress(caps.addresses), 3); + icd.set(caps); + } + + /** + * Returns the {@link GLCapabilities} of the OpenGL context that is current in the current thread. + * + * @throws IllegalStateException if {@link #setCapabilities} has never been called in the current thread or was last called with a {@code null} value + */ + public static GLCapabilities getCapabilities() { + return checkCapabilities(capabilitiesTLS.get()); + } + + private static GLCapabilities checkCapabilities(@Nullable GLCapabilities caps) { + if (CHECKS && caps == null) { + throw new IllegalStateException( + "No GLCapabilities instance set for the current thread. Possible solutions:\n" + + "\ta) Call GL.createCapabilities() after making a context current in the current thread.\n" + + "\tb) Call GL.setCapabilities() if a GLCapabilities instance already exists for the current context." + ); + } + //noinspection ConstantConditions + return caps; + } + + /** + * Returns the WGL capabilities. + * + *This method may only be used on Windows.
+ */ + public static WGLCapabilities getCapabilitiesWGL() { + if (capabilitiesWGL == null) { + capabilitiesWGL = createCapabilitiesWGLDummy(); + } + + return capabilitiesWGL; + } + + /** Returns the GLX client capabilities. */ + static GLXCapabilities getCapabilitiesGLXClient() { + if (capabilitiesGLXClient == null) { + capabilitiesGLXClient = initCapabilitiesGLX(true); + } + + return capabilitiesGLXClient; + } + + /** + * Returns the GLX capabilities. + * + *This method may only be used on Linux.
+ */ + public static GLXCapabilities getCapabilitiesGLX() { + if (capabilitiesGLX == null) { + capabilitiesGLX = initCapabilitiesGLX(false); + } + + return capabilitiesGLX; + } + + private static GLXCapabilities initCapabilitiesGLX(boolean client) { + long display = nXOpenDisplay(NULL); + try { + return createCapabilitiesGLX(display, client ? -1 : XDefaultScreen(display)); + } finally { + XCloseDisplay(display); + } + } + + /** + * Creates a new {@link GLCapabilities} instance for the OpenGL context that is current in the current thread. + * + *Depending on the current context, the instance returned may or may not contain the deprecated functionality removed since OpenGL version 3.1.
+ * + *This method calls {@link #setCapabilities(GLCapabilities)} with the new instance before returning.
+ * + * @return the GLCapabilities instance + */ + public static GLCapabilities createCapabilities() { + return createCapabilities(false); + } + + /** + * Creates a new {@link GLCapabilities} instance for the OpenGL context that is current in the current thread. + * + *Depending on the current context, the instance returned may or may not contain the deprecated functionality removed since OpenGL version 3.1. The + * {@code forwardCompatible} flag will force LWJGL to not load the deprecated functions, even if the current context exposes them.
+ * + *This method calls {@link #setCapabilities(GLCapabilities)} with the new instance before returning.
+ * + * @param forwardCompatible if true, LWJGL will create forward compatible capabilities + * + * @return the GLCapabilities instance + */ + @SuppressWarnings("AssignmentToMethodParameter") + public static GLCapabilities createCapabilities(boolean forwardCompatible) { + FunctionProvider functionProvider = GL.functionProvider; + if (functionProvider == null) { + throw new IllegalStateException("OpenGL library has not been loaded."); + } + + GLCapabilities caps = null; + + try { + // We don't have a current ContextCapabilities when this method is called + // so we have to use the native bindings directly. + long GetError = functionProvider.getFunctionAddress("glGetError"); + long GetString = functionProvider.getFunctionAddress("glGetString"); + long GetIntegerv = functionProvider.getFunctionAddress("glGetIntegerv"); + + if (GetError == NULL || GetString == NULL || GetIntegerv == NULL) { + throw new IllegalStateException("Core OpenGL functions could not be found. Make sure that the OpenGL library has been loaded correctly."); + } + + int errorCode = callI(GetError); + if (errorCode != GL_NO_ERROR) { + apiLog(String.format("An OpenGL context was in an error state before the creation of its capabilities instance. Error: 0x%X", errorCode)); + } + + int majorVersion; + int minorVersion; + + try (MemoryStack stack = stackPush()) { + IntBuffer version = stack.ints(0); + + // Try the 3.0+ version query first + callPV(GL_MAJOR_VERSION, memAddress(version), GetIntegerv); + if (callI(GetError) == GL_NO_ERROR && 3 <= (majorVersion = version.get(0))) { + // We're on an 3.0+ context. + callPV(GL_MINOR_VERSION, memAddress(version), GetIntegerv); + minorVersion = version.get(0); + } else { + // Fallback to the string query. + String versionString = memUTF8Safe(callP(GL_VERSION, GetString)); + if (versionString == null || callI(GetError) != GL_NO_ERROR) { + throw new IllegalStateException("There is no OpenGL context current in the current thread."); + } + + APIVersion apiVersion = apiParseVersion(versionString); + + majorVersion = apiVersion.major; + minorVersion = apiVersion.minor; + } + } + + if (majorVersion < 1 || (majorVersion == 1 && minorVersion < 1)) { + throw new IllegalStateException("OpenGL 1.1 is required."); + } + + int[] GL_VERSIONS = { + 5, // OpenGL 1.1 to 1.5 + 1, // OpenGL 2.0 to 2.1 + 3, // OpenGL 3.0 to 3.3 + 6, // OpenGL 4.0 to 4.6 + }; + + SetThis method may only be used on Windows.
+ */ + public static WGLCapabilities createCapabilitiesWGL() { + long hdc = wglGetCurrentDC(); + if (hdc == NULL) { + throw new IllegalStateException("Failed to retrieve the device context of the current OpenGL context"); + } + + return createCapabilitiesWGL(hdc); + } + + /** + * Creates a {@link WGLCapabilities} instance for the specified device context. + * + * @param hdc the device context handle ({@code HDC}) + */ + private static WGLCapabilities createCapabilitiesWGL(long hdc) { + FunctionProvider functionProvider = GL.functionProvider; + if (functionProvider == null) { + throw new IllegalStateException("OpenGL library has not been loaded."); + } + + String extensionsString = null; + + long wglGetExtensionsString = functionProvider.getFunctionAddress("wglGetExtensionsStringARB"); + if (wglGetExtensionsString != NULL) { + extensionsString = memASCII(callPP(hdc, wglGetExtensionsString)); + } else { + wglGetExtensionsString = functionProvider.getFunctionAddress("wglGetExtensionsStringEXT"); + if (wglGetExtensionsString != NULL) { + extensionsString = memASCII(callP(wglGetExtensionsString)); + } + } + + SetThis method may only be used on Linux.
+ * + * @param display the X connection handle ({@code DISPLAY}) + */ + public static GLXCapabilities createCapabilitiesGLX(long display) { + return createCapabilitiesGLX(display, XDefaultScreen(display)); + } + + /** + * Creates a {@link GLXCapabilities} instance for the specified screen of the specified X connection. + * + *This method may only be used on Linux.
+ * + * @param display the X connection handle ({@code DISPLAY}) + * @param screen the screen index + */ + public static GLXCapabilities createCapabilitiesGLX(long display, int screen) { + FunctionProvider functionProvider = GL.functionProvider; + if (functionProvider == null) { + throw new IllegalStateException("OpenGL library has not been loaded."); + } + + int majorVersion; + int minorVersion; + + try (MemoryStack stack = stackPush()) { + IntBuffer piMajor = stack.ints(0); + IntBuffer piMinor = stack.ints(0); + + if (!glXQueryVersion(display, piMajor, piMinor)) { + throw new IllegalStateException("Failed to query GLX version"); + } + + majorVersion = piMajor.get(0); + minorVersion = piMinor.get(0); + if (majorVersion != 1) { + throw new IllegalStateException("Invalid GLX major version: " + majorVersion); + } + } + + SetThis is the default implementation that skips the thread-local lookup. When a new GLCapabilities is set, we compare it to the write-once capabilities. + * If different function pointers are found, we fall back to the expensive lookup.
+ */ + private static class ICDStatic implements ICD { + + @Nullable + private static GLCapabilities tempCaps; + + @Override + public void set(@Nullable GLCapabilities caps) { + if (tempCaps == null) { + tempCaps = caps; + } else if (caps != null && caps != tempCaps && ThreadLocalUtil.areCapabilitiesDifferent(tempCaps.addresses, caps.addresses)) { + apiLog("[WARNING] Incompatible context detected. Falling back to thread-local lookup for GL contexts."); + icd = GL::getCapabilities; // fall back to thread/process lookup + } + } + + @Override + public GLCapabilities get() { + return WriteOnce.caps; + } + + private static final class WriteOnce { + // This will be initialized the first time get() above is called + @Nullable + static final GLCapabilities caps = ICDStatic.tempCaps; + + static { + if (caps == null) { + throw new IllegalStateException("No GLCapabilities instance has been set"); + } + } + } + + } + +} diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL11.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL11.java new file mode 100644 index 00000000..1a8e6ae4 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL11.java @@ -0,0 +1,10003 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * The OpenGL functionality up to version 1.1. Includes the deprecated symbols of the Compatibility Profile. + * + *Extensions promoted to core in this release:
+ * + *| {@link #GL_ACCUM ACCUM} | {@link #GL_LOAD LOAD} | {@link #GL_RETURN RETURN} | {@link #GL_MULT MULT} | {@link #GL_ADD ADD} |
| {@link #GL_NEVER NEVER} | {@link #GL_ALWAYS ALWAYS} | {@link #GL_LESS LESS} | {@link #GL_LEQUAL LEQUAL} | {@link #GL_EQUAL EQUAL} | {@link #GL_GEQUAL GEQUAL} | {@link #GL_GREATER GREATER} | {@link #GL_NOTEQUAL NOTEQUAL} |
| {@link #GL_POINTS POINTS} | {@link #GL_LINE_STRIP LINE_STRIP} | {@link #GL_LINE_LOOP LINE_LOOP} | {@link #GL_LINES LINES} | {@link #GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link #GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link #GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link #GL_POLYGON POLYGON} | {@link #GL_QUADS QUADS} |
| {@link #GL_QUAD_STRIP QUAD_STRIP} |
While a texture object is bound, GL operations on the target to which it is bound affect the bound object, and queries of the target to which it is + * bound return state from the bound object. If texture mapping of the dimensionality of the target to which a texture object is bound is enabled, the + * state of the bound texture object directs the texturing operation.
+ * + * @param target the texture target. One of:| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11C#GL_ZERO ZERO} | {@link GL11C#GL_ONE ONE} | {@link GL11C#GL_SRC_COLOR SRC_COLOR} | {@link GL11C#GL_ONE_MINUS_SRC_COLOR ONE_MINUS_SRC_COLOR} | {@link GL11C#GL_DST_COLOR DST_COLOR} |
| {@link GL11C#GL_ONE_MINUS_DST_COLOR ONE_MINUS_DST_COLOR} | {@link GL11C#GL_SRC_ALPHA SRC_ALPHA} | {@link GL11C#GL_ONE_MINUS_SRC_ALPHA ONE_MINUS_SRC_ALPHA} | {@link GL11C#GL_DST_ALPHA DST_ALPHA} | {@link GL11C#GL_ONE_MINUS_DST_ALPHA ONE_MINUS_DST_ALPHA} |
| {@link GL14#GL_CONSTANT_COLOR CONSTANT_COLOR} | {@link GL14#GL_ONE_MINUS_CONSTANT_COLOR ONE_MINUS_CONSTANT_COLOR} | {@link GL14#GL_CONSTANT_ALPHA CONSTANT_ALPHA} | {@link GL14#GL_ONE_MINUS_CONSTANT_ALPHA ONE_MINUS_CONSTANT_ALPHA} | {@link GL11C#GL_SRC_ALPHA_SATURATE SRC_ALPHA_SATURATE} |
| {@link GL33#GL_SRC1_COLOR SRC1_COLOR} | {@link GL33#GL_ONE_MINUS_SRC1_COLOR ONE_MINUS_SRC1_COLOR} | {@link GL15#GL_SRC1_ALPHA SRC1_ALPHA} | {@link GL33#GL_ONE_MINUS_SRC1_ALPHA ONE_MINUS_SRC1_ALPHA} |
| {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_INT INT} | {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_FLOAT FLOAT} | {@link #GL_2_BYTES 2_BYTES} | {@link #GL_3_BYTES 3_BYTES} | {@link #GL_4_BYTES 4_BYTES} |
| {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_INT INT} | {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_FLOAT FLOAT} | {@link #GL_2_BYTES 2_BYTES} | {@link #GL_3_BYTES 3_BYTES} | {@link #GL_4_BYTES 4_BYTES} |
| {@link GL11C#GL_COLOR_BUFFER_BIT COLOR_BUFFER_BIT} | {@link GL11C#GL_DEPTH_BUFFER_BIT DEPTH_BUFFER_BIT} | {@link GL11C#GL_STENCIL_BUFFER_BIT STENCIL_BUFFER_BIT} |
2m – 1, where {@code m} is the number of bits in a color index value stored in the
+ * framebuffer.
+ *
+ * @param index the value to which to clear the color buffer in color index mode
+ *
+ * @see Reference Page - This function is deprecated and unavailable in the Core profile
+ */
+ public static native void glClearIndex(@NativeType("GLfloat") float index);
+
+ // --- [ glClearStencil ] ---
+
+ /**
+ * Sets the value to which to clear the stencil buffer. {@code s} is masked to the number of bitplanes in the stencil buffer.
+ *
+ * @param s the value to which to clear the stencil buffer
+ *
+ * @see Reference Page
+ */
+ public static void glClearStencil(@NativeType("GLint") int s) {
+ GL11C.glClearStencil(s);
+ }
+
+ // --- [ glClipPlane ] ---
+
+ /** Unsafe version of: {@link #glClipPlane ClipPlane} */
+ public static native void nglClipPlane(int plane, long equation);
+
+ /**
+ * Specifies a client-defined clip plane.
+ *
+ * The value of the first argument, {@code plane}, is a symbolic constant, CLIP_PLANEi, where i is an integer between 0 and n – 1, indicating one of + * n client-defined clip planes. {@code equation} is an array of four double-precision floating-point values. These are the coefficients of a plane + * equation in object coordinates: p1, p2, p3, and p4 (in that order).
+ * + * @param plane the clip plane to define + * @param equation the clip plane coefficients + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glClipPlane(@NativeType("GLenum") int plane, @NativeType("GLdouble const *") DoubleBuffer equation) { + if (CHECKS) { + check(equation, 4); + } + nglClipPlane(plane, memAddress(equation)); + } + + // --- [ glColor3b ] --- + + /** + * Sets the R, G, and B components of the current color. The alpha component is set to 1.0. + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor3b(@NativeType("GLbyte") byte red, @NativeType("GLbyte") byte green, @NativeType("GLbyte") byte blue); + + // --- [ glColor3s ] --- + + /** + * Short version of {@link #glColor3b Color3b} + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor3s(@NativeType("GLshort") short red, @NativeType("GLshort") short green, @NativeType("GLshort") short blue); + + // --- [ glColor3i ] --- + + /** + * Integer version of {@link #glColor3b Color3b} + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor3i(@NativeType("GLint") int red, @NativeType("GLint") int green, @NativeType("GLint") int blue); + + // --- [ glColor3f ] --- + + /** + * Float version of {@link #glColor3b Color3b} + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor3f(@NativeType("GLfloat") float red, @NativeType("GLfloat") float green, @NativeType("GLfloat") float blue); + + // --- [ glColor3d ] --- + + /** + * Double version of {@link #glColor3b Color3b} + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor3d(@NativeType("GLdouble") double red, @NativeType("GLdouble") double green, @NativeType("GLdouble") double blue); + + // --- [ glColor3ub ] --- + + /** + * Unsigned version of {@link #glColor3b Color3b} + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor3ub(@NativeType("GLubyte") byte red, @NativeType("GLubyte") byte green, @NativeType("GLubyte") byte blue); + + // --- [ glColor3us ] --- + + /** + * Unsigned short version of {@link #glColor3b Color3b} + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor3us(@NativeType("GLushort") short red, @NativeType("GLushort") short green, @NativeType("GLushort") short blue); + + // --- [ glColor3ui ] --- + + /** + * Unsigned int version of {@link #glColor3b Color3b} + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor3ui(@NativeType("GLint") int red, @NativeType("GLint") int green, @NativeType("GLint") int blue); + + // --- [ glColor3bv ] --- + + /** Unsafe version of: {@link #glColor3bv Color3bv} */ + public static native void nglColor3bv(long v); + + /** + * Byte pointer version of {@link #glColor3b Color3b}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor3bv(@NativeType("GLbyte const *") ByteBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglColor3bv(memAddress(v)); + } + + // --- [ glColor3sv ] --- + + /** Unsafe version of: {@link #glColor3sv Color3sv} */ + public static native void nglColor3sv(long v); + + /** + * Pointer version of {@link #glColor3s Color3s}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor3sv(@NativeType("GLshort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglColor3sv(memAddress(v)); + } + + // --- [ glColor3iv ] --- + + /** Unsafe version of: {@link #glColor3iv Color3iv} */ + public static native void nglColor3iv(long v); + + /** + * Pointer version of {@link #glColor3i Color3i}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor3iv(@NativeType("GLint const *") IntBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglColor3iv(memAddress(v)); + } + + // --- [ glColor3fv ] --- + + /** Unsafe version of: {@link #glColor3fv Color3fv} */ + public static native void nglColor3fv(long v); + + /** + * Pointer version of {@link #glColor3f Color3f}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor3fv(@NativeType("GLfloat const *") FloatBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglColor3fv(memAddress(v)); + } + + // --- [ glColor3dv ] --- + + /** Unsafe version of: {@link #glColor3dv Color3dv} */ + public static native void nglColor3dv(long v); + + /** + * Pointer version of {@link #glColor3d Color3d}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor3dv(@NativeType("GLdouble const *") DoubleBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglColor3dv(memAddress(v)); + } + + // --- [ glColor3ubv ] --- + + /** Unsafe version of: {@link #glColor3ubv Color3ubv} */ + public static native void nglColor3ubv(long v); + + /** + * Pointer version of {@link #glColor3ub Color3ub}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor3ubv(@NativeType("GLubyte const *") ByteBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglColor3ubv(memAddress(v)); + } + + // --- [ glColor3usv ] --- + + /** Unsafe version of: {@link #glColor3usv Color3usv} */ + public static native void nglColor3usv(long v); + + /** + * Pointer version of {@link #glColor3us Color3us}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor3usv(@NativeType("GLushort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglColor3usv(memAddress(v)); + } + + // --- [ glColor3uiv ] --- + + /** Unsafe version of: {@link #glColor3uiv Color3uiv} */ + public static native void nglColor3uiv(long v); + + /** + * Pointer version of {@link #glColor3ui Color3ui}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor3uiv(@NativeType("GLuint const *") IntBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglColor3uiv(memAddress(v)); + } + + // --- [ glColor4b ] --- + + /** + * Sets the current color. + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * @param alpha the alpha component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor4b(@NativeType("GLbyte") byte red, @NativeType("GLbyte") byte green, @NativeType("GLbyte") byte blue, @NativeType("GLbyte") byte alpha); + + // --- [ glColor4s ] --- + + /** + * Short version of {@link #glColor4b Color4b} + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * @param alpha the alpha component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor4s(@NativeType("GLshort") short red, @NativeType("GLshort") short green, @NativeType("GLshort") short blue, @NativeType("GLshort") short alpha); + + // --- [ glColor4i ] --- + + /** + * Integer version of {@link #glColor4b Color4b} + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * @param alpha the alpha component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor4i(@NativeType("GLint") int red, @NativeType("GLint") int green, @NativeType("GLint") int blue, @NativeType("GLint") int alpha); + + // --- [ glColor4f ] --- + + /** + * Float version of {@link #glColor4b Color4b} + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * @param alpha the alpha component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor4f(@NativeType("GLfloat") float red, @NativeType("GLfloat") float green, @NativeType("GLfloat") float blue, @NativeType("GLfloat") float alpha); + + // --- [ glColor4d ] --- + + /** + * Double version of {@link #glColor4b Color4b} + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * @param alpha the alpha component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor4d(@NativeType("GLdouble") double red, @NativeType("GLdouble") double green, @NativeType("GLdouble") double blue, @NativeType("GLdouble") double alpha); + + // --- [ glColor4ub ] --- + + /** + * Unsigned version of {@link #glColor4b Color4b} + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * @param alpha the alpha component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor4ub(@NativeType("GLubyte") byte red, @NativeType("GLubyte") byte green, @NativeType("GLubyte") byte blue, @NativeType("GLubyte") byte alpha); + + // --- [ glColor4us ] --- + + /** + * Unsigned short version of {@link #glColor4b Color4b} + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * @param alpha the alpha component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor4us(@NativeType("GLushort") short red, @NativeType("GLushort") short green, @NativeType("GLushort") short blue, @NativeType("GLushort") short alpha); + + // --- [ glColor4ui ] --- + + /** + * Unsigned int version of {@link #glColor4b Color4b} + * + * @param red the red component of the current color + * @param green the green component of the current color + * @param blue the blue component of the current color + * @param alpha the alpha component of the current color + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glColor4ui(@NativeType("GLint") int red, @NativeType("GLint") int green, @NativeType("GLint") int blue, @NativeType("GLint") int alpha); + + // --- [ glColor4bv ] --- + + /** Unsafe version of: {@link #glColor4bv Color4bv} */ + public static native void nglColor4bv(long v); + + /** + * Pointer version of {@link #glColor4b Color4b}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor4bv(@NativeType("GLbyte const *") ByteBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglColor4bv(memAddress(v)); + } + + // --- [ glColor4sv ] --- + + /** Unsafe version of: {@link #glColor4sv Color4sv} */ + public static native void nglColor4sv(long v); + + /** + * Pointer version of {@link #glColor4s Color4s}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor4sv(@NativeType("GLshort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglColor4sv(memAddress(v)); + } + + // --- [ glColor4iv ] --- + + /** Unsafe version of: {@link #glColor4iv Color4iv} */ + public static native void nglColor4iv(long v); + + /** + * Pointer version of {@link #glColor4i Color4i}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor4iv(@NativeType("GLint const *") IntBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglColor4iv(memAddress(v)); + } + + // --- [ glColor4fv ] --- + + /** Unsafe version of: {@link #glColor4fv Color4fv} */ + public static native void nglColor4fv(long v); + + /** + * Pointer version of {@link #glColor4f Color4f}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor4fv(@NativeType("GLfloat const *") FloatBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglColor4fv(memAddress(v)); + } + + // --- [ glColor4dv ] --- + + /** Unsafe version of: {@link #glColor4dv Color4dv} */ + public static native void nglColor4dv(long v); + + /** + * Pointer version of {@link #glColor4d Color4d}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor4dv(@NativeType("GLdouble const *") DoubleBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglColor4dv(memAddress(v)); + } + + // --- [ glColor4ubv ] --- + + /** Unsafe version of: {@link #glColor4ubv Color4ubv} */ + public static native void nglColor4ubv(long v); + + /** + * Pointer version of {@link #glColor4ub Color4ub}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor4ubv(@NativeType("GLubyte const *") ByteBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglColor4ubv(memAddress(v)); + } + + // --- [ glColor4usv ] --- + + /** Unsafe version of: {@link #glColor4usv Color4usv} */ + public static native void nglColor4usv(long v); + + /** + * Pointer version of {@link #glColor4us Color4us}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor4usv(@NativeType("GLushort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglColor4usv(memAddress(v)); + } + + // --- [ glColor4uiv ] --- + + /** Unsafe version of: {@link #glColor4uiv Color4uiv} */ + public static native void nglColor4uiv(long v); + + /** + * Pointer version of {@link #glColor4ui Color4ui}. + * + * @param v the color buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor4uiv(@NativeType("GLuint const *") IntBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglColor4uiv(memAddress(v)); + } + + // --- [ glColorMask ] --- + + /** + * Masks the writing of R, G, B and A values to all draw buffers. In the initial state, all color values are enabled for writing for all draw buffers. + * + * @param red whether R values are written or not + * @param green whether G values are written or not + * @param blue whether B values are written or not + * @param alpha whether A values are written or not + * + * @see Reference Page + */ + public static void glColorMask(@NativeType("GLboolean") boolean red, @NativeType("GLboolean") boolean green, @NativeType("GLboolean") boolean blue, @NativeType("GLboolean") boolean alpha) { + GL11C.glColorMask(red, green, blue, alpha); + } + + // --- [ glColorMaterial ] --- + + /** + * It is possible to attach one or more material properties to the current color, so that they continuously track its component values. This behavior is + * enabled and disabled by calling {@link #glEnable Enable} or {@link #glDisable Disable} with the symbolic value {@link #GL_COLOR_MATERIAL COLOR_MATERIAL}. This function controls which + * of these modes is selected. + * + * @param face specifies which material face is affected by the current color. One of:| {@link #GL_FRONT FRONT} | {@link #GL_BACK BACK} | {@link #GL_FRONT_AND_BACK FRONT_AND_BACK} |
| {@link #GL_EMISSION EMISSION} | {@link #GL_AMBIENT AMBIENT} | {@link #GL_DIFFUSE DIFFUSE} | {@link #GL_SPECULAR SPECULAR} | {@link #GL_AMBIENT_AND_DIFFUSE AMBIENT_AND_DIFFUSE} |
| 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_INT INT} | {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_INT INT} | {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_INT INT} | {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_INT INT} | {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_INT INT} | {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| {@link #GL_COLOR COLOR} | {@link #GL_STENCIL STENCIL} | {@link #GL_DEPTH DEPTH} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_FRONT FRONT} | {@link GL11C#GL_BACK BACK} | {@link GL11C#GL_FRONT_AND_BACK FRONT_AND_BACK} |
| {@link GL11C#GL_NEVER NEVER} | {@link GL11C#GL_ALWAYS ALWAYS} | {@link GL11C#GL_LESS LESS} | {@link GL11C#GL_LEQUAL LEQUAL} | {@link GL11C#GL_EQUAL EQUAL} | {@link GL11C#GL_GREATER GREATER} | {@link GL11C#GL_GEQUAL GEQUAL} | {@link GL11C#GL_NOTEQUAL NOTEQUAL} |
If the {@link NVVertexBufferUnifiedMemory} extension is supported, this function is available even in a core profile context.
+ * + * @param cap the capability to disable. One of:| {@link #GL_COLOR_ARRAY COLOR_ARRAY} | {@link #GL_EDGE_FLAG_ARRAY EDGE_FLAG_ARRAY} | {@link GL15#GL_FOG_COORD_ARRAY FOG_COORD_ARRAY} | {@link #GL_INDEX_ARRAY INDEX_ARRAY} |
| {@link #GL_NORMAL_ARRAY NORMAL_ARRAY} | {@link GL14#GL_SECONDARY_COLOR_ARRAY SECONDARY_COLOR_ARRAY} | {@link #GL_TEXTURE_COORD_ARRAY TEXTURE_COORD_ARRAY} | {@link #GL_VERTEX_ARRAY VERTEX_ARRAY} |
| {@link NVVertexBufferUnifiedMemory#GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV VERTEX_ATTRIB_ARRAY_UNIFIED_NV} | {@link NVVertexBufferUnifiedMemory#GL_ELEMENT_ARRAY_UNIFIED_NV ELEMENT_ARRAY_UNIFIED_NV} |
first + count – 1 of each enabled non-instanced array are transferred to the GL.
+ *
+ * If an array corresponding to an attribute required by a vertex shader is not enabled, then the corresponding element is taken from the current attribute + * state. If an array is enabled, the corresponding current vertex attribute value is unaffected by the execution of this function.
+ * + * @param mode the kind of primitives being constructed + * @param first the first vertex to transfer to the GL + * @param count the number of vertices after {@code first} to transfer to the GL + * + * @see Reference Page + */ + public static void glDrawArrays(@NativeType("GLenum") int mode, @NativeType("GLint") int first, @NativeType("GLsizei") int count) { + GL11C.glDrawArrays(mode, first, count); + } + + // --- [ glDrawBuffer ] --- + + /** + * Defines the color buffer to which fragment color zero is written. + * + *Acceptable values for {@code buf} depend on whether the GL is using the default framebuffer (i.e., {@link GL30#GL_DRAW_FRAMEBUFFER_BINDING DRAW_FRAMEBUFFER_BINDING} is zero), or + * a framebuffer object (i.e., {@link GL30#GL_DRAW_FRAMEBUFFER_BINDING DRAW_FRAMEBUFFER_BINDING} is non-zero). In the initial state, the GL is bound to the default framebuffer.
+ * + * @param buf the color buffer to draw to. One of:| {@link GL11C#GL_NONE NONE} | {@link GL11C#GL_FRONT_LEFT FRONT_LEFT} | {@link GL11C#GL_FRONT_RIGHT FRONT_RIGHT} | {@link GL11C#GL_BACK_LEFT BACK_LEFT} | {@link GL11C#GL_BACK_RIGHT BACK_RIGHT} | {@link GL11C#GL_FRONT FRONT} | {@link GL11C#GL_BACK BACK} | {@link GL11C#GL_LEFT LEFT} |
| {@link GL11C#GL_RIGHT RIGHT} | {@link GL11C#GL_FRONT_AND_BACK FRONT_AND_BACK} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11C#GL_POINTS POINTS} | {@link GL11C#GL_LINE_STRIP LINE_STRIP} | {@link GL11C#GL_LINE_LOOP LINE_LOOP} | {@link GL11C#GL_LINES LINES} | {@link GL11C#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11C#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11C#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11C#GL_POINTS POINTS} | {@link GL11C#GL_LINE_STRIP LINE_STRIP} | {@link GL11C#GL_LINE_LOOP LINE_LOOP} | {@link GL11C#GL_LINES LINES} | {@link GL11C#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11C#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11C#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11C#GL_POINTS POINTS} | {@link GL11C#GL_LINE_STRIP LINE_STRIP} | {@link GL11C#GL_LINE_LOOP LINE_LOOP} | {@link GL11C#GL_LINES LINES} | {@link GL11C#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11C#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11C#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11C#GL_POINTS POINTS} | {@link GL11C#GL_LINE_STRIP LINE_STRIP} | {@link GL11C#GL_LINE_LOOP LINE_LOOP} | {@link GL11C#GL_LINES LINES} | {@link GL11C#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11C#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11C#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11C#GL_POINTS POINTS} | {@link GL11C#GL_LINE_STRIP LINE_STRIP} | {@link GL11C#GL_LINE_LOOP LINE_LOOP} | {@link GL11C#GL_LINES LINES} | {@link GL11C#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11C#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11C#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link #GL_LUMINANCE LUMINANCE} | {@link #GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_BITMAP BITMAP} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link #GL_LUMINANCE LUMINANCE} | {@link #GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_BITMAP BITMAP} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link #GL_LUMINANCE LUMINANCE} | {@link #GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_BITMAP BITMAP} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link #GL_LUMINANCE LUMINANCE} | {@link #GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_BITMAP BITMAP} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link #GL_LUMINANCE LUMINANCE} | {@link #GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_BITMAP BITMAP} |
When a primitive of type {@link #GL_POLYGON POLYGON}, {@link #GL_TRIANGLES TRIANGLES}, or {@link #GL_QUADS QUADS} is drawn, each vertex transferred begins an edge. If the edge + * flag bit is TRUE, then each specified vertex begins an edge that is flagged as boundary. If the bit is FALSE, then induced edges are flagged as + * non-boundary.
+ * + * @param flag the edge flag bit + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glEdgeFlag(@NativeType("GLboolean") boolean flag); + + // --- [ glEdgeFlagv ] --- + + /** Unsafe version of: {@link #glEdgeFlagv EdgeFlagv} */ + public static native void nglEdgeFlagv(long flag); + + /** + * Pointer version of {@link #glEdgeFlag EdgeFlag}. + * + * @param flag the edge flag buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glEdgeFlagv(@NativeType("GLboolean const *") ByteBuffer flag) { + if (CHECKS) { + check(flag, 1); + } + nglEdgeFlagv(memAddress(flag)); + } + + // --- [ glEdgeFlagPointer ] --- + + /** Unsafe version of: {@link #glEdgeFlagPointer EdgeFlagPointer} */ + public static native void nglEdgeFlagPointer(int stride, long pointer); + + /** + * Specifies the location and organization of an edge flag array. + * + * @param stride the vertex stride in bytes. If specified as zero, then array elements are stored sequentially + * @param pointer the edge flag array data + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glEdgeFlagPointer(@NativeType("GLsizei") int stride, @NativeType("GLboolean const *") ByteBuffer pointer) { + nglEdgeFlagPointer(stride, memAddress(pointer)); + } + + /** + * Specifies the location and organization of an edge flag array. + * + * @param stride the vertex stride in bytes. If specified as zero, then array elements are stored sequentially + * @param pointer the edge flag array data + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glEdgeFlagPointer(@NativeType("GLsizei") int stride, @NativeType("GLboolean const *") long pointer) { + nglEdgeFlagPointer(stride, pointer); + } + + // --- [ glEnableClientState ] --- + + /** + * Enables a client-side capability. + * + *If the {@link NVVertexBufferUnifiedMemory} extension is supported, this function is available even in a core profile context.
+ * + * @param cap the capability to enable. One of:| {@link #GL_COLOR_ARRAY COLOR_ARRAY} | {@link #GL_EDGE_FLAG_ARRAY EDGE_FLAG_ARRAY} | {@link GL15#GL_FOG_COORD_ARRAY FOG_COORD_ARRAY} | {@link #GL_INDEX_ARRAY INDEX_ARRAY} |
| {@link #GL_NORMAL_ARRAY NORMAL_ARRAY} | {@link GL14#GL_SECONDARY_COLOR_ARRAY SECONDARY_COLOR_ARRAY} | {@link #GL_TEXTURE_COORD_ARRAY TEXTURE_COORD_ARRAY} | {@link #GL_VERTEX_ARRAY VERTEX_ARRAY} |
| {@link NVVertexBufferUnifiedMemory#GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV VERTEX_ATTRIB_ARRAY_UNIFIED_NV} | {@link NVVertexBufferUnifiedMemory#GL_ELEMENT_ARRAY_UNIFIED_NV ELEMENT_ARRAY_UNIFIED_NV} |
| {@link #GL_POINT POINT} | {@link #GL_LINE LINE} |
| {@link #GL_FILL FILL} | {@link #GL_LINE LINE} | {@link #GL_POINT POINT} |
| {@link #GL_2D 2D} | {@link #GL_3D 3D} | {@link #GL_3D_COLOR 3D_COLOR} | {@link #GL_3D_COLOR_TEXTURE 3D_COLOR_TEXTURE} | {@link #GL_4D_COLOR_TEXTURE 4D_COLOR_TEXTURE} |
| {@link #GL_FOG_MODE FOG_MODE} | {@link GL15#GL_FOG_COORD_SRC FOG_COORD_SRC} |
| {@link #GL_EXP EXP} | {@link #GL_EXP2 EXP2} | {@link #GL_LINEAR LINEAR} | {@link GL14#GL_FRAGMENT_DEPTH FRAGMENT_DEPTH} | {@link GL15#GL_FOG_COORD FOG_COORD} |
| {@link #GL_FOG_MODE FOG_MODE} | {@link GL15#GL_FOG_COORD_SRC FOG_COORD_SRC} |
| {@link #GL_FOG_DENSITY FOG_DENSITY} | {@link #GL_FOG_START FOG_START} | {@link #GL_FOG_END FOG_END} |
| {@link #GL_FOG_DENSITY FOG_DENSITY} | {@link #GL_FOG_START FOG_START} | {@link #GL_FOG_END FOG_END} |
| {@link GL11C#GL_CCW CCW} | {@link GL11C#GL_CW CW} |
Unused names in textures that have been marked as used for the purposes of {@link #glGenTextures GenTextures} are marked as unused again. Unused names in textures are + * silently ignored, as is the name zero.
+ * + * @param textures contains {@code n} names of texture objects to be deleted + * + * @see Reference Page + */ + public static void glDeleteTextures(@NativeType("GLuint const *") IntBuffer textures) { + GL11C.glDeleteTextures(textures); + } + + /** + * Deletes texture objects. After a texture object is deleted, it has no contents or dimensionality, and its name is again unused. If a texture that is + * currently bound to any of the target bindings of {@link #glBindTexture BindTexture} is deleted, it is as though {@link #glBindTexture BindTexture} had been executed with the + * same target and texture zero. Additionally, special care must be taken when deleting a texture if any of the images of the texture are attached to a + * framebuffer object. + * + *Unused names in textures that have been marked as used for the purposes of {@link #glGenTextures GenTextures} are marked as unused again. Unused names in textures are + * silently ignored, as is the name zero.
+ * + * @see Reference Page + */ + public static void glDeleteTextures(@NativeType("GLuint const *") int texture) { + GL11C.glDeleteTextures(texture); + } + + // --- [ glGetClipPlane ] --- + + /** Unsafe version of: {@link #glGetClipPlane GetClipPlane} */ + public static native void nglGetClipPlane(int plane, long equation); + + /** + * Returns four double-precision values in {@code equation}; these are the coefficients of the plane equation of plane in eye coordinates (these + * coordinates are those that were computed when the plane was specified). + * + * @param plane the clip plane + * @param equation a buffer in which to place the returned values + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetClipPlane(@NativeType("GLenum") int plane, @NativeType("GLdouble *") DoubleBuffer equation) { + if (CHECKS) { + check(equation, 4); + } + nglGetClipPlane(plane, memAddress(equation)); + } + + // --- [ glGetBooleanv ] --- + + /** Unsafe version of: {@link #glGetBooleanv GetBooleanv} */ + public static void nglGetBooleanv(int pname, long params) { + GL11C.nglGetBooleanv(pname, params); + } + + /** + * Returns the current boolean value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * @param params a scalar or buffer in which to place the returned data + * + * @see Reference Page + */ + public static void glGetBooleanv(@NativeType("GLenum") int pname, @NativeType("GLboolean *") ByteBuffer params) { + GL11C.glGetBooleanv(pname, params); + } + + /** + * Returns the current boolean value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * + * @see Reference Page + */ + @NativeType("void") + public static boolean glGetBoolean(@NativeType("GLenum") int pname) { + return GL11C.glGetBoolean(pname); + } + + // --- [ glGetFloatv ] --- + + /** Unsafe version of: {@link #glGetFloatv GetFloatv} */ + public static void nglGetFloatv(int pname, long params) { + GL11C.nglGetFloatv(pname, params); + } + + /** + * Returns the current float value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * @param params a scalar or buffer in which to place the returned data + * + * @see Reference Page + */ + public static void glGetFloatv(@NativeType("GLenum") int pname, @NativeType("GLfloat *") FloatBuffer params) { + GL11C.glGetFloatv(pname, params); + } + + /** + * Returns the current float value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * + * @see Reference Page + */ + @NativeType("void") + public static float glGetFloat(@NativeType("GLenum") int pname) { + return GL11C.glGetFloat(pname); + } + + // --- [ glGetIntegerv ] --- + + /** Unsafe version of: {@link #glGetIntegerv GetIntegerv} */ + public static void nglGetIntegerv(int pname, long params) { + GL11C.nglGetIntegerv(pname, params); + } + + /** + * Returns the current integer value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * @param params a scalar or buffer in which to place the returned data + * + * @see Reference Page + */ + public static void glGetIntegerv(@NativeType("GLenum") int pname, @NativeType("GLint *") IntBuffer params) { + GL11C.glGetIntegerv(pname, params); + } + + /** + * Returns the current integer value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * + * @see Reference Page + */ + @NativeType("void") + public static int glGetInteger(@NativeType("GLenum") int pname) { + return GL11C.glGetInteger(pname); + } + + // --- [ glGetDoublev ] --- + + /** Unsafe version of: {@link #glGetDoublev GetDoublev} */ + public static void nglGetDoublev(int pname, long params) { + GL11C.nglGetDoublev(pname, params); + } + + /** + * Returns the current double value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * @param params a scalar or buffer in which to place the returned data + * + * @see Reference Page + */ + public static void glGetDoublev(@NativeType("GLenum") int pname, @NativeType("GLdouble *") DoubleBuffer params) { + GL11C.glGetDoublev(pname, params); + } + + /** + * Returns the current double value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * + * @see Reference Page + */ + @NativeType("void") + public static double glGetDouble(@NativeType("GLenum") int pname) { + return GL11C.glGetDouble(pname); + } + + // --- [ glGetError ] --- + + /** + * Returns error information. + * + *Each detectable error is assigned a numeric code. When an error is detected, a flag is set and the code is recorded. Further errors, if they occur, do + * not affect this recorded code. When {@code GetError} is called, the code is returned and the flag is cleared, so that a further error will again record + * its code. If a call to {@code GetError} returns {@link GL11C#GL_NO_ERROR NO_ERROR}, then there has been no detectable error since the last call to {@code GetError} (or since + * the GL was initialized).
+ * + * @see Reference Page + */ + @NativeType("GLenum") + public static int glGetError() { + return GL11C.glGetError(); + } + + // --- [ glGetLightiv ] --- + + /** Unsafe version of: {@link #glGetLightiv GetLightiv} */ + public static native void nglGetLightiv(int light, int pname, long data); + + /** + * Returns integer information about light parameter {@code pname} for {@code light} in {@code data}. + * + * @param light the light for which to return information. One of:| {@link #GL_LIGHT0 LIGHT0} | GL_LIGHT[1-7] |
| {@link #GL_AMBIENT AMBIENT} | {@link #GL_DIFFUSE DIFFUSE} | {@link #GL_SPECULAR SPECULAR} | {@link #GL_POSITION POSITION} | {@link #GL_CONSTANT_ATTENUATION CONSTANT_ATTENUATION} | {@link #GL_LINEAR_ATTENUATION LINEAR_ATTENUATION} |
| {@link #GL_QUADRATIC_ATTENUATION QUADRATIC_ATTENUATION} | {@link #GL_SPOT_DIRECTION SPOT_DIRECTION} | {@link #GL_SPOT_EXPONENT SPOT_EXPONENT} | {@link #GL_SPOT_CUTOFF SPOT_CUTOFF} |
| {@link #GL_LIGHT0 LIGHT0} | GL_LIGHT[1-7] |
| {@link #GL_AMBIENT AMBIENT} | {@link #GL_DIFFUSE DIFFUSE} | {@link #GL_SPECULAR SPECULAR} | {@link #GL_POSITION POSITION} | {@link #GL_CONSTANT_ATTENUATION CONSTANT_ATTENUATION} | {@link #GL_LINEAR_ATTENUATION LINEAR_ATTENUATION} |
| {@link #GL_QUADRATIC_ATTENUATION QUADRATIC_ATTENUATION} | {@link #GL_SPOT_DIRECTION SPOT_DIRECTION} | {@link #GL_SPOT_EXPONENT SPOT_EXPONENT} | {@link #GL_SPOT_CUTOFF SPOT_CUTOFF} |
| {@link #GL_MAP1_VERTEX_3 MAP1_VERTEX_3} | {@link #GL_MAP1_VERTEX_4 MAP1_VERTEX_4} | {@link #GL_MAP1_COLOR_4 MAP1_COLOR_4} | {@link #GL_MAP1_NORMAL MAP1_NORMAL} | {@link #GL_MAP1_TEXTURE_COORD_1 MAP1_TEXTURE_COORD_1} |
| {@link #GL_MAP1_TEXTURE_COORD_2 MAP1_TEXTURE_COORD_2} | {@link #GL_MAP1_TEXTURE_COORD_3 MAP1_TEXTURE_COORD_3} | {@link #GL_MAP1_TEXTURE_COORD_4 MAP1_TEXTURE_COORD_4} | {@link #GL_MAP2_VERTEX_3 MAP2_VERTEX_3} | {@link #GL_MAP2_VERTEX_4 MAP2_VERTEX_4} |
| {@link #GL_MAP2_COLOR_4 MAP2_COLOR_4} | {@link #GL_MAP2_NORMAL MAP2_NORMAL} | {@link #GL_MAP2_TEXTURE_COORD_1 MAP2_TEXTURE_COORD_1} | {@link #GL_MAP2_TEXTURE_COORD_2 MAP2_TEXTURE_COORD_2} | {@link #GL_MAP2_TEXTURE_COORD_3 MAP2_TEXTURE_COORD_3} |
| {@link #GL_MAP2_TEXTURE_COORD_4 MAP2_TEXTURE_COORD_4} |
| {@link #GL_ORDER ORDER} | {@link #GL_COEFF COEFF} | {@link #GL_DOMAIN DOMAIN} |
| {@link #GL_MAP1_VERTEX_3 MAP1_VERTEX_3} | {@link #GL_MAP1_VERTEX_4 MAP1_VERTEX_4} | {@link #GL_MAP1_COLOR_4 MAP1_COLOR_4} | {@link #GL_MAP1_NORMAL MAP1_NORMAL} | {@link #GL_MAP1_TEXTURE_COORD_1 MAP1_TEXTURE_COORD_1} |
| {@link #GL_MAP1_TEXTURE_COORD_2 MAP1_TEXTURE_COORD_2} | {@link #GL_MAP1_TEXTURE_COORD_3 MAP1_TEXTURE_COORD_3} | {@link #GL_MAP1_TEXTURE_COORD_4 MAP1_TEXTURE_COORD_4} | {@link #GL_MAP2_VERTEX_3 MAP2_VERTEX_3} | {@link #GL_MAP2_VERTEX_4 MAP2_VERTEX_4} |
| {@link #GL_MAP2_COLOR_4 MAP2_COLOR_4} | {@link #GL_MAP2_NORMAL MAP2_NORMAL} | {@link #GL_MAP2_TEXTURE_COORD_1 MAP2_TEXTURE_COORD_1} | {@link #GL_MAP2_TEXTURE_COORD_2 MAP2_TEXTURE_COORD_2} | {@link #GL_MAP2_TEXTURE_COORD_3 MAP2_TEXTURE_COORD_3} |
| {@link #GL_MAP2_TEXTURE_COORD_4 MAP2_TEXTURE_COORD_4} |
| {@link #GL_ORDER ORDER} | {@link #GL_COEFF COEFF} | {@link #GL_DOMAIN DOMAIN} |
| {@link #GL_FRONT FRONT} | {@link #GL_BACK BACK} |
| {@link #GL_AMBIENT AMBIENT} | {@link #GL_DIFFUSE DIFFUSE} | {@link #GL_SPECULAR SPECULAR} | {@link #GL_EMISSION EMISSION} | {@link #GL_SHININESS SHININESS} |
| {@link #GL_PIXEL_MAP_I_TO_I PIXEL_MAP_I_TO_I} | {@link #GL_PIXEL_MAP_S_TO_S PIXEL_MAP_S_TO_S} | {@link #GL_PIXEL_MAP_I_TO_R PIXEL_MAP_I_TO_R} | {@link #GL_PIXEL_MAP_I_TO_G PIXEL_MAP_I_TO_G} | {@link #GL_PIXEL_MAP_I_TO_B PIXEL_MAP_I_TO_B} |
| {@link #GL_PIXEL_MAP_I_TO_A PIXEL_MAP_I_TO_A} | {@link #GL_PIXEL_MAP_R_TO_R PIXEL_MAP_R_TO_R} | {@link #GL_PIXEL_MAP_G_TO_G PIXEL_MAP_G_TO_G} | {@link #GL_PIXEL_MAP_B_TO_B PIXEL_MAP_B_TO_B} | {@link #GL_PIXEL_MAP_A_TO_A PIXEL_MAP_A_TO_A} |
| {@link #GL_PIXEL_MAP_I_TO_I PIXEL_MAP_I_TO_I} | {@link #GL_PIXEL_MAP_S_TO_S PIXEL_MAP_S_TO_S} | {@link #GL_PIXEL_MAP_I_TO_R PIXEL_MAP_I_TO_R} | {@link #GL_PIXEL_MAP_I_TO_G PIXEL_MAP_I_TO_G} | {@link #GL_PIXEL_MAP_I_TO_B PIXEL_MAP_I_TO_B} |
| {@link #GL_PIXEL_MAP_I_TO_A PIXEL_MAP_I_TO_A} | {@link #GL_PIXEL_MAP_R_TO_R PIXEL_MAP_R_TO_R} | {@link #GL_PIXEL_MAP_G_TO_G PIXEL_MAP_G_TO_G} | {@link #GL_PIXEL_MAP_B_TO_B PIXEL_MAP_B_TO_B} | {@link #GL_PIXEL_MAP_A_TO_A PIXEL_MAP_A_TO_A} |
| {@link GL43#GL_DEBUG_CALLBACK_FUNCTION DEBUG_CALLBACK_FUNCTION} | {@link GL43#GL_DEBUG_CALLBACK_USER_PARAM DEBUG_CALLBACK_USER_PARAM} |
| {@link GL43#GL_DEBUG_CALLBACK_FUNCTION DEBUG_CALLBACK_FUNCTION} | {@link GL43#GL_DEBUG_CALLBACK_USER_PARAM DEBUG_CALLBACK_USER_PARAM} |
| {@link GL11C#GL_RENDERER RENDERER} | {@link GL11C#GL_VENDOR VENDOR} | {@link GL11C#GL_EXTENSIONS EXTENSIONS} | {@link GL11C#GL_VERSION VERSION} | {@link GL20#GL_SHADING_LANGUAGE_VERSION SHADING_LANGUAGE_VERSION} |
| {@link GL20#GL_POINT_SPRITE POINT_SPRITE} | {@link #GL_TEXTURE_ENV TEXTURE_ENV} | {@link GL14#GL_TEXTURE_FILTER_CONTROL TEXTURE_FILTER_CONTROL} |
| {@link GL20#GL_COORD_REPLACE COORD_REPLACE} | {@link #GL_TEXTURE_ENV_MODE TEXTURE_ENV_MODE} | {@link #GL_TEXTURE_ENV_COLOR TEXTURE_ENV_COLOR} | {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL13#GL_COMBINE_RGB COMBINE_RGB} | {@link GL13#GL_COMBINE_ALPHA COMBINE_ALPHA} |
| {@link GL15#GL_SRC0_RGB SRC0_RGB} | {@link GL15#GL_SRC1_RGB SRC1_RGB} | {@link GL15#GL_SRC2_RGB SRC2_RGB} | {@link GL15#GL_SRC0_ALPHA SRC0_ALPHA} | {@link GL15#GL_SRC1_ALPHA SRC1_ALPHA} | {@link GL15#GL_SRC2_ALPHA SRC2_ALPHA} |
| {@link GL13#GL_OPERAND0_RGB OPERAND0_RGB} | {@link GL13#GL_OPERAND1_RGB OPERAND1_RGB} | {@link GL13#GL_OPERAND2_RGB OPERAND2_RGB} | {@link GL13#GL_OPERAND0_ALPHA OPERAND0_ALPHA} | {@link GL13#GL_OPERAND1_ALPHA OPERAND1_ALPHA} | {@link GL13#GL_OPERAND2_ALPHA OPERAND2_ALPHA} |
| {@link GL13#GL_RGB_SCALE RGB_SCALE} | {@link #GL_ALPHA_SCALE ALPHA_SCALE} |
| {@link GL20#GL_POINT_SPRITE POINT_SPRITE} | {@link #GL_TEXTURE_ENV TEXTURE_ENV} | {@link GL14#GL_TEXTURE_FILTER_CONTROL TEXTURE_FILTER_CONTROL} |
| {@link GL20#GL_COORD_REPLACE COORD_REPLACE} | {@link #GL_TEXTURE_ENV_MODE TEXTURE_ENV_MODE} | {@link #GL_TEXTURE_ENV_COLOR TEXTURE_ENV_COLOR} | {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL13#GL_COMBINE_RGB COMBINE_RGB} | {@link GL13#GL_COMBINE_ALPHA COMBINE_ALPHA} |
| {@link GL15#GL_SRC0_RGB SRC0_RGB} | {@link GL15#GL_SRC1_RGB SRC1_RGB} | {@link GL15#GL_SRC2_RGB SRC2_RGB} | {@link GL15#GL_SRC0_ALPHA SRC0_ALPHA} | {@link GL15#GL_SRC1_ALPHA SRC1_ALPHA} | {@link GL15#GL_SRC2_ALPHA SRC2_ALPHA} |
| {@link GL13#GL_OPERAND0_RGB OPERAND0_RGB} | {@link GL13#GL_OPERAND1_RGB OPERAND1_RGB} | {@link GL13#GL_OPERAND2_RGB OPERAND2_RGB} | {@link GL13#GL_OPERAND0_ALPHA OPERAND0_ALPHA} | {@link GL13#GL_OPERAND1_ALPHA OPERAND1_ALPHA} | {@link GL13#GL_OPERAND2_ALPHA OPERAND2_ALPHA} |
| {@link GL13#GL_RGB_SCALE RGB_SCALE} | {@link #GL_ALPHA_SCALE ALPHA_SCALE} |
| {@link #GL_S S} | {@link #GL_T T} | {@link #GL_R R} | {@link #GL_Q Q} |
| {@link #GL_EYE_PLANE EYE_PLANE} | {@link #GL_OBJECT_PLANE OBJECT_PLANE} | {@link #GL_TEXTURE_GEN_MODE TEXTURE_GEN_MODE} |
| {@link #GL_S S} | {@link #GL_T T} | {@link #GL_R R} | {@link #GL_Q Q} |
| {@link #GL_EYE_PLANE EYE_PLANE} | {@link #GL_OBJECT_PLANE OBJECT_PLANE} | {@link #GL_TEXTURE_GEN_MODE TEXTURE_GEN_MODE} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} | {@link GL11C#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} | {@link GL12#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11C#GL_TEXTURE_WIDTH TEXTURE_WIDTH} | {@link GL11C#GL_TEXTURE_HEIGHT TEXTURE_HEIGHT} | {@link GL12#GL_TEXTURE_DEPTH TEXTURE_DEPTH} | {@link GL32#GL_TEXTURE_SAMPLES TEXTURE_SAMPLES} |
| {@link GL32#GL_TEXTURE_FIXED_SAMPLE_LOCATIONS TEXTURE_FIXED_SAMPLE_LOCATIONS} | {@link GL11C#GL_TEXTURE_INTERNAL_FORMAT TEXTURE_INTERNAL_FORMAT} | {@link GL11C#GL_TEXTURE_RED_SIZE TEXTURE_RED_SIZE} | {@link GL11C#GL_TEXTURE_GREEN_SIZE TEXTURE_GREEN_SIZE} |
| {@link GL11C#GL_TEXTURE_BLUE_SIZE TEXTURE_BLUE_SIZE} | {@link GL11C#GL_TEXTURE_ALPHA_SIZE TEXTURE_ALPHA_SIZE} | {@link GL14#GL_TEXTURE_DEPTH_SIZE TEXTURE_DEPTH_SIZE} | {@link GL30#GL_TEXTURE_STENCIL_SIZE TEXTURE_STENCIL_SIZE} |
| {@link GL30#GL_TEXTURE_SHARED_SIZE TEXTURE_SHARED_SIZE} | {@link GL30#GL_TEXTURE_ALPHA_TYPE TEXTURE_ALPHA_TYPE} | {@link GL30#GL_TEXTURE_DEPTH_TYPE TEXTURE_DEPTH_TYPE} | {@link GL13#GL_TEXTURE_COMPRESSED TEXTURE_COMPRESSED} |
| {@link GL13#GL_TEXTURE_COMPRESSED_IMAGE_SIZE TEXTURE_COMPRESSED_IMAGE_SIZE} | {@link GL31#GL_TEXTURE_BUFFER_DATA_STORE_BINDING TEXTURE_BUFFER_DATA_STORE_BINDING} | {@link GL43#GL_TEXTURE_BUFFER_OFFSET TEXTURE_BUFFER_OFFSET} | {@link GL43#GL_TEXTURE_BUFFER_SIZE TEXTURE_BUFFER_SIZE} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} | {@link GL11C#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} | {@link GL12#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11C#GL_TEXTURE_WIDTH TEXTURE_WIDTH} | {@link GL11C#GL_TEXTURE_HEIGHT TEXTURE_HEIGHT} | {@link GL12#GL_TEXTURE_DEPTH TEXTURE_DEPTH} | {@link GL32#GL_TEXTURE_SAMPLES TEXTURE_SAMPLES} |
| {@link GL32#GL_TEXTURE_FIXED_SAMPLE_LOCATIONS TEXTURE_FIXED_SAMPLE_LOCATIONS} | {@link GL11C#GL_TEXTURE_INTERNAL_FORMAT TEXTURE_INTERNAL_FORMAT} | {@link GL11C#GL_TEXTURE_RED_SIZE TEXTURE_RED_SIZE} | {@link GL11C#GL_TEXTURE_GREEN_SIZE TEXTURE_GREEN_SIZE} |
| {@link GL11C#GL_TEXTURE_BLUE_SIZE TEXTURE_BLUE_SIZE} | {@link GL11C#GL_TEXTURE_ALPHA_SIZE TEXTURE_ALPHA_SIZE} | {@link GL14#GL_TEXTURE_DEPTH_SIZE TEXTURE_DEPTH_SIZE} | {@link GL30#GL_TEXTURE_STENCIL_SIZE TEXTURE_STENCIL_SIZE} |
| {@link GL30#GL_TEXTURE_SHARED_SIZE TEXTURE_SHARED_SIZE} | {@link GL30#GL_TEXTURE_ALPHA_TYPE TEXTURE_ALPHA_TYPE} | {@link GL30#GL_TEXTURE_DEPTH_TYPE TEXTURE_DEPTH_TYPE} | {@link GL13#GL_TEXTURE_COMPRESSED TEXTURE_COMPRESSED} |
| {@link GL13#GL_TEXTURE_COMPRESSED_IMAGE_SIZE TEXTURE_COMPRESSED_IMAGE_SIZE} | {@link GL31#GL_TEXTURE_BUFFER_DATA_STORE_BINDING TEXTURE_BUFFER_DATA_STORE_BINDING} | {@link GL43#GL_TEXTURE_BUFFER_OFFSET TEXTURE_BUFFER_OFFSET} | {@link GL43#GL_TEXTURE_BUFFER_SIZE TEXTURE_BUFFER_SIZE} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link GL11C#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL11C#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL11C#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link GL11C#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link GL11C#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
| {@link GL42#GL_IMAGE_FORMAT_COMPATIBILITY_TYPE IMAGE_FORMAT_COMPATIBILITY_TYPE} | {@link GL42#GL_TEXTURE_IMMUTABLE_FORMAT TEXTURE_IMMUTABLE_FORMAT} | {@link GL43#GL_TEXTURE_IMMUTABLE_LEVELS TEXTURE_IMMUTABLE_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LEVEL TEXTURE_VIEW_MIN_LEVEL} |
| {@link GL43#GL_TEXTURE_VIEW_NUM_LEVELS TEXTURE_VIEW_NUM_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LAYER TEXTURE_VIEW_MIN_LAYER} | {@link GL43#GL_TEXTURE_VIEW_NUM_LAYERS TEXTURE_VIEW_NUM_LAYERS} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link GL11C#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL11C#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL11C#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link GL11C#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link GL11C#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
| {@link GL42#GL_IMAGE_FORMAT_COMPATIBILITY_TYPE IMAGE_FORMAT_COMPATIBILITY_TYPE} | {@link GL42#GL_TEXTURE_IMMUTABLE_FORMAT TEXTURE_IMMUTABLE_FORMAT} | {@link GL43#GL_TEXTURE_IMMUTABLE_LEVELS TEXTURE_IMMUTABLE_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LEVEL TEXTURE_VIEW_MIN_LEVEL} |
| {@link GL43#GL_TEXTURE_VIEW_NUM_LEVELS TEXTURE_VIEW_NUM_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LAYER TEXTURE_VIEW_MIN_LAYER} | {@link GL43#GL_TEXTURE_VIEW_NUM_LAYERS TEXTURE_VIEW_NUM_LAYERS} |
| {@link GL11C#GL_LINE_SMOOTH_HINT LINE_SMOOTH_HINT} | {@link GL11C#GL_POLYGON_SMOOTH_HINT POLYGON_SMOOTH_HINT} | {@link GL13#GL_TEXTURE_COMPRESSION_HINT TEXTURE_COMPRESSION_HINT} |
| {@link GL20#GL_FRAGMENT_SHADER_DERIVATIVE_HINT FRAGMENT_SHADER_DERIVATIVE_HINT} |
| {@link GL11C#GL_FASTEST FASTEST} | {@link GL11C#GL_NICEST NICEST} | {@link GL11C#GL_DONT_CARE DONT_CARE} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} |
| {@link #GL_V2F V2F} | {@link #GL_V3F V3F} | {@link #GL_C4UB_V2F C4UB_V2F} | {@link #GL_C4UB_V3F C4UB_V3F} | {@link #GL_C3F_V3F C3F_V3F} | {@link #GL_N3F_V3F N3F_V3F} | {@link #GL_C4F_N3F_V3F C4F_N3F_V3F} | {@link #GL_T2F_V3F T2F_V3F} |
| {@link #GL_T4F_V4F T4F_V4F} | {@link #GL_T2F_C4UB_V3F T2F_C4UB_V3F} | {@link #GL_T2F_C3F_V3F T2F_C3F_V3F} | {@link #GL_T2F_N3F_V3F T2F_N3F_V3F} | {@link #GL_T2F_C4F_N3F_V3F T2F_C4F_N3F_V3F} | {@link #GL_T4F_C4F_N3F_V4F T4F_C4F_N3F_V4F} |
| {@link #GL_V2F V2F} | {@link #GL_V3F V3F} | {@link #GL_C4UB_V2F C4UB_V2F} | {@link #GL_C4UB_V3F C4UB_V3F} | {@link #GL_C3F_V3F C3F_V3F} | {@link #GL_N3F_V3F N3F_V3F} | {@link #GL_C4F_N3F_V3F C4F_N3F_V3F} | {@link #GL_T2F_V3F T2F_V3F} |
| {@link #GL_T4F_V4F T4F_V4F} | {@link #GL_T2F_C4UB_V3F T2F_C4UB_V3F} | {@link #GL_T2F_C3F_V3F T2F_C3F_V3F} | {@link #GL_T2F_N3F_V3F T2F_N3F_V3F} | {@link #GL_T2F_C4F_N3F_V3F T2F_C4F_N3F_V3F} | {@link #GL_T4F_C4F_N3F_V4F T4F_C4F_N3F_V4F} |
| {@link #GL_V2F V2F} | {@link #GL_V3F V3F} | {@link #GL_C4UB_V2F C4UB_V2F} | {@link #GL_C4UB_V3F C4UB_V3F} | {@link #GL_C3F_V3F C3F_V3F} | {@link #GL_N3F_V3F N3F_V3F} | {@link #GL_C4F_N3F_V3F C4F_N3F_V3F} | {@link #GL_T2F_V3F T2F_V3F} |
| {@link #GL_T4F_V4F T4F_V4F} | {@link #GL_T2F_C4UB_V3F T2F_C4UB_V3F} | {@link #GL_T2F_C3F_V3F T2F_C3F_V3F} | {@link #GL_T2F_N3F_V3F T2F_N3F_V3F} | {@link #GL_T2F_C4F_N3F_V3F T2F_C4F_N3F_V3F} | {@link #GL_T4F_C4F_N3F_V4F T4F_C4F_N3F_V4F} |
| {@link #GL_V2F V2F} | {@link #GL_V3F V3F} | {@link #GL_C4UB_V2F C4UB_V2F} | {@link #GL_C4UB_V3F C4UB_V3F} | {@link #GL_C3F_V3F C3F_V3F} | {@link #GL_N3F_V3F N3F_V3F} | {@link #GL_C4F_N3F_V3F C4F_N3F_V3F} | {@link #GL_T2F_V3F T2F_V3F} |
| {@link #GL_T4F_V4F T4F_V4F} | {@link #GL_T2F_C4UB_V3F T2F_C4UB_V3F} | {@link #GL_T2F_C3F_V3F T2F_C3F_V3F} | {@link #GL_T2F_N3F_V3F T2F_N3F_V3F} | {@link #GL_T2F_C4F_N3F_V3F T2F_C4F_N3F_V3F} | {@link #GL_T4F_C4F_N3F_V4F T4F_C4F_N3F_V4F} |
| {@link #GL_V2F V2F} | {@link #GL_V3F V3F} | {@link #GL_C4UB_V2F C4UB_V2F} | {@link #GL_C4UB_V3F C4UB_V3F} | {@link #GL_C3F_V3F C3F_V3F} | {@link #GL_N3F_V3F N3F_V3F} | {@link #GL_C4F_N3F_V3F C4F_N3F_V3F} | {@link #GL_T2F_V3F T2F_V3F} |
| {@link #GL_T4F_V4F T4F_V4F} | {@link #GL_T2F_C4UB_V3F T2F_C4UB_V3F} | {@link #GL_T2F_C3F_V3F T2F_C3F_V3F} | {@link #GL_T2F_N3F_V3F T2F_N3F_V3F} | {@link #GL_T2F_C4F_N3F_V3F T2F_C4F_N3F_V3F} | {@link #GL_T4F_C4F_N3F_V4F T4F_C4F_N3F_V4F} |
| {@link #GL_V2F V2F} | {@link #GL_V3F V3F} | {@link #GL_C4UB_V2F C4UB_V2F} | {@link #GL_C4UB_V3F C4UB_V3F} | {@link #GL_C3F_V3F C3F_V3F} | {@link #GL_N3F_V3F N3F_V3F} | {@link #GL_C4F_N3F_V3F C4F_N3F_V3F} | {@link #GL_T2F_V3F T2F_V3F} |
| {@link #GL_T4F_V4F T4F_V4F} | {@link #GL_T2F_C4UB_V3F T2F_C4UB_V3F} | {@link #GL_T2F_C3F_V3F T2F_C3F_V3F} | {@link #GL_T2F_N3F_V3F T2F_N3F_V3F} | {@link #GL_T2F_C4F_N3F_V3F T2F_C4F_N3F_V3F} | {@link #GL_T4F_C4F_N3F_V4F T4F_C4F_N3F_V4F} |
| {@link #GL_LIGHT_MODEL_AMBIENT LIGHT_MODEL_AMBIENT} | {@link #GL_LIGHT_MODEL_LOCAL_VIEWER LIGHT_MODEL_LOCAL_VIEWER} | {@link #GL_LIGHT_MODEL_TWO_SIDE LIGHT_MODEL_TWO_SIDE} |
| {@link GL12#GL_LIGHT_MODEL_COLOR_CONTROL LIGHT_MODEL_COLOR_CONTROL} |
| {@link #GL_LIGHT0 LIGHT0} | GL_LIGHT[1-7] |
| {@link #GL_AMBIENT AMBIENT} | {@link #GL_DIFFUSE DIFFUSE} | {@link #GL_SPECULAR SPECULAR} | {@link #GL_POSITION POSITION} | {@link #GL_CONSTANT_ATTENUATION CONSTANT_ATTENUATION} | {@link #GL_LINEAR_ATTENUATION LINEAR_ATTENUATION} |
| {@link #GL_QUADRATIC_ATTENUATION QUADRATIC_ATTENUATION} | {@link #GL_SPOT_DIRECTION SPOT_DIRECTION} | {@link #GL_SPOT_EXPONENT SPOT_EXPONENT} | {@link #GL_SPOT_CUTOFF SPOT_CUTOFF} |
The matrix is stored as 16 consecutive values, i.e. as:
+ * + *| a1 | a5 | a9 | a13 |
| a2 | a6 | a10 | a14 |
| a3 | a7 | a11 | a15 |
| a4 | a8 | a12 | a16 |
This differs from the standard row-major ordering for matrix elements. If the standard ordering is used, all of the subsequent transformation equations + * are transposed, and the columns representing vectors become rows.
+ * + * @param m the matrix data + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glLoadMatrixf(@NativeType("GLfloat const *") FloatBuffer m) { + if (CHECKS) { + check(m, 16); + } + nglLoadMatrixf(memAddress(m)); + } + + // --- [ glLoadMatrixd ] --- + + /** Unsafe version of: {@link #glLoadMatrixd LoadMatrixd} */ + public static native void nglLoadMatrixd(long m); + + /** + * Double version of {@link #glLoadMatrixf LoadMatrixf}. + * + * @param m the matrix data + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glLoadMatrixd(@NativeType("GLdouble const *") DoubleBuffer m) { + if (CHECKS) { + check(m, 16); + } + nglLoadMatrixd(memAddress(m)); + } + + // --- [ glLoadIdentity ] --- + + /** + * Sets the current matrix to the identity matrix. + * + *Calling this function is equivalent to calling {@link #glLoadMatrixf LoadMatrixf} with the following matrix:
+ * + *| 1 | 0 | 0 | 0 |
| 0 | 1 | 0 | 0 |
| 0 | 0 | 1 | 0 |
| 0 | 0 | 0 | 1 |
| {@link GL11C#GL_CLEAR CLEAR} | {@link GL11C#GL_AND AND} | {@link GL11C#GL_AND_REVERSE AND_REVERSE} | {@link GL11C#GL_COPY COPY} | {@link GL11C#GL_AND_INVERTED AND_INVERTED} | {@link GL11C#GL_NOOP NOOP} | {@link GL11C#GL_XOR XOR} | {@link GL11C#GL_OR OR} | {@link GL11C#GL_NOR NOR} | {@link GL11C#GL_EQUIV EQUIV} | {@link GL11C#GL_INVERT INVERT} | {@link GL11C#GL_OR_REVERSE OR_REVERSE} | {@link GL11C#GL_COPY_INVERTED COPY_INVERTED} |
| {@link GL11C#GL_OR_INVERTED OR_INVERTED} | {@link GL11C#GL_NAND NAND} | {@link GL11C#GL_SET SET} |
| {@link #GL_MAP1_VERTEX_3 MAP1_VERTEX_3} | {@link #GL_MAP1_VERTEX_4 MAP1_VERTEX_4} | {@link #GL_MAP1_COLOR_4 MAP1_COLOR_4} | {@link #GL_MAP1_NORMAL MAP1_NORMAL} | {@link #GL_MAP1_TEXTURE_COORD_1 MAP1_TEXTURE_COORD_1} |
| {@link #GL_MAP1_TEXTURE_COORD_2 MAP1_TEXTURE_COORD_2} | {@link #GL_MAP1_TEXTURE_COORD_3 MAP1_TEXTURE_COORD_3} | {@link #GL_MAP1_TEXTURE_COORD_4 MAP1_TEXTURE_COORD_4} |
uorder × vorder blocks of storage containing control points
+ *
+ * @see Reference Page - This function is deprecated and unavailable in the Core profile
+ */
+ public static void glMap2f(@NativeType("GLenum") int target, @NativeType("GLfloat") float u1, @NativeType("GLfloat") float u2, @NativeType("GLint") int ustride, @NativeType("GLint") int uorder, @NativeType("GLfloat") float v1, @NativeType("GLfloat") float v2, @NativeType("GLint") int vstride, @NativeType("GLint") int vorder, @NativeType("GLfloat const *") FloatBuffer points) {
+ if (CHECKS) {
+ check(points, ustride * uorder * vstride * vorder);
+ }
+ nglMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, memAddress(points));
+ }
+
+ // --- [ glMap2d ] ---
+
+ /** Unsafe version of: {@link #glMap2d Map2d} */
+ public static native void nglMap2d(int target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, long points);
+
+ /**
+ * Double version of {@link #glMap2f Map2f}.
+ *
+ * @param target the evaluator target
+ * @param u1 the first u-dimension endpoint of the pre-image rectangle of the map
+ * @param u2 the second u-dimension endpoint of the pre-image rectangle of the map
+ * @param ustride the number of values in the u-dimension in each block of storage
+ * @param uorder the polynomial order in the u-dimension
+ * @param v1 the first v-dimension endpoint of the pre-image rectangle of the map
+ * @param v2 the second v-dimension endpoint of the pre-image rectangle of the map
+ * @param vstride the number of values in the v-dimension in each block of storage
+ * @param vorder the polynomial order in the v-dimension
+ * @param points a set of uorder × vorder blocks of storage containing control points
+ *
+ * @see Reference Page - This function is deprecated and unavailable in the Core profile
+ */
+ public static void glMap2d(@NativeType("GLenum") int target, @NativeType("GLdouble") double u1, @NativeType("GLdouble") double u2, @NativeType("GLint") int ustride, @NativeType("GLint") int uorder, @NativeType("GLdouble") double v1, @NativeType("GLdouble") double v2, @NativeType("GLint") int vstride, @NativeType("GLint") int vorder, @NativeType("GLdouble const *") DoubleBuffer points) {
+ if (CHECKS) {
+ check(points, ustride * uorder * vstride * vorder);
+ }
+ nglMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, memAddress(points));
+ }
+
+ // --- [ glMapGrid1f ] ---
+
+ /**
+ * Defines a one-dimensional grid in the map evaluator domain.
+ *
+ * @param n the number of partitions of the interval
+ * @param u1 the first interval endpoint
+ * @param u2 the second interval endpoint
+ *
+ * @see Reference Page - This function is deprecated and unavailable in the Core profile
+ */
+ public static native void glMapGrid1f(@NativeType("GLint") int n, @NativeType("GLfloat") float u1, @NativeType("GLfloat") float u2);
+
+ // --- [ glMapGrid1d ] ---
+
+ /**
+ * Double version of {@link #glMapGrid1f MapGrid1f}.
+ *
+ * @param n the number of partitions of the interval
+ * @param u1 the first interval endpoint
+ * @param u2 the second interval endpoint
+ *
+ * @see Reference Page - This function is deprecated and unavailable in the Core profile
+ */
+ public static native void glMapGrid1d(@NativeType("GLint") int n, @NativeType("GLdouble") double u1, @NativeType("GLdouble") double u2);
+
+ // --- [ glMapGrid2f ] ---
+
+ /**
+ * Defines a two-dimensional grid in the map evaluator domain.
+ *
+ * @param un the number of partitions of the interval in the u-dimension
+ * @param u1 the first u-dimension interval endpoint
+ * @param u2 the second u-dimension interval endpoint
+ * @param vn the number of partitions of the interval in the v-dimension
+ * @param v1 the first v-dimension interval endpoint
+ * @param v2 the second v-dimension interval endpoint
+ *
+ * @see Reference Page - This function is deprecated and unavailable in the Core profile
+ */
+ public static native void glMapGrid2f(@NativeType("GLint") int un, @NativeType("GLfloat") float u1, @NativeType("GLfloat") float u2, @NativeType("GLint") int vn, @NativeType("GLfloat") float v1, @NativeType("GLfloat") float v2);
+
+ // --- [ glMapGrid2d ] ---
+
+ /**
+ * Double version of {@link #glMapGrid2f MapGrid2f}.
+ *
+ * @param un the number of partitions of the interval in the u-dimension
+ * @param u1 the first u-dimension interval endpoint
+ * @param u2 the second u-dimension interval endpoint
+ * @param vn the number of partitions of the interval in the v-dimension
+ * @param v1 the first v-dimension interval endpoint
+ * @param v2 the second v-dimension interval endpoint
+ *
+ * @see Reference Page - This function is deprecated and unavailable in the Core profile
+ */
+ public static native void glMapGrid2d(@NativeType("GLint") int un, @NativeType("GLdouble") double u1, @NativeType("GLdouble") double u2, @NativeType("GLint") int vn, @NativeType("GLdouble") double v1, @NativeType("GLdouble") double v2);
+
+ // --- [ glMateriali ] ---
+
+ /**
+ * Sets the integer value of a material parameter.
+ *
+ * @param face the material face for which to set the parameter. One of:| {@link #GL_FRONT FRONT} | {@link #GL_BACK BACK} | {@link #GL_FRONT_AND_BACK FRONT_AND_BACK} |
| {@link #GL_SHININESS SHININESS} |
| {@link #GL_AMBIENT AMBIENT} | {@link #GL_DIFFUSE DIFFUSE} | {@link #GL_AMBIENT_AND_DIFFUSE AMBIENT_AND_DIFFUSE} | {@link #GL_SPECULAR SPECULAR} | {@link #GL_EMISSION EMISSION} |
| {@link #GL_MODELVIEW MODELVIEW} | {@link #GL_PROJECTION PROJECTION} | {@link #GL_TEXTURE TEXTURE} | {@link #GL_COLOR COLOR} |
(lb – n)T
+ * and (rt – n)T specify the points on the near clipping plane that are mapped to the lower left and upper right corners of the
+ * window, respectively (assuming that the eye is located at (0 0 0)T). {@code f} gives the distance from the eye to the far clipping
+ * plane.
+ *
+ * Calling this function is equivalent to calling {@link #glMultMatrixf MultMatrixf} with the following matrix:
+ * + *| 2n / (r - l) | 0 | (r + l) / (r - l) | 0 |
| 0 | 2n / (t - b) | (t + b) / (t - b) | 0 |
| 0 | 0 | - (f + n) / (f - n) | - (2fn) / (f - n) |
| 0 | 0 | -1 | 0 |
| {@link #GL_COMPILE COMPILE} | {@link #GL_COMPILE_AND_EXECUTE COMPILE_AND_EXECUTE} |
| {@link #GL_BYTE BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| {@link #GL_BYTE BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| {@link #GL_BYTE BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| {@link #GL_BYTE BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| {@link #GL_BYTE BYTE} | {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
(lb – n)T
+ * and (rt – n)T specify the points on the near clipping plane that are mapped to the lower left and upper right corners of the
+ * window, respectively (assuming that the eye is located at (0 0 0)T). {@code f} gives the distance from the eye to the far clipping
+ * plane.
+ *
+ * Calling this function is equivalent to calling {@link #glMultMatrixf MultMatrixf} with the following matrix:
+ * + *| 2 / (r - l) | 0 | 0 | - (r + l) / (r - l) |
| 0 | 2 / (t - b) | 0 | - (t + b) / (t - b) |
| 0 | 0 | - 2 / (f - n) | - (f + n) / (f - n) |
| 0 | 0 | 0 | 1 |
| {@link #GL_PIXEL_MAP_I_TO_I PIXEL_MAP_I_TO_I} | {@link #GL_PIXEL_MAP_S_TO_S PIXEL_MAP_S_TO_S} | {@link #GL_PIXEL_MAP_I_TO_R PIXEL_MAP_I_TO_R} | {@link #GL_PIXEL_MAP_I_TO_G PIXEL_MAP_I_TO_G} | {@link #GL_PIXEL_MAP_I_TO_B PIXEL_MAP_I_TO_B} |
| {@link #GL_PIXEL_MAP_I_TO_A PIXEL_MAP_I_TO_A} | {@link #GL_PIXEL_MAP_R_TO_R PIXEL_MAP_R_TO_R} | {@link #GL_PIXEL_MAP_G_TO_G PIXEL_MAP_G_TO_G} | {@link #GL_PIXEL_MAP_B_TO_B PIXEL_MAP_B_TO_B} | {@link #GL_PIXEL_MAP_A_TO_A PIXEL_MAP_A_TO_A} |
| {@link #GL_PIXEL_MAP_I_TO_I PIXEL_MAP_I_TO_I} | {@link #GL_PIXEL_MAP_S_TO_S PIXEL_MAP_S_TO_S} | {@link #GL_PIXEL_MAP_I_TO_R PIXEL_MAP_I_TO_R} | {@link #GL_PIXEL_MAP_I_TO_G PIXEL_MAP_I_TO_G} | {@link #GL_PIXEL_MAP_I_TO_B PIXEL_MAP_I_TO_B} |
| {@link #GL_PIXEL_MAP_I_TO_A PIXEL_MAP_I_TO_A} | {@link #GL_PIXEL_MAP_R_TO_R PIXEL_MAP_R_TO_R} | {@link #GL_PIXEL_MAP_G_TO_G PIXEL_MAP_G_TO_G} | {@link #GL_PIXEL_MAP_B_TO_B PIXEL_MAP_B_TO_B} | {@link #GL_PIXEL_MAP_A_TO_A PIXEL_MAP_A_TO_A} |
| {@link GL11C#GL_UNPACK_SWAP_BYTES UNPACK_SWAP_BYTES} | {@link GL11C#GL_UNPACK_LSB_FIRST UNPACK_LSB_FIRST} | {@link GL11C#GL_UNPACK_ROW_LENGTH UNPACK_ROW_LENGTH} |
| {@link GL11C#GL_UNPACK_SKIP_ROWS UNPACK_SKIP_ROWS} | {@link GL11C#GL_UNPACK_SKIP_PIXELS UNPACK_SKIP_PIXELS} | {@link GL11C#GL_UNPACK_ALIGNMENT UNPACK_ALIGNMENT} |
| {@link GL12#GL_UNPACK_IMAGE_HEIGHT UNPACK_IMAGE_HEIGHT} | {@link GL12#GL_UNPACK_SKIP_IMAGES UNPACK_SKIP_IMAGES} | {@link GL42#GL_UNPACK_COMPRESSED_BLOCK_WIDTH UNPACK_COMPRESSED_BLOCK_WIDTH} |
| {@link GL42#GL_UNPACK_COMPRESSED_BLOCK_HEIGHT UNPACK_COMPRESSED_BLOCK_HEIGHT} | {@link GL42#GL_UNPACK_COMPRESSED_BLOCK_DEPTH UNPACK_COMPRESSED_BLOCK_DEPTH} | {@link GL42#GL_UNPACK_COMPRESSED_BLOCK_SIZE UNPACK_COMPRESSED_BLOCK_SIZE} |
| {@link #GL_MAP_COLOR MAP_COLOR} | {@link #GL_MAP_STENCIL MAP_STENCIL} | {@link #GL_INDEX_SHIFT INDEX_SHIFT} | {@link #GL_INDEX_OFFSET INDEX_OFFSET} |
| {@link #GL_RED_SCALE RED_SCALE} | {@link #GL_GREEN_SCALE GREEN_SCALE} | {@link #GL_BLUE_SCALE BLUE_SCALE} | {@link #GL_ALPHA_SCALE ALPHA_SCALE} |
| {@link #GL_DEPTH_SCALE DEPTH_SCALE} | {@link #GL_RED_BIAS RED_BIAS} | {@link #GL_GREEN_BIAS GREEN_BIAS} | {@link #GL_BLUE_BIAS BLUE_BIAS} |
| {@link #GL_ALPHA_BIAS ALPHA_BIAS} | {@link #GL_DEPTH_BIAS DEPTH_BIAS} | {@link ARBImaging#GL_POST_CONVOLUTION_RED_SCALE POST_CONVOLUTION_RED_SCALE} | {@link ARBImaging#GL_POST_CONVOLUTION_RED_BIAS POST_CONVOLUTION_RED_BIAS} |
| {@link ARBImaging#GL_POST_COLOR_MATRIX_RED_SCALE POST_COLOR_MATRIX_RED_SCALE} | {@link ARBImaging#GL_POST_COLOR_MATRIX_RED_BIAS POST_COLOR_MATRIX_RED_BIAS} | {@link ARBImaging#GL_POST_CONVOLUTION_GREEN_SCALE POST_CONVOLUTION_GREEN_SCALE} | {@link ARBImaging#GL_POST_CONVOLUTION_GREEN_BIAS POST_CONVOLUTION_GREEN_BIAS} |
| {@link ARBImaging#GL_POST_COLOR_MATRIX_GREEN_SCALE POST_COLOR_MATRIX_GREEN_SCALE} | {@link ARBImaging#GL_POST_COLOR_MATRIX_GREEN_BIAS POST_COLOR_MATRIX_GREEN_BIAS} | {@link ARBImaging#GL_POST_CONVOLUTION_BLUE_SCALE POST_CONVOLUTION_BLUE_SCALE} | {@link ARBImaging#GL_POST_CONVOLUTION_BLUE_BIAS POST_CONVOLUTION_BLUE_BIAS} |
| {@link ARBImaging#GL_POST_COLOR_MATRIX_BLUE_SCALE POST_COLOR_MATRIX_BLUE_SCALE} | {@link ARBImaging#GL_POST_COLOR_MATRIX_BLUE_BIAS POST_COLOR_MATRIX_BLUE_BIAS} | {@link ARBImaging#GL_POST_CONVOLUTION_ALPHA_SCALE POST_CONVOLUTION_ALPHA_SCALE} | {@link ARBImaging#GL_POST_CONVOLUTION_ALPHA_BIAS POST_CONVOLUTION_ALPHA_BIAS} |
| {@link ARBImaging#GL_POST_COLOR_MATRIX_ALPHA_SCALE POST_COLOR_MATRIX_ALPHA_SCALE} | {@link ARBImaging#GL_POST_COLOR_MATRIX_ALPHA_BIAS POST_COLOR_MATRIX_ALPHA_BIAS} |
Let (xrp, yrp) be the current raster position. If a particular group is the nth in a row and belongs to the + * mth row, consider the region in window coordinates bounded by the rectangle with corners
+ * + *(xrp + zxn, yrp + zym) and (xrp + zx(n + 1), yrp + zy(m + 1))
+ * + *(either zx or zy may be negative). A fragment representing group {@code (n, m)} is produced for each framebuffer pixel inside, or + * on the bottom or left boundary, of this rectangle.
+ * + * @param xfactor the zx factor + * @param yfactor the zy factor + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glPixelZoom(@NativeType("GLfloat") float xfactor, @NativeType("GLfloat") float yfactor); + + // --- [ glPointSize ] --- + + /** + * Controls the rasterization of points if no vertex, tessellation control, tessellation evaluation, or geometry shader is active. The default point size is 1.0. + * + * @param size the request size of a point + * + * @see Reference Page + */ + public static void glPointSize(@NativeType("GLfloat") float size) { + GL11C.glPointSize(size); + } + + // --- [ glPolygonMode ] --- + + /** + * Controls the interpretation of polygons for rasterization. + * + *{@link GL11C#GL_FILL FILL} is the default mode of polygon rasterization. Note that these modes affect only the final rasterization of polygons: in particular, a + * polygon's vertices are lit, and the polygon is clipped and possibly culled before these modes are applied. Polygon antialiasing applies only to the + * {@link GL11C#GL_FILL FILL} state of PolygonMode. For {@link GL11C#GL_POINT POINT} or {@link GL11C#GL_LINE LINE}, point antialiasing or line segment antialiasing, respectively, apply.
+ * + * @param face the face for which to set the rasterizing method. One of:| {@link GL11C#GL_FRONT FRONT} | {@link GL11C#GL_BACK BACK} | {@link GL11C#GL_FRONT_AND_BACK FRONT_AND_BACK} |
| {@link GL11C#GL_POINT POINT} | {@link GL11C#GL_LINE LINE} | {@link GL11C#GL_FILL FILL} |
{@code factor} scales the maximum depth slope of the polygon, and {@code units} scales an implementation-dependent constant that relates to the usable + * resolution of the depth buffer. The resulting values are summed to produce the polygon offset value.
+ * + * @param factor the maximum depth slope factor + * @param units the constant scale + * + * @see Reference Page + */ + public static void glPolygonOffset(@NativeType("GLfloat") float factor, @NativeType("GLfloat") float units) { + GL11C.glPolygonOffset(factor, units); + } + + // --- [ glPolygonStipple ] --- + + /** Unsafe version of: {@link #glPolygonStipple PolygonStipple} */ + public static native void nglPolygonStipple(long pattern); + + /** + * Defines a polygon stipple. It works much the same way as {@link #glLineStipple LineStipple}, masking out certain fragments produced by rasterization so that they + * are not sent to the next stage of the GL. This is the case regardless of the state of polygon antialiasing. + * + *If xw and yw are the window coordinates of a rasterized polygon fragment, then that fragment is sent to the next stage of the GL + * if and only if the bit of the pattern (xw mod 32, yw mod 32) is 1.
+ * + *Polygon stippling may be enabled or disabled with {@link #glEnable Enable} or {@link #glDisable Disable} using the constant {@link #GL_POLYGON_STIPPLE POLYGON_STIPPLE}. When disabled, + * it is as if the stipple pattern were all ones.
+ * + * @param pattern a pointer to memory into which a 32 × 32 pattern is packed + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glPolygonStipple(@NativeType("GLubyte const *") ByteBuffer pattern) { + if (CHECKS) { + check(pattern, 128); + } + nglPolygonStipple(memAddress(pattern)); + } + + /** + * Defines a polygon stipple. It works much the same way as {@link #glLineStipple LineStipple}, masking out certain fragments produced by rasterization so that they + * are not sent to the next stage of the GL. This is the case regardless of the state of polygon antialiasing. + * + *If xw and yw are the window coordinates of a rasterized polygon fragment, then that fragment is sent to the next stage of the GL + * if and only if the bit of the pattern (xw mod 32, yw mod 32) is 1.
+ * + *Polygon stippling may be enabled or disabled with {@link #glEnable Enable} or {@link #glDisable Disable} using the constant {@link #GL_POLYGON_STIPPLE POLYGON_STIPPLE}. When disabled, + * it is as if the stipple pattern were all ones.
+ * + * @param pattern a pointer to memory into which a 32 × 32 pattern is packed + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glPolygonStipple(@NativeType("GLubyte const *") long pattern) { + nglPolygonStipple(pattern); + } + + // --- [ glPushAttrib ] --- + + /** + * Takes a bitwise OR of symbolic constants indicating which groups of state variables to push onto the server attribute stack. Each constant refers to a + * group of state variables. + * + *Bits set in mask that do not correspond to an attribute group are ignored. The special mask value {@link #GL_ALL_ATTRIB_BITS ALL_ATTRIB_BITS} may be used to push all + * stackable server state.
+ * + *A {@link #GL_STACK_OVERFLOW STACK_OVERFLOW} error is generated if {@code PushAttrib} is called and the attribute stack depth is equal to the value of + * {@link #GL_MAX_ATTRIB_STACK_DEPTH MAX_ATTRIB_STACK_DEPTH}.
+ * + * @param mask the state variables to push. One or more of:| {@link #GL_ACCUM_BUFFER_BIT ACCUM_BUFFER_BIT} | {@link #GL_COLOR_BUFFER_BIT COLOR_BUFFER_BIT} | {@link #GL_CURRENT_BIT CURRENT_BIT} | {@link #GL_DEPTH_BUFFER_BIT DEPTH_BUFFER_BIT} | {@link #GL_ENABLE_BIT ENABLE_BIT} | {@link #GL_EVAL_BIT EVAL_BIT} |
| {@link #GL_FOG_BIT FOG_BIT} | {@link #GL_HINT_BIT HINT_BIT} | {@link #GL_LIGHTING_BIT LIGHTING_BIT} | {@link #GL_LINE_BIT LINE_BIT} | {@link #GL_LIST_BIT LIST_BIT} | {@link GL13#GL_MULTISAMPLE_BIT MULTISAMPLE_BIT} |
| {@link #GL_PIXEL_MODE_BIT PIXEL_MODE_BIT} | {@link #GL_POINT_BIT POINT_BIT} | {@link #GL_POLYGON_BIT POLYGON_BIT} | {@link #GL_POLYGON_STIPPLE_BIT POLYGON_STIPPLE_BIT} | {@link #GL_SCISSOR_BIT SCISSOR_BIT} | {@link #GL_STENCIL_BUFFER_BIT STENCIL_BUFFER_BIT} |
| {@link #GL_TEXTURE_BIT TEXTURE_BIT} | {@link #GL_TRANSFORM_BIT TRANSFORM_BIT} | {@link #GL_VIEWPORT_BIT VIEWPORT_BIT} | {@link #GL_ALL_ATTRIB_BITS ALL_ATTRIB_BITS} |
Bits set in mask that do not correspond to an attribute group are ignored. The special mask value {@link #GL_CLIENT_ALL_ATTRIB_BITS CLIENT_ALL_ATTRIB_BITS} may be used to push + * all stackable client state.
+ * + *A {@link #GL_STACK_OVERFLOW STACK_OVERFLOW} error is generated if {@code PushAttrib} is called and the client attribute stack depth is equal to the value of + * {@link #GL_MAX_CLIENT_ATTRIB_STACK_DEPTH MAX_CLIENT_ATTRIB_STACK_DEPTH}.
+ * + * @param mask the state variables to push. One or more of:| {@link #GL_CLIENT_VERTEX_ARRAY_BIT CLIENT_VERTEX_ARRAY_BIT} | {@link #GL_CLIENT_PIXEL_STORE_BIT CLIENT_PIXEL_STORE_BIT} | {@link #GL_CLIENT_ALL_ATTRIB_BITS CLIENT_ALL_ATTRIB_BITS} |
The coordinates are treated as if they were specified in a Vertex command. If a vertex shader is active, this vertex shader is executed using the x, y, + * z, and w coordinates as the object coordinates of the vertex. Otherwise, the x, y, z, and w coordinates are transformed by the current model-view and + * projection matrices. These coordinates, along with current values, are used to generate primary and secondary colors and texture coordinates just as is + * done for a vertex. The colors and texture coordinates so produced replace the colors and texture coordinates stored in the current raster position's + * associated data.
+ * + * @param x the {@code x} raster coordinate + * @param y the {@code y} raster coordinate + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRasterPos2i(@NativeType("GLint") int x, @NativeType("GLint") int y); + + // --- [ glRasterPos2s ] --- + + /** + * Short version of {@link #glRasterPos2i RasterPos2i}. + * + * @param x the {@code x} raster coordinate + * @param y the {@code y} raster coordinate + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRasterPos2s(@NativeType("GLshort") short x, @NativeType("GLshort") short y); + + // --- [ glRasterPos2f ] --- + + /** + * Float version of {@link #glRasterPos2i RasterPos2i}. + * + * @param x the {@code x} raster coordinate + * @param y the {@code y} raster coordinate + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRasterPos2f(@NativeType("GLfloat") float x, @NativeType("GLfloat") float y); + + // --- [ glRasterPos2d ] --- + + /** + * Double version of {@link #glRasterPos2i RasterPos2i}. + * + * @param x the {@code x} raster coordinate + * @param y the {@code y} raster coordinate + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRasterPos2d(@NativeType("GLdouble") double x, @NativeType("GLdouble") double y); + + // --- [ glRasterPos2iv ] --- + + /** Unsafe version of: {@link #glRasterPos2iv RasterPos2iv} */ + public static native void nglRasterPos2iv(long coords); + + /** + * Pointer version of {@link #glRasterPos2i RasterPos2i}. + * + * @param coords the raster position buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos2iv(@NativeType("GLint const *") IntBuffer coords) { + if (CHECKS) { + check(coords, 2); + } + nglRasterPos2iv(memAddress(coords)); + } + + // --- [ glRasterPos2sv ] --- + + /** Unsafe version of: {@link #glRasterPos2sv RasterPos2sv} */ + public static native void nglRasterPos2sv(long coords); + + /** + * Pointer version of {@link #glRasterPos2s RasterPos2s}. + * + * @param coords the raster position buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos2sv(@NativeType("GLshort const *") ShortBuffer coords) { + if (CHECKS) { + check(coords, 2); + } + nglRasterPos2sv(memAddress(coords)); + } + + // --- [ glRasterPos2fv ] --- + + /** Unsafe version of: {@link #glRasterPos2fv RasterPos2fv} */ + public static native void nglRasterPos2fv(long coords); + + /** + * Pointer version of {@link #glRasterPos2f RasterPos2f}. + * + * @param coords the raster position buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos2fv(@NativeType("GLfloat const *") FloatBuffer coords) { + if (CHECKS) { + check(coords, 2); + } + nglRasterPos2fv(memAddress(coords)); + } + + // --- [ glRasterPos2dv ] --- + + /** Unsafe version of: {@link #glRasterPos2dv RasterPos2dv} */ + public static native void nglRasterPos2dv(long coords); + + /** + * Pointer version of {@link #glRasterPos2d RasterPos2d}. + * + * @param coords the raster position buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos2dv(@NativeType("GLdouble const *") DoubleBuffer coords) { + if (CHECKS) { + check(coords, 2); + } + nglRasterPos2dv(memAddress(coords)); + } + + // --- [ glRasterPos3i ] --- + + /** + * Sets the three-dimensional current raster position. {@code w} is implicitly set to 1. See {@link #glRasterPos2i RasterPos2i} for more details. + * + * @param x the {@code x} raster coordinate + * @param y the {@code y} raster coordinate + * @param z the {@code z} raster coordinate + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRasterPos3i(@NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLint") int z); + + // --- [ glRasterPos3s ] --- + + /** + * Short version of {@link #glRasterPos3i RasterPos3i}. + * + * @param x the {@code x} raster coordinate + * @param y the {@code y} raster coordinate + * @param z the {@code z} raster coordinate + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRasterPos3s(@NativeType("GLshort") short x, @NativeType("GLshort") short y, @NativeType("GLshort") short z); + + // --- [ glRasterPos3f ] --- + + /** + * Float version of {@link #glRasterPos3i RasterPos3i}. + * + * @param x the {@code x} raster coordinate + * @param y the {@code y} raster coordinate + * @param z the {@code z} raster coordinate + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRasterPos3f(@NativeType("GLfloat") float x, @NativeType("GLfloat") float y, @NativeType("GLfloat") float z); + + // --- [ glRasterPos3d ] --- + + /** + * Double version of {@link #glRasterPos3i RasterPos3i}. + * + * @param x the {@code x} raster coordinate + * @param y the {@code y} raster coordinate + * @param z the {@code z} raster coordinate + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRasterPos3d(@NativeType("GLdouble") double x, @NativeType("GLdouble") double y, @NativeType("GLdouble") double z); + + // --- [ glRasterPos3iv ] --- + + /** Unsafe version of: {@link #glRasterPos3iv RasterPos3iv} */ + public static native void nglRasterPos3iv(long coords); + + /** + * Pointer version of {@link #glRasterPos3i RasterPos3i}. + * + * @param coords the raster position buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos3iv(@NativeType("GLint const *") IntBuffer coords) { + if (CHECKS) { + check(coords, 3); + } + nglRasterPos3iv(memAddress(coords)); + } + + // --- [ glRasterPos3sv ] --- + + /** Unsafe version of: {@link #glRasterPos3sv RasterPos3sv} */ + public static native void nglRasterPos3sv(long coords); + + /** + * Pointer version of {@link #glRasterPos3s RasterPos3s}. + * + * @param coords the raster position buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos3sv(@NativeType("GLshort const *") ShortBuffer coords) { + if (CHECKS) { + check(coords, 3); + } + nglRasterPos3sv(memAddress(coords)); + } + + // --- [ glRasterPos3fv ] --- + + /** Unsafe version of: {@link #glRasterPos3fv RasterPos3fv} */ + public static native void nglRasterPos3fv(long coords); + + /** + * Pointer version of {@link #glRasterPos3f RasterPos3f}. + * + * @param coords the raster position buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos3fv(@NativeType("GLfloat const *") FloatBuffer coords) { + if (CHECKS) { + check(coords, 3); + } + nglRasterPos3fv(memAddress(coords)); + } + + // --- [ glRasterPos3dv ] --- + + /** Unsafe version of: {@link #glRasterPos3dv RasterPos3dv} */ + public static native void nglRasterPos3dv(long coords); + + /** + * Pointer version of {@link #glRasterPos3d RasterPos3d}. + * + * @param coords the raster position buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos3dv(@NativeType("GLdouble const *") DoubleBuffer coords) { + if (CHECKS) { + check(coords, 3); + } + nglRasterPos3dv(memAddress(coords)); + } + + // --- [ glRasterPos4i ] --- + + /** + * Sets the four-dimensional current raster position. See {@link #glRasterPos2i RasterPos2i} for more details. + * + * @param x the {@code x} raster coordinate + * @param y the {@code y} raster coordinate + * @param z the {@code z} raster coordinate + * @param w the {@code w} raster coordinate + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRasterPos4i(@NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLint") int z, @NativeType("GLint") int w); + + // --- [ glRasterPos4s ] --- + + /** + * Short version of {@link #glRasterPos4i RasterPos4i}. + * + * @param x the {@code x} raster coordinate + * @param y the {@code y} raster coordinate + * @param z the {@code z} raster coordinate + * @param w the {@code w} raster coordinate + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRasterPos4s(@NativeType("GLshort") short x, @NativeType("GLshort") short y, @NativeType("GLshort") short z, @NativeType("GLshort") short w); + + // --- [ glRasterPos4f ] --- + + /** + * Float version of RasterPos4i. + * + * @param x the {@code x} raster coordinate + * @param y the {@code y} raster coordinate + * @param z the {@code z} raster coordinate + * @param w the {@code w} raster coordinate + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRasterPos4f(@NativeType("GLfloat") float x, @NativeType("GLfloat") float y, @NativeType("GLfloat") float z, @NativeType("GLfloat") float w); + + // --- [ glRasterPos4d ] --- + + /** + * Double version of {@link #glRasterPos4i RasterPos4i}. + * + * @param x the {@code x} raster coordinate + * @param y the {@code y} raster coordinate + * @param z the {@code z} raster coordinate + * @param w the {@code w} raster coordinate + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRasterPos4d(@NativeType("GLdouble") double x, @NativeType("GLdouble") double y, @NativeType("GLdouble") double z, @NativeType("GLdouble") double w); + + // --- [ glRasterPos4iv ] --- + + /** Unsafe version of: {@link #glRasterPos4iv RasterPos4iv} */ + public static native void nglRasterPos4iv(long coords); + + /** + * Pointer version of {@link #glRasterPos4i RasterPos4i}. + * + * @param coords the raster position buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos4iv(@NativeType("GLint const *") IntBuffer coords) { + if (CHECKS) { + check(coords, 4); + } + nglRasterPos4iv(memAddress(coords)); + } + + // --- [ glRasterPos4sv ] --- + + /** Unsafe version of: {@link #glRasterPos4sv RasterPos4sv} */ + public static native void nglRasterPos4sv(long coords); + + /** + * Pointer version of {@link #glRasterPos4s RasterPos4s}. + * + * @param coords the raster position buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos4sv(@NativeType("GLshort const *") ShortBuffer coords) { + if (CHECKS) { + check(coords, 4); + } + nglRasterPos4sv(memAddress(coords)); + } + + // --- [ glRasterPos4fv ] --- + + /** Unsafe version of: {@link #glRasterPos4fv RasterPos4fv} */ + public static native void nglRasterPos4fv(long coords); + + /** + * Pointer version of {@link #glRasterPos4f RasterPos4f}. + * + * @param coords the raster position buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos4fv(@NativeType("GLfloat const *") FloatBuffer coords) { + if (CHECKS) { + check(coords, 4); + } + nglRasterPos4fv(memAddress(coords)); + } + + // --- [ glRasterPos4dv ] --- + + /** Unsafe version of: {@link #glRasterPos4dv RasterPos4dv} */ + public static native void nglRasterPos4dv(long coords); + + /** + * Pointer version of {@link #glRasterPos4d RasterPos4d}. + * + * @param coords the raster position buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos4dv(@NativeType("GLdouble const *") DoubleBuffer coords) { + if (CHECKS) { + check(coords, 4); + } + nglRasterPos4dv(memAddress(coords)); + } + + // --- [ glReadBuffer ] --- + + /** + * Defines the color buffer from which values are obtained. + * + *Acceptable values for {@code src} depend on whether the GL is using the default framebuffer (i.e., {@link GL30#GL_DRAW_FRAMEBUFFER_BINDING DRAW_FRAMEBUFFER_BINDING} is zero), or + * a framebuffer object (i.e., {@link GL30#GL_DRAW_FRAMEBUFFER_BINDING DRAW_FRAMEBUFFER_BINDING} is non-zero). In the initial state, the GL is bound to the default framebuffer.
+ * + * @param src the color buffer to read from. One of:| {@link GL11C#GL_NONE NONE} | {@link GL11C#GL_FRONT_LEFT FRONT_LEFT} | {@link GL11C#GL_FRONT_RIGHT FRONT_RIGHT} | {@link GL11C#GL_BACK_LEFT BACK_LEFT} | {@link GL11C#GL_BACK_RIGHT BACK_RIGHT} | {@link GL11C#GL_FRONT FRONT} | {@link GL11C#GL_BACK BACK} | {@link GL11C#GL_LEFT LEFT} |
| {@link GL11C#GL_RIGHT RIGHT} | {@link GL11C#GL_FRONT_AND_BACK FRONT_AND_BACK} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
{@code Rect(x1, y1, x2, y2);}
+ * + *is exactly the same as the following sequence of commands: + * {@code + * Begin(POLYGON); + * Vertex2(x1, y1); + * Vertex2(x2, y1); + * Vertex2(x2, y2); + * Vertex2(x1, y2); + * End();}
+ * + *The appropriate Vertex2 command would be invoked depending on which of the Rect commands is issued.
+ * + * @param x1 the x coordinate of the first corner vertex + * @param y1 the y coordinate of the first corner vertex + * @param x2 the x coordinate of the second corner vertex + * @param y2 the y coordinate of the second corner vertex + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRecti(@NativeType("GLint") int x1, @NativeType("GLint") int y1, @NativeType("GLint") int x2, @NativeType("GLint") int y2); + + // --- [ glRects ] --- + + /** + * Short version of {@link #glRecti Recti}. + * + * @param x1 the x coordinate of the first corner vertex + * @param y1 the y coordinate of the first corner vertex + * @param x2 the x coordinate of the second corner vertex + * @param y2 the y coordinate of the second corner vertex + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRects(@NativeType("GLshort") short x1, @NativeType("GLshort") short y1, @NativeType("GLshort") short x2, @NativeType("GLshort") short y2); + + // --- [ glRectf ] --- + + /** + * Float version of {@link #glRecti Recti}. + * + * @param x1 the x coordinate of the first corner vertex + * @param y1 the y coordinate of the first corner vertex + * @param x2 the x coordinate of the second corner vertex + * @param y2 the y coordinate of the second corner vertex + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRectf(@NativeType("GLfloat") float x1, @NativeType("GLfloat") float y1, @NativeType("GLfloat") float x2, @NativeType("GLfloat") float y2); + + // --- [ glRectd ] --- + + /** + * Double version of {@link #glRecti Recti}. + * + * @param x1 the x coordinate of the first corner vertex + * @param y1 the y coordinate of the first corner vertex + * @param x2 the x coordinate of the second corner vertex + * @param y2 the y coordinate of the second corner vertex + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glRectd(@NativeType("GLdouble") double x1, @NativeType("GLdouble") double y1, @NativeType("GLdouble") double x2, @NativeType("GLdouble") double y2); + + // --- [ glRectiv ] --- + + /** Unsafe version of: {@link #glRectiv Rectiv} */ + public static native void nglRectiv(long v1, long v2); + + /** + * Pointer version of {@link #glRecti Recti}. + * + * @param v1 the first vertex buffer + * @param v2 the second vertex buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRectiv(@NativeType("GLint const *") IntBuffer v1, @NativeType("GLint const *") IntBuffer v2) { + if (CHECKS) { + check(v1, 2); + check(v2, 2); + } + nglRectiv(memAddress(v1), memAddress(v2)); + } + + // --- [ glRectsv ] --- + + /** Unsafe version of: {@link #glRectsv Rectsv} */ + public static native void nglRectsv(long v1, long v2); + + /** + * Pointer version of {@link #glRects Rects}. + * + * @param v1 the first vertex buffer + * @param v2 the second vertex buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRectsv(@NativeType("GLshort const *") ShortBuffer v1, @NativeType("GLshort const *") ShortBuffer v2) { + if (CHECKS) { + check(v1, 2); + check(v2, 2); + } + nglRectsv(memAddress(v1), memAddress(v2)); + } + + // --- [ glRectfv ] --- + + /** Unsafe version of: {@link #glRectfv Rectfv} */ + public static native void nglRectfv(long v1, long v2); + + /** + * Pointer version of {@link #glRectf Rectf}. + * + * @param v1 the first vertex buffer + * @param v2 the second vertex buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRectfv(@NativeType("GLfloat const *") FloatBuffer v1, @NativeType("GLfloat const *") FloatBuffer v2) { + if (CHECKS) { + check(v1, 2); + check(v2, 2); + } + nglRectfv(memAddress(v1), memAddress(v2)); + } + + // --- [ glRectdv ] --- + + /** Unsafe version of: {@link #glRectdv Rectdv} */ + public static native void nglRectdv(long v1, long v2); + + /** + * Pointer version of {@link #glRectd Rectd}. + * + * @param v1 the first vertex buffer + * @param v2 the second vertex buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRectdv(@NativeType("GLdouble const *") DoubleBuffer v1, @NativeType("GLdouble const *") DoubleBuffer v2) { + if (CHECKS) { + check(v1, 2); + check(v2, 2); + } + nglRectdv(memAddress(v1), memAddress(v2)); + } + + // --- [ glRenderMode ] --- + + /** + * Sets the current render mode. The default is {@link #GL_RENDER RENDER}. + * + * @param mode the render mode. One of:| {@link #GL_RENDER RENDER} | {@link #GL_SELECT SELECT} | {@link #GL_FEEDBACK FEEDBACK} |
{@code angle} gives an angle of rotation in degrees; the coordinates of a vector v are given by v = (x y z)T. The computed matrix
+ * is a counter-clockwise rotation about the line through the origin with the specified axis when that axis is pointing up (i.e. the right-hand rule
+ * determines the sense of the rotation angle). The matrix is thus
| R | 0 | ||
| 0 | |||
| 0 | |||
| 0 | 0 | 0 | 1 |
Let u = v / ||v|| = (x' y' z')T. If S =
| 0 | -z' | y' |
| z' | 0 | -x' |
| -y' | x' | 0 |
then R = uuT + cos(angle)(I - uuT) + sin(angle)S
Calling this function is equivalent to calling {@link #glMultMatrixf MultMatrixf} with the following matrix:
+ * + *| x | 0 | 0 | 0 |
| 0 | y | 0 | 0 |
| 0 | 0 | z | 0 |
| 0 | 0 | 0 | 1 |
left ≤ xw < left + width and bottom ≤ yw < bottom + height for the scissor rectangle, then the scissor
+ * test passes. Otherwise, the test fails and the fragment is discarded.
+ *
+ * @param x the left scissor rectangle coordinate
+ * @param y the bottom scissor rectangle coordinate
+ * @param width the scissor rectangle width
+ * @param height the scissor rectangle height
+ *
+ * @see Reference Page
+ */
+ public static void glScissor(@NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height) {
+ GL11C.glScissor(x, y, width, height);
+ }
+
+ // --- [ glSelectBuffer ] ---
+
+ /**
+ * Unsafe version of: {@link #glSelectBuffer SelectBuffer}
+ *
+ * @param size the maximum number of values that can be stored in {@code buffer}
+ */
+ public static native void nglSelectBuffer(int size, long buffer);
+
+ /**
+ * Sets the selection array.
+ *
+ * @param buffer an array of unsigned integers to be potentially filled names
+ *
+ * @see Reference Page - This function is deprecated and unavailable in the Core profile
+ */
+ public static void glSelectBuffer(@NativeType("GLuint *") IntBuffer buffer) {
+ nglSelectBuffer(buffer.remaining(), memAddress(buffer));
+ }
+
+ // --- [ glShadeModel ] ---
+
+ /**
+ * Sets the current shade mode. The initial value of the shade mode is {@link #GL_SMOOTH SMOOTH}.
+ *
+ * If mode is {@link #GL_SMOOTH SMOOTH}, vertex colors are treated individually. If mode is {@link #GL_FLAT FLAT}, flatshading is enabled and colors are taken from the + * provoking vertex of the primitive. The colors selected are those derived from current values, generated by lighting, or generated by vertex shading, if + * lighting is disabled, enabled, or a vertex shader is in use, respectively.
+ * + * @param mode the shade mode. One of:| {@link #GL_SMOOTH SMOOTH} | {@link #GL_FLAT FLAT} |
{@code ref} is an integer reference value that is used in the unsigned stencil comparison. Stencil comparison operations and queries of {@code ref} + * clamp its value to the range [0, 2s – 1], where s is the number of bits in the stencil buffer attached to the draw framebuffer. The s + * least significant bits of {@code mask} are bitwise ANDed with both the reference and the stored stencil value, and the resulting masked values are those that + * participate in the comparison controlled by {@code func}.
+ * + * @param func the stencil comparison function. One of:| {@link GL11C#GL_NEVER NEVER} | {@link GL11C#GL_ALWAYS ALWAYS} | {@link GL11C#GL_LESS LESS} | {@link GL11C#GL_LEQUAL LEQUAL} | {@link GL11C#GL_EQUAL EQUAL} | {@link GL11C#GL_GEQUAL GEQUAL} | {@link GL11C#GL_GREATER GREATER} | {@link GL11C#GL_NOTEQUAL NOTEQUAL} |
The least significant s bits of {@code mask}, where s is the number of bits in the stencil buffer, specify an integer mask. Where a 1 appears in this + * mask, the corresponding bit in the stencil buffer is written; where a 0 appears, the bit is not written.
+ * + * @param mask the stencil mask + * + * @see Reference Page + */ + public static void glStencilMask(@NativeType("GLuint") int mask) { + GL11C.glStencilMask(mask); + } + + // --- [ glStencilOp ] --- + + /** + * Indicates what happens to the stored stencil value if this or certain subsequent tests fail or pass. + * + *The supported actions are {@link GL11C#GL_KEEP KEEP}, {@link GL11C#GL_ZERO ZERO}, {@link GL11C#GL_REPLACE REPLACE}, {@link GL11C#GL_INCR INCR}, {@link GL11C#GL_DECR DECR}, {@link GL11C#GL_INVERT INVERT}, + * {@link GL14#GL_INCR_WRAP INCR_WRAP} and {@link GL14#GL_DECR_WRAP DECR_WRAP}. These correspond to keeping the current value, setting to zero, replacing with the reference value, + * incrementing with saturation, decrementing with saturation, bitwise inverting it, incrementing without saturation, and decrementing without saturation.
+ * + *For purposes of increment and decrement, the stencil bits are considered as an unsigned integer. Incrementing or decrementing with saturation clamps + * the stencil value at 0 and the maximum representable value. Incrementing or decrementing without saturation will wrap such that incrementing the maximum + * representable value results in 0, and decrementing 0 results in the maximum representable value.
+ * + * @param sfail the action to take if the stencil test fails + * @param dpfail the action to take if the depth buffer test fails + * @param dppass the action to take if the depth buffer test passes + * + * @see Reference Page + */ + public static void glStencilOp(@NativeType("GLenum") int sfail, @NativeType("GLenum") int dpfail, @NativeType("GLenum") int dppass) { + GL11C.glStencilOp(sfail, dpfail, dppass); + } + + // --- [ glTexCoord1f ] --- + + /** + * Sets the current one-dimensional texture coordinate. {@code t} and {@code r} are implicitly set to 0 and {@code q} to 1. + * + * @param s the s component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord1f(@NativeType("GLfloat") float s); + + // --- [ glTexCoord1s ] --- + + /** + * Short version of {@link #glTexCoord1f TexCoord1f}. + * + * @param s the s component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord1s(@NativeType("GLshort") short s); + + // --- [ glTexCoord1i ] --- + + /** + * Integer version of {@link #glTexCoord1f TexCoord1f}. + * + * @param s the s component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord1i(@NativeType("GLint") int s); + + // --- [ glTexCoord1d ] --- + + /** + * Double version of {@link #glTexCoord1f TexCoord1f}. + * + * @param s the s component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord1d(@NativeType("GLdouble") double s); + + // --- [ glTexCoord1fv ] --- + + /** Unsafe version of: {@link #glTexCoord1fv TexCoord1fv} */ + public static native void nglTexCoord1fv(long v); + + /** + * Pointer version of {@link #glTexCoord1f TexCoord1f}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord1fv(@NativeType("GLfloat const *") FloatBuffer v) { + if (CHECKS) { + check(v, 1); + } + nglTexCoord1fv(memAddress(v)); + } + + // --- [ glTexCoord1sv ] --- + + /** Unsafe version of: {@link #glTexCoord1sv TexCoord1sv} */ + public static native void nglTexCoord1sv(long v); + + /** + * Pointer version of {@link #glTexCoord1s TexCoord1s}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord1sv(@NativeType("GLshort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 1); + } + nglTexCoord1sv(memAddress(v)); + } + + // --- [ glTexCoord1iv ] --- + + /** Unsafe version of: {@link #glTexCoord1iv TexCoord1iv} */ + public static native void nglTexCoord1iv(long v); + + /** + * Pointer version of {@link #glTexCoord1i TexCoord1i}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord1iv(@NativeType("GLint const *") IntBuffer v) { + if (CHECKS) { + check(v, 1); + } + nglTexCoord1iv(memAddress(v)); + } + + // --- [ glTexCoord1dv ] --- + + /** Unsafe version of: {@link #glTexCoord1dv TexCoord1dv} */ + public static native void nglTexCoord1dv(long v); + + /** + * Pointer version of {@link #glTexCoord1d TexCoord1d}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord1dv(@NativeType("GLdouble const *") DoubleBuffer v) { + if (CHECKS) { + check(v, 1); + } + nglTexCoord1dv(memAddress(v)); + } + + // --- [ glTexCoord2f ] --- + + /** + * Sets the current two-dimensional texture coordinate. {@code r} is implicitly set to 0 and {@code q} to 1. + * + * @param s the s component of the current texture coordinates + * @param t the t component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord2f(@NativeType("GLfloat") float s, @NativeType("GLfloat") float t); + + // --- [ glTexCoord2s ] --- + + /** + * Short version of {@link #glTexCoord2f TexCoord2f}. + * + * @param s the s component of the current texture coordinates + * @param t the t component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord2s(@NativeType("GLshort") short s, @NativeType("GLshort") short t); + + // --- [ glTexCoord2i ] --- + + /** + * Integer version of {@link #glTexCoord2f TexCoord2f}. + * + * @param s the s component of the current texture coordinates + * @param t the t component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord2i(@NativeType("GLint") int s, @NativeType("GLint") int t); + + // --- [ glTexCoord2d ] --- + + /** + * Double version of {@link #glTexCoord2f TexCoord2f}. + * + * @param s the s component of the current texture coordinates + * @param t the t component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord2d(@NativeType("GLdouble") double s, @NativeType("GLdouble") double t); + + // --- [ glTexCoord2fv ] --- + + /** Unsafe version of: {@link #glTexCoord2fv TexCoord2fv} */ + public static native void nglTexCoord2fv(long v); + + /** + * Pointer version of {@link #glTexCoord2f TexCoord2f}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord2fv(@NativeType("GLfloat const *") FloatBuffer v) { + if (CHECKS) { + check(v, 2); + } + nglTexCoord2fv(memAddress(v)); + } + + // --- [ glTexCoord2sv ] --- + + /** Unsafe version of: {@link #glTexCoord2sv TexCoord2sv} */ + public static native void nglTexCoord2sv(long v); + + /** + * Pointer version of {@link #glTexCoord2s TexCoord2s}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord2sv(@NativeType("GLshort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 2); + } + nglTexCoord2sv(memAddress(v)); + } + + // --- [ glTexCoord2iv ] --- + + /** Unsafe version of: {@link #glTexCoord2iv TexCoord2iv} */ + public static native void nglTexCoord2iv(long v); + + /** + * Pointer version of {@link #glTexCoord2i TexCoord2i}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord2iv(@NativeType("GLint const *") IntBuffer v) { + if (CHECKS) { + check(v, 2); + } + nglTexCoord2iv(memAddress(v)); + } + + // --- [ glTexCoord2dv ] --- + + /** Unsafe version of: {@link #glTexCoord2dv TexCoord2dv} */ + public static native void nglTexCoord2dv(long v); + + /** + * Pointer version of {@link #glTexCoord2d TexCoord2d}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord2dv(@NativeType("GLdouble const *") DoubleBuffer v) { + if (CHECKS) { + check(v, 2); + } + nglTexCoord2dv(memAddress(v)); + } + + // --- [ glTexCoord3f ] --- + + /** + * Sets the current three-dimensional texture coordinate. {@code q} is implicitly set to 1. + * + * @param s the s component of the current texture coordinates + * @param t the t component of the current texture coordinates + * @param r the r component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord3f(@NativeType("GLfloat") float s, @NativeType("GLfloat") float t, @NativeType("GLfloat") float r); + + // --- [ glTexCoord3s ] --- + + /** + * Short version of {@link #glTexCoord3f TexCoord3f}. + * + * @param s the s component of the current texture coordinates + * @param t the t component of the current texture coordinates + * @param r the r component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord3s(@NativeType("GLshort") short s, @NativeType("GLshort") short t, @NativeType("GLshort") short r); + + // --- [ glTexCoord3i ] --- + + /** + * Integer version of {@link #glTexCoord3f TexCoord3f}. + * + * @param s the s component of the current texture coordinates + * @param t the t component of the current texture coordinates + * @param r the r component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord3i(@NativeType("GLint") int s, @NativeType("GLint") int t, @NativeType("GLint") int r); + + // --- [ glTexCoord3d ] --- + + /** + * Double version of {@link #glTexCoord3f TexCoord3f}. + * + * @param s the s component of the current texture coordinates + * @param t the t component of the current texture coordinates + * @param r the r component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord3d(@NativeType("GLdouble") double s, @NativeType("GLdouble") double t, @NativeType("GLdouble") double r); + + // --- [ glTexCoord3fv ] --- + + /** Unsafe version of: {@link #glTexCoord3fv TexCoord3fv} */ + public static native void nglTexCoord3fv(long v); + + /** + * Pointer version of {@link #glTexCoord3f TexCoord3f}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord3fv(@NativeType("GLfloat const *") FloatBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglTexCoord3fv(memAddress(v)); + } + + // --- [ glTexCoord3sv ] --- + + /** Unsafe version of: {@link #glTexCoord3sv TexCoord3sv} */ + public static native void nglTexCoord3sv(long v); + + /** + * Pointer version of {@link #glTexCoord3s TexCoord3s}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord3sv(@NativeType("GLshort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglTexCoord3sv(memAddress(v)); + } + + // --- [ glTexCoord3iv ] --- + + /** Unsafe version of: {@link #glTexCoord3iv TexCoord3iv} */ + public static native void nglTexCoord3iv(long v); + + /** + * Pointer version of {@link #glTexCoord3i TexCoord3i}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord3iv(@NativeType("GLint const *") IntBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglTexCoord3iv(memAddress(v)); + } + + // --- [ glTexCoord3dv ] --- + + /** Unsafe version of: {@link #glTexCoord3dv TexCoord3dv} */ + public static native void nglTexCoord3dv(long v); + + /** + * Pointer version of {@link #glTexCoord3d TexCoord3d}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord3dv(@NativeType("GLdouble const *") DoubleBuffer v) { + if (CHECKS) { + check(v, 3); + } + nglTexCoord3dv(memAddress(v)); + } + + // --- [ glTexCoord4f ] --- + + /** + * Sets the current four-dimensional texture coordinate. + * + * @param s the s component of the current texture coordinates + * @param t the t component of the current texture coordinates + * @param r the r component of the current texture coordinates + * @param q the q component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord4f(@NativeType("GLfloat") float s, @NativeType("GLfloat") float t, @NativeType("GLfloat") float r, @NativeType("GLfloat") float q); + + // --- [ glTexCoord4s ] --- + + /** + * Short version of {@link #glTexCoord4f TexCoord4f}. + * + * @param s the s component of the current texture coordinates + * @param t the t component of the current texture coordinates + * @param r the r component of the current texture coordinates + * @param q the q component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord4s(@NativeType("GLshort") short s, @NativeType("GLshort") short t, @NativeType("GLshort") short r, @NativeType("GLshort") short q); + + // --- [ glTexCoord4i ] --- + + /** + * Integer version of {@link #glTexCoord4f TexCoord4f}. + * + * @param s the s component of the current texture coordinates + * @param t the t component of the current texture coordinates + * @param r the r component of the current texture coordinates + * @param q the q component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord4i(@NativeType("GLint") int s, @NativeType("GLint") int t, @NativeType("GLint") int r, @NativeType("GLint") int q); + + // --- [ glTexCoord4d ] --- + + /** + * Double version of {@link #glTexCoord4f TexCoord4f}. + * + * @param s the s component of the current texture coordinates + * @param t the t component of the current texture coordinates + * @param r the r component of the current texture coordinates + * @param q the q component of the current texture coordinates + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static native void glTexCoord4d(@NativeType("GLdouble") double s, @NativeType("GLdouble") double t, @NativeType("GLdouble") double r, @NativeType("GLdouble") double q); + + // --- [ glTexCoord4fv ] --- + + /** Unsafe version of: {@link #glTexCoord4fv TexCoord4fv} */ + public static native void nglTexCoord4fv(long v); + + /** + * Pointer version of {@link #glTexCoord4f TexCoord4f}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord4fv(@NativeType("GLfloat const *") FloatBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglTexCoord4fv(memAddress(v)); + } + + // --- [ glTexCoord4sv ] --- + + /** Unsafe version of: {@link #glTexCoord4sv TexCoord4sv} */ + public static native void nglTexCoord4sv(long v); + + /** + * Pointer version of {@link #glTexCoord4s TexCoord4s}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord4sv(@NativeType("GLshort const *") ShortBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglTexCoord4sv(memAddress(v)); + } + + // --- [ glTexCoord4iv ] --- + + /** Unsafe version of: {@link #glTexCoord4iv TexCoord4iv} */ + public static native void nglTexCoord4iv(long v); + + /** + * Pointer version of {@link #glTexCoord4i TexCoord4i}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord4iv(@NativeType("GLint const *") IntBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglTexCoord4iv(memAddress(v)); + } + + // --- [ glTexCoord4dv ] --- + + /** Unsafe version of: {@link #glTexCoord4dv TexCoord4dv} */ + public static native void nglTexCoord4dv(long v); + + /** + * Pointer version of {@link #glTexCoord4d TexCoord4d}. + * + * @param v the texture coordinate buffer + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord4dv(@NativeType("GLdouble const *") DoubleBuffer v) { + if (CHECKS) { + check(v, 4); + } + nglTexCoord4dv(memAddress(v)); + } + + // --- [ glTexCoordPointer ] --- + + /** Unsafe version of: {@link #glTexCoordPointer TexCoordPointer} */ + public static native void nglTexCoordPointer(int size, int type, int stride, long pointer); + + /** + * Specifies the location and organization of a texture coordinate array. + * + * @param size the number of values per vertex that are stored in the array. One of:| 1 | 2 | 3 | 4 |
| {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 1 | 2 | 3 | 4 |
| {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 1 | 2 | 3 | 4 |
| {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 1 | 2 | 3 | 4 |
| {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 1 | 2 | 3 | 4 |
| {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| {@link #GL_TEXTURE_ENV TEXTURE_ENV} | {@link GL14#GL_TEXTURE_FILTER_CONTROL TEXTURE_FILTER_CONTROL} | {@link GL20#GL_POINT_SPRITE POINT_SPRITE} |
| {@link GL20#GL_COORD_REPLACE COORD_REPLACE} | {@link #GL_TEXTURE_ENV_MODE TEXTURE_ENV_MODE} | {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL13#GL_COMBINE_RGB COMBINE_RGB} | {@link GL13#GL_COMBINE_ALPHA COMBINE_ALPHA} | {@link GL15#GL_SRC0_RGB SRC0_RGB} |
| {@link GL15#GL_SRC1_RGB SRC1_RGB} | {@link GL15#GL_SRC2_RGB SRC2_RGB} | {@link GL15#GL_SRC0_ALPHA SRC0_ALPHA} | {@link GL15#GL_SRC1_ALPHA SRC1_ALPHA} | {@link GL15#GL_SRC2_ALPHA SRC2_ALPHA} | {@link GL13#GL_OPERAND0_RGB OPERAND0_RGB} |
| {@link GL13#GL_OPERAND1_RGB OPERAND1_RGB} | {@link GL13#GL_OPERAND2_RGB OPERAND2_RGB} | {@link GL13#GL_OPERAND0_ALPHA OPERAND0_ALPHA} | {@link GL13#GL_OPERAND1_ALPHA OPERAND1_ALPHA} | {@link GL13#GL_OPERAND2_ALPHA OPERAND2_ALPHA} | {@link GL13#GL_RGB_SCALE RGB_SCALE} |
| {@link #GL_ALPHA_SCALE ALPHA_SCALE} |
| {@link #GL_REPLACE REPLACE} | {@link #GL_MODULATE MODULATE} | {@link #GL_DECAL DECAL} | {@link #GL_BLEND BLEND} | {@link #GL_ADD ADD} | {@link GL13#GL_COMBINE COMBINE} | {@link GL13#GL_ADD_SIGNED ADD_SIGNED} | {@link GL13#GL_INTERPOLATE INTERPOLATE} |
| {@link GL13#GL_SUBTRACT SUBTRACT} | {@link GL13#GL_DOT3_RGB DOT3_RGB} | {@link GL13#GL_DOT3_RGBA DOT3_RGBA} | {@link #GL_TEXTURE TEXTURE} | {@link GL13#GL_TEXTURE0 TEXTURE0} | GL13.GL_TEXTURE[1-31] | {@link GL13#GL_CONSTANT CONSTANT} | {@link GL13#GL_PRIMARY_COLOR PRIMARY_COLOR} |
| {@link GL13#GL_PREVIOUS PREVIOUS} |
| {@link #GL_TEXTURE_ENV TEXTURE_ENV} |
| {@link #GL_TEXTURE_ENV_COLOR TEXTURE_ENV_COLOR} |
| {@link #GL_TEXTURE_ENV TEXTURE_ENV} |
| {@link #GL_TEXTURE_ENV_COLOR TEXTURE_ENV_COLOR} |
A texture coordinate generation function is enabled or disabled using {@link #glEnable Enable} and {@link #glDisable Disable} with an argument of + * {@link #GL_TEXTURE_GEN_S TEXTURE_GEN_S}, {@link #GL_TEXTURE_GEN_T TEXTURE_GEN_T}, {@link #GL_TEXTURE_GEN_R TEXTURE_GEN_R}, or {@link #GL_TEXTURE_GEN_Q TEXTURE_GEN_Q} (each indicates the corresponding texture + * coordinate). When enabled, the specified texture coordinate is computed according to the current {@link #GL_EYE_LINEAR EYE_LINEAR}, {@link #GL_OBJECT_LINEAR OBJECT_LINEAR} or + * {@link #GL_SPHERE_MAP SPHERE_MAP} specification, depending on the current setting of {@link #GL_TEXTURE_GEN_MODE TEXTURE_GEN_MODE} for that coordinate. When disabled, subsequent + * vertices will take the indicated texture coordinate from the current texture coordinates.
+ * + *The initial state has the texture generation function disabled for all texture coordinates. Initially all texture generation modes are EYE_LINEAR.
+ * + * @param coord the coordinate for which to set the parameter. One of:| {@link #GL_S S} | {@link #GL_T T} | {@link #GL_R R} | {@link #GL_Q Q} |
| {@link #GL_TEXTURE_GEN_MODE TEXTURE_GEN_MODE} |
| {@link #GL_OBJECT_LINEAR OBJECT_LINEAR} | {@link #GL_EYE_LINEAR EYE_LINEAR} | {@link #GL_SPHERE_MAP SPHERE_MAP} | {@link GL13#GL_REFLECTION_MAP REFLECTION_MAP} | {@link GL13#GL_NORMAL_MAP NORMAL_MAP} |
| {@link #GL_OBJECT_PLANE OBJECT_PLANE} | {@link #GL_EYE_PLANE EYE_PLANE} |
| {@link #GL_OBJECT_PLANE OBJECT_PLANE} | {@link #GL_EYE_PLANE EYE_PLANE} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11C#GL_R3_G3_B2 R3_G3_B2} | {@link GL11C#GL_RGB4 RGB4} | {@link GL11C#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11C#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11C#GL_RGB10 RGB10} | {@link GL11C#GL_RGB12 RGB12} | {@link GL11C#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11C#GL_RGBA2 RGBA2} | {@link GL11C#GL_RGBA4 RGBA4} | {@link GL11C#GL_RGB5_A1 RGB5_A1} | {@link GL11C#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11C#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11C#GL_RGBA12 RGBA12} | {@link GL11C#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11C#GL_R3_G3_B2 R3_G3_B2} | {@link GL11C#GL_RGB4 RGB4} | {@link GL11C#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11C#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11C#GL_RGB10 RGB10} | {@link GL11C#GL_RGB12 RGB12} | {@link GL11C#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11C#GL_RGBA2 RGBA2} | {@link GL11C#GL_RGBA4 RGBA4} | {@link GL11C#GL_RGB5_A1 RGB5_A1} | {@link GL11C#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11C#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11C#GL_RGBA12 RGBA12} | {@link GL11C#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11C#GL_R3_G3_B2 R3_G3_B2} | {@link GL11C#GL_RGB4 RGB4} | {@link GL11C#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11C#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11C#GL_RGB10 RGB10} | {@link GL11C#GL_RGB12 RGB12} | {@link GL11C#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11C#GL_RGBA2 RGBA2} | {@link GL11C#GL_RGBA4 RGBA4} | {@link GL11C#GL_RGB5_A1 RGB5_A1} | {@link GL11C#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11C#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11C#GL_RGBA12 RGBA12} | {@link GL11C#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11C#GL_R3_G3_B2 R3_G3_B2} | {@link GL11C#GL_RGB4 RGB4} | {@link GL11C#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11C#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11C#GL_RGB10 RGB10} | {@link GL11C#GL_RGB12 RGB12} | {@link GL11C#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11C#GL_RGBA2 RGBA2} | {@link GL11C#GL_RGBA4 RGBA4} | {@link GL11C#GL_RGB5_A1 RGB5_A1} | {@link GL11C#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11C#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11C#GL_RGBA12 RGBA12} | {@link GL11C#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11C#GL_R3_G3_B2 R3_G3_B2} | {@link GL11C#GL_RGB4 RGB4} | {@link GL11C#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11C#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11C#GL_RGB10 RGB10} | {@link GL11C#GL_RGB12 RGB12} | {@link GL11C#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11C#GL_RGBA2 RGBA2} | {@link GL11C#GL_RGBA4 RGBA4} | {@link GL11C#GL_RGB5_A1 RGB5_A1} | {@link GL11C#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11C#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11C#GL_RGBA12 RGBA12} | {@link GL11C#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11C#GL_R3_G3_B2 R3_G3_B2} | {@link GL11C#GL_RGB4 RGB4} | {@link GL11C#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11C#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11C#GL_RGB10 RGB10} | {@link GL11C#GL_RGB12 RGB12} | {@link GL11C#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11C#GL_RGBA2 RGBA2} | {@link GL11C#GL_RGBA4 RGBA4} | {@link GL11C#GL_RGB5_A1 RGB5_A1} | {@link GL11C#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11C#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11C#GL_RGBA12 RGBA12} | {@link GL11C#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} |
{@code x}, {@code y}, {@code width}, and {@code height} correspond precisely to the corresponding arguments to {@link #glReadPixels ReadPixels}; they specify the + * image's width and height, and the lower left (x, y) coordinates of the framebuffer region to be copied.
+ * + *The image is taken from the framebuffer exactly as if these arguments were passed to {@link GL11#glCopyPixels CopyPixels} with argument type set to {@link GL11C#GL_COLOR COLOR}, + * {@link GL11C#GL_DEPTH DEPTH}, or {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL}, depending on {@code internalformat}. RGBA data is taken from the current color buffer, while depth + * component and stencil index data are taken from the depth and stencil buffers, respectively.
+ * + *Subsequent processing is identical to that described for {@link #glTexImage2D TexImage2D}, beginning with clamping of the R, G, B, A, or depth values, and masking + * of the stencil index values from the resulting pixel groups. Parameters {@code level}, {@code internalformat}, and {@code border} are specified using + * the same values, with the same meanings, as the corresponding arguments of {@link #glTexImage2D TexImage2D}.
+ * + *The constraints on width, height, and border are exactly those for the corresponding arguments of {@link #glTexImage2D TexImage2D}.
+ * + * @param target the texture target. One of:| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link GL11C#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL11C#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL11C#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link GL11C#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link GL11C#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_1D TEXTURE_1D} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11C#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11C#GL_RED RED} | {@link GL11C#GL_GREEN GREEN} | {@link GL11C#GL_BLUE BLUE} | {@link GL11C#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11C#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11C#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11C#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11C#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11C#GL_BYTE BYTE} | {@link GL11C#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11C#GL_SHORT SHORT} |
| {@link GL11C#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11C#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11C#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
Calling this function is equivalent to calling {@link #glMultMatrixf MultMatrixf} with the following matrix:
+ * + *| 1 | 0 | 0 | x |
| 0 | 1 | 0 | y |
| 0 | 0 | 1 | z |
| 0 | 0 | 0 | 1 |
| 2 | 3 | 4 |
| {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 2 | 3 | 4 |
| {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 2 | 3 | 4 |
| {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 2 | 3 | 4 |
| {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 2 | 3 | 4 |
| {@link #GL_SHORT SHORT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} | {@link #GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
The location of the viewport's bottom-left corner, given by {@code (x, y)}, are clamped to be within the implementation-dependent viewport bounds range. + * The viewport bounds range {@code [min, max]} tuple may be determined by calling {@link #glGetFloatv GetFloatv} with the symbolic + * constant {@link GL41#GL_VIEWPORT_BOUNDS_RANGE VIEWPORT_BOUNDS_RANGE}. Viewport width and height are clamped to implementation-dependent maximums when specified. The maximum + * width and height may be found by calling {@link #glGetFloatv GetFloatv} with the symbolic constant {@link GL11C#GL_MAX_VIEWPORT_DIMS MAX_VIEWPORT_DIMS}. The + * maximum viewport dimensions must be greater than or equal to the larger of the visible dimensions of the display being rendered to (if a display + * exists), and the largest renderbuffer image which can be successfully created and attached to a framebuffer object.
+ * + *In the initial state, {@code w} and {@code h} for each viewport are set to the width and height, respectively, of the window into which the GL is to do + * its rendering. If the default framebuffer is bound but no default framebuffer is associated with the GL context, then {@code w} and {@code h} are + * initially set to zero.
+ * + * @param x the left viewport coordinate + * @param y the bottom viewport coordinate + * @param w the viewport width + * @param h the viewport height + * + * @see Reference Page + */ + public static void glViewport(@NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLsizei") int w, @NativeType("GLsizei") int h) { + GL11C.glViewport(x, y, w, h); + } + + /** + * Array version of: {@link #glAreTexturesResident AreTexturesResident} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + @NativeType("GLboolean") + public static boolean glAreTexturesResident(@NativeType("GLuint const *") int[] textures, @NativeType("GLboolean *") ByteBuffer residences) { + long __functionAddress = GL.getICD().glAreTexturesResident; + if (CHECKS) { + check(__functionAddress); + check(residences, textures.length); + } + return callPPZ(textures.length, textures, memAddress(residences), __functionAddress); + } + + /** + * Array version of: {@link #glClipPlane ClipPlane} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glClipPlane(@NativeType("GLenum") int plane, @NativeType("GLdouble const *") double[] equation) { + long __functionAddress = GL.getICD().glClipPlane; + if (CHECKS) { + check(__functionAddress); + check(equation, 4); + } + callPV(plane, equation, __functionAddress); + } + + /** + * Array version of: {@link #glColor3sv Color3sv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor3sv(@NativeType("GLshort const *") short[] v) { + long __functionAddress = GL.getICD().glColor3sv; + if (CHECKS) { + check(__functionAddress); + check(v, 3); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glColor3iv Color3iv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor3iv(@NativeType("GLint const *") int[] v) { + long __functionAddress = GL.getICD().glColor3iv; + if (CHECKS) { + check(__functionAddress); + check(v, 3); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glColor3fv Color3fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor3fv(@NativeType("GLfloat const *") float[] v) { + long __functionAddress = GL.getICD().glColor3fv; + if (CHECKS) { + check(__functionAddress); + check(v, 3); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glColor3dv Color3dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor3dv(@NativeType("GLdouble const *") double[] v) { + long __functionAddress = GL.getICD().glColor3dv; + if (CHECKS) { + check(__functionAddress); + check(v, 3); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glColor3usv Color3usv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor3usv(@NativeType("GLushort const *") short[] v) { + long __functionAddress = GL.getICD().glColor3usv; + if (CHECKS) { + check(__functionAddress); + check(v, 3); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glColor3uiv Color3uiv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor3uiv(@NativeType("GLuint const *") int[] v) { + long __functionAddress = GL.getICD().glColor3uiv; + if (CHECKS) { + check(__functionAddress); + check(v, 3); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glColor4sv Color4sv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor4sv(@NativeType("GLshort const *") short[] v) { + long __functionAddress = GL.getICD().glColor4sv; + if (CHECKS) { + check(__functionAddress); + check(v, 4); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glColor4iv Color4iv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor4iv(@NativeType("GLint const *") int[] v) { + long __functionAddress = GL.getICD().glColor4iv; + if (CHECKS) { + check(__functionAddress); + check(v, 4); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glColor4fv Color4fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor4fv(@NativeType("GLfloat const *") float[] v) { + long __functionAddress = GL.getICD().glColor4fv; + if (CHECKS) { + check(__functionAddress); + check(v, 4); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glColor4dv Color4dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor4dv(@NativeType("GLdouble const *") double[] v) { + long __functionAddress = GL.getICD().glColor4dv; + if (CHECKS) { + check(__functionAddress); + check(v, 4); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glColor4usv Color4usv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor4usv(@NativeType("GLushort const *") short[] v) { + long __functionAddress = GL.getICD().glColor4usv; + if (CHECKS) { + check(__functionAddress); + check(v, 4); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glColor4uiv Color4uiv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glColor4uiv(@NativeType("GLuint const *") int[] v) { + long __functionAddress = GL.getICD().glColor4uiv; + if (CHECKS) { + check(__functionAddress); + check(v, 4); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glDrawPixels DrawPixels} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glDrawPixels(@NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") short[] pixels) { + long __functionAddress = GL.getICD().glDrawPixels; + if (CHECKS) { + check(__functionAddress); + } + callPV(width, height, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glDrawPixels DrawPixels} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glDrawPixels(@NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") int[] pixels) { + long __functionAddress = GL.getICD().glDrawPixels; + if (CHECKS) { + check(__functionAddress); + } + callPV(width, height, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glDrawPixels DrawPixels} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glDrawPixels(@NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") float[] pixels) { + long __functionAddress = GL.getICD().glDrawPixels; + if (CHECKS) { + check(__functionAddress); + } + callPV(width, height, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glEvalCoord1fv EvalCoord1fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glEvalCoord1fv(@NativeType("GLfloat const *") float[] u) { + long __functionAddress = GL.getICD().glEvalCoord1fv; + if (CHECKS) { + check(__functionAddress); + check(u, 1); + } + callPV(u, __functionAddress); + } + + /** + * Array version of: {@link #glEvalCoord1dv EvalCoord1dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glEvalCoord1dv(@NativeType("GLdouble const *") double[] u) { + long __functionAddress = GL.getICD().glEvalCoord1dv; + if (CHECKS) { + check(__functionAddress); + check(u, 1); + } + callPV(u, __functionAddress); + } + + /** + * Array version of: {@link #glEvalCoord2fv EvalCoord2fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glEvalCoord2fv(@NativeType("GLfloat const *") float[] u) { + long __functionAddress = GL.getICD().glEvalCoord2fv; + if (CHECKS) { + check(__functionAddress); + check(u, 2); + } + callPV(u, __functionAddress); + } + + /** + * Array version of: {@link #glEvalCoord2dv EvalCoord2dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glEvalCoord2dv(@NativeType("GLdouble const *") double[] u) { + long __functionAddress = GL.getICD().glEvalCoord2dv; + if (CHECKS) { + check(__functionAddress); + check(u, 2); + } + callPV(u, __functionAddress); + } + + /** + * Array version of: {@link #glFeedbackBuffer FeedbackBuffer} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glFeedbackBuffer(@NativeType("GLenum") int type, @NativeType("GLfloat *") float[] buffer) { + long __functionAddress = GL.getICD().glFeedbackBuffer; + if (CHECKS) { + check(__functionAddress); + } + callPV(buffer.length, type, buffer, __functionAddress); + } + + /** + * Array version of: {@link #glFogiv Fogiv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glFogiv(@NativeType("GLenum") int pname, @NativeType("GLint const *") int[] params) { + long __functionAddress = GL.getICD().glFogiv; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glFogfv Fogfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glFogfv(@NativeType("GLenum") int pname, @NativeType("GLfloat const *") float[] params) { + long __functionAddress = GL.getICD().glFogfv; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glGenTextures GenTextures} + * + * @see Reference Page + */ + public static void glGenTextures(@NativeType("GLuint *") int[] textures) { + GL11C.glGenTextures(textures); + } + + /** + * Array version of: {@link #glDeleteTextures DeleteTextures} + * + * @see Reference Page + */ + public static void glDeleteTextures(@NativeType("GLuint const *") int[] textures) { + GL11C.glDeleteTextures(textures); + } + + /** + * Array version of: {@link #glGetClipPlane GetClipPlane} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetClipPlane(@NativeType("GLenum") int plane, @NativeType("GLdouble *") double[] equation) { + long __functionAddress = GL.getICD().glGetClipPlane; + if (CHECKS) { + check(__functionAddress); + check(equation, 4); + } + callPV(plane, equation, __functionAddress); + } + + /** + * Array version of: {@link #glGetFloatv GetFloatv} + * + * @see Reference Page + */ + public static void glGetFloatv(@NativeType("GLenum") int pname, @NativeType("GLfloat *") float[] params) { + GL11C.glGetFloatv(pname, params); + } + + /** + * Array version of: {@link #glGetIntegerv GetIntegerv} + * + * @see Reference Page + */ + public static void glGetIntegerv(@NativeType("GLenum") int pname, @NativeType("GLint *") int[] params) { + GL11C.glGetIntegerv(pname, params); + } + + /** + * Array version of: {@link #glGetDoublev GetDoublev} + * + * @see Reference Page + */ + public static void glGetDoublev(@NativeType("GLenum") int pname, @NativeType("GLdouble *") double[] params) { + GL11C.glGetDoublev(pname, params); + } + + /** + * Array version of: {@link #glGetLightiv GetLightiv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetLightiv(@NativeType("GLenum") int light, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] data) { + long __functionAddress = GL.getICD().glGetLightiv; + if (CHECKS) { + check(__functionAddress); + check(data, 4); + } + callPV(light, pname, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetLightfv GetLightfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetLightfv(@NativeType("GLenum") int light, @NativeType("GLenum") int pname, @NativeType("GLfloat *") float[] data) { + long __functionAddress = GL.getICD().glGetLightfv; + if (CHECKS) { + check(__functionAddress); + check(data, 4); + } + callPV(light, pname, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetMapiv GetMapiv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetMapiv(@NativeType("GLenum") int target, @NativeType("GLenum") int query, @NativeType("GLint *") int[] data) { + long __functionAddress = GL.getICD().glGetMapiv; + if (CHECKS) { + check(__functionAddress); + check(data, 4); + } + callPV(target, query, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetMapfv GetMapfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetMapfv(@NativeType("GLenum") int target, @NativeType("GLenum") int query, @NativeType("GLfloat *") float[] data) { + long __functionAddress = GL.getICD().glGetMapfv; + if (CHECKS) { + check(__functionAddress); + check(data, 4); + } + callPV(target, query, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetMapdv GetMapdv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetMapdv(@NativeType("GLenum") int target, @NativeType("GLenum") int query, @NativeType("GLdouble *") double[] data) { + long __functionAddress = GL.getICD().glGetMapdv; + if (CHECKS) { + check(__functionAddress); + check(data, 4); + } + callPV(target, query, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetMaterialiv GetMaterialiv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetMaterialiv(@NativeType("GLenum") int face, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] data) { + long __functionAddress = GL.getICD().glGetMaterialiv; + if (CHECKS) { + check(__functionAddress); + check(data, 1); + } + callPV(face, pname, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetMaterialfv GetMaterialfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetMaterialfv(@NativeType("GLenum") int face, @NativeType("GLenum") int pname, @NativeType("GLfloat *") float[] data) { + long __functionAddress = GL.getICD().glGetMaterialfv; + if (CHECKS) { + check(__functionAddress); + check(data, 1); + } + callPV(face, pname, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetPixelMapfv GetPixelMapfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetPixelMapfv(@NativeType("GLenum") int map, @NativeType("GLfloat *") float[] data) { + long __functionAddress = GL.getICD().glGetPixelMapfv; + if (CHECKS) { + check(__functionAddress); + check(data, 32); + } + callPV(map, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetPixelMapusv GetPixelMapusv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetPixelMapusv(@NativeType("GLenum") int map, @NativeType("GLushort *") short[] data) { + long __functionAddress = GL.getICD().glGetPixelMapusv; + if (CHECKS) { + check(__functionAddress); + check(data, 32); + } + callPV(map, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetPixelMapuiv GetPixelMapuiv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetPixelMapuiv(@NativeType("GLenum") int map, @NativeType("GLuint *") int[] data) { + long __functionAddress = GL.getICD().glGetPixelMapuiv; + if (CHECKS) { + check(__functionAddress); + check(data, 32); + } + callPV(map, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetTexEnviv GetTexEnviv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetTexEnviv(@NativeType("GLenum") int env, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] data) { + long __functionAddress = GL.getICD().glGetTexEnviv; + if (CHECKS) { + check(__functionAddress); + check(data, 1); + } + callPV(env, pname, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetTexEnvfv GetTexEnvfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetTexEnvfv(@NativeType("GLenum") int env, @NativeType("GLenum") int pname, @NativeType("GLfloat *") float[] data) { + long __functionAddress = GL.getICD().glGetTexEnvfv; + if (CHECKS) { + check(__functionAddress); + check(data, 1); + } + callPV(env, pname, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetTexGeniv GetTexGeniv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetTexGeniv(@NativeType("GLenum") int coord, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] data) { + long __functionAddress = GL.getICD().glGetTexGeniv; + if (CHECKS) { + check(__functionAddress); + check(data, 1); + } + callPV(coord, pname, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetTexGenfv GetTexGenfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetTexGenfv(@NativeType("GLenum") int coord, @NativeType("GLenum") int pname, @NativeType("GLfloat *") float[] data) { + long __functionAddress = GL.getICD().glGetTexGenfv; + if (CHECKS) { + check(__functionAddress); + check(data, 4); + } + callPV(coord, pname, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetTexGendv GetTexGendv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glGetTexGendv(@NativeType("GLenum") int coord, @NativeType("GLenum") int pname, @NativeType("GLdouble *") double[] data) { + long __functionAddress = GL.getICD().glGetTexGendv; + if (CHECKS) { + check(__functionAddress); + check(data, 4); + } + callPV(coord, pname, data, __functionAddress); + } + + /** + * Array version of: {@link #glGetTexImage GetTexImage} + * + * @see Reference Page + */ + public static void glGetTexImage(@NativeType("GLenum") int tex, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void *") short[] pixels) { + GL11C.glGetTexImage(tex, level, format, type, pixels); + } + + /** + * Array version of: {@link #glGetTexImage GetTexImage} + * + * @see Reference Page + */ + public static void glGetTexImage(@NativeType("GLenum") int tex, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void *") int[] pixels) { + GL11C.glGetTexImage(tex, level, format, type, pixels); + } + + /** + * Array version of: {@link #glGetTexImage GetTexImage} + * + * @see Reference Page + */ + public static void glGetTexImage(@NativeType("GLenum") int tex, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void *") float[] pixels) { + GL11C.glGetTexImage(tex, level, format, type, pixels); + } + + /** + * Array version of: {@link #glGetTexImage GetTexImage} + * + * @see Reference Page + */ + public static void glGetTexImage(@NativeType("GLenum") int tex, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void *") double[] pixels) { + GL11C.glGetTexImage(tex, level, format, type, pixels); + } + + /** + * Array version of: {@link #glGetTexLevelParameteriv GetTexLevelParameteriv} + * + * @see Reference Page + */ + public static void glGetTexLevelParameteriv(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] params) { + GL11C.glGetTexLevelParameteriv(target, level, pname, params); + } + + /** + * Array version of: {@link #glGetTexLevelParameterfv GetTexLevelParameterfv} + * + * @see Reference Page + */ + public static void glGetTexLevelParameterfv(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLenum") int pname, @NativeType("GLfloat *") float[] params) { + GL11C.glGetTexLevelParameterfv(target, level, pname, params); + } + + /** + * Array version of: {@link #glGetTexParameteriv GetTexParameteriv} + * + * @see Reference Page + */ + public static void glGetTexParameteriv(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] params) { + GL11C.glGetTexParameteriv(target, pname, params); + } + + /** + * Array version of: {@link #glGetTexParameterfv GetTexParameterfv} + * + * @see Reference Page + */ + public static void glGetTexParameterfv(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLfloat *") float[] params) { + GL11C.glGetTexParameterfv(target, pname, params); + } + + /** + * Array version of: {@link #glIndexiv Indexiv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glIndexiv(@NativeType("GLint const *") int[] index) { + long __functionAddress = GL.getICD().glIndexiv; + if (CHECKS) { + check(__functionAddress); + check(index, 1); + } + callPV(index, __functionAddress); + } + + /** + * Array version of: {@link #glIndexsv Indexsv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glIndexsv(@NativeType("GLshort const *") short[] index) { + long __functionAddress = GL.getICD().glIndexsv; + if (CHECKS) { + check(__functionAddress); + check(index, 1); + } + callPV(index, __functionAddress); + } + + /** + * Array version of: {@link #glIndexfv Indexfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glIndexfv(@NativeType("GLfloat const *") float[] index) { + long __functionAddress = GL.getICD().glIndexfv; + if (CHECKS) { + check(__functionAddress); + check(index, 1); + } + callPV(index, __functionAddress); + } + + /** + * Array version of: {@link #glIndexdv Indexdv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glIndexdv(@NativeType("GLdouble const *") double[] index) { + long __functionAddress = GL.getICD().glIndexdv; + if (CHECKS) { + check(__functionAddress); + check(index, 1); + } + callPV(index, __functionAddress); + } + + /** + * Array version of: {@link #glInterleavedArrays InterleavedArrays} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glInterleavedArrays(@NativeType("GLenum") int format, @NativeType("GLsizei") int stride, @NativeType("void const *") short[] pointer) { + long __functionAddress = GL.getICD().glInterleavedArrays; + if (CHECKS) { + check(__functionAddress); + } + callPV(format, stride, pointer, __functionAddress); + } + + /** + * Array version of: {@link #glInterleavedArrays InterleavedArrays} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glInterleavedArrays(@NativeType("GLenum") int format, @NativeType("GLsizei") int stride, @NativeType("void const *") int[] pointer) { + long __functionAddress = GL.getICD().glInterleavedArrays; + if (CHECKS) { + check(__functionAddress); + } + callPV(format, stride, pointer, __functionAddress); + } + + /** + * Array version of: {@link #glInterleavedArrays InterleavedArrays} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glInterleavedArrays(@NativeType("GLenum") int format, @NativeType("GLsizei") int stride, @NativeType("void const *") float[] pointer) { + long __functionAddress = GL.getICD().glInterleavedArrays; + if (CHECKS) { + check(__functionAddress); + } + callPV(format, stride, pointer, __functionAddress); + } + + /** + * Array version of: {@link #glInterleavedArrays InterleavedArrays} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glInterleavedArrays(@NativeType("GLenum") int format, @NativeType("GLsizei") int stride, @NativeType("void const *") double[] pointer) { + long __functionAddress = GL.getICD().glInterleavedArrays; + if (CHECKS) { + check(__functionAddress); + } + callPV(format, stride, pointer, __functionAddress); + } + + /** + * Array version of: {@link #glLightModeliv LightModeliv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glLightModeliv(@NativeType("GLenum") int pname, @NativeType("GLint const *") int[] params) { + long __functionAddress = GL.getICD().glLightModeliv; + if (CHECKS) { + check(__functionAddress); + check(params, 4); + } + callPV(pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glLightModelfv LightModelfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glLightModelfv(@NativeType("GLenum") int pname, @NativeType("GLfloat const *") float[] params) { + long __functionAddress = GL.getICD().glLightModelfv; + if (CHECKS) { + check(__functionAddress); + check(params, 4); + } + callPV(pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glLightiv Lightiv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glLightiv(@NativeType("GLenum") int light, @NativeType("GLenum") int pname, @NativeType("GLint const *") int[] params) { + long __functionAddress = GL.getICD().glLightiv; + if (CHECKS) { + check(__functionAddress); + check(params, 4); + } + callPV(light, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glLightfv Lightfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glLightfv(@NativeType("GLenum") int light, @NativeType("GLenum") int pname, @NativeType("GLfloat const *") float[] params) { + long __functionAddress = GL.getICD().glLightfv; + if (CHECKS) { + check(__functionAddress); + check(params, 4); + } + callPV(light, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glLoadMatrixf LoadMatrixf} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glLoadMatrixf(@NativeType("GLfloat const *") float[] m) { + long __functionAddress = GL.getICD().glLoadMatrixf; + if (CHECKS) { + check(__functionAddress); + check(m, 16); + } + callPV(m, __functionAddress); + } + + /** + * Array version of: {@link #glLoadMatrixd LoadMatrixd} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glLoadMatrixd(@NativeType("GLdouble const *") double[] m) { + long __functionAddress = GL.getICD().glLoadMatrixd; + if (CHECKS) { + check(__functionAddress); + check(m, 16); + } + callPV(m, __functionAddress); + } + + /** + * Array version of: {@link #glMap1f Map1f} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glMap1f(@NativeType("GLenum") int target, @NativeType("GLfloat") float u1, @NativeType("GLfloat") float u2, @NativeType("GLint") int stride, @NativeType("GLint") int order, @NativeType("GLfloat const *") float[] points) { + long __functionAddress = GL.getICD().glMap1f; + if (CHECKS) { + check(__functionAddress); + check(points, order * stride); + } + callPV(target, u1, u2, stride, order, points, __functionAddress); + } + + /** + * Array version of: {@link #glMap1d Map1d} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glMap1d(@NativeType("GLenum") int target, @NativeType("GLdouble") double u1, @NativeType("GLdouble") double u2, @NativeType("GLint") int stride, @NativeType("GLint") int order, @NativeType("GLdouble const *") double[] points) { + long __functionAddress = GL.getICD().glMap1d; + if (CHECKS) { + check(__functionAddress); + check(points, stride * order); + } + callPV(target, u1, u2, stride, order, points, __functionAddress); + } + + /** + * Array version of: {@link #glMap2f Map2f} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glMap2f(@NativeType("GLenum") int target, @NativeType("GLfloat") float u1, @NativeType("GLfloat") float u2, @NativeType("GLint") int ustride, @NativeType("GLint") int uorder, @NativeType("GLfloat") float v1, @NativeType("GLfloat") float v2, @NativeType("GLint") int vstride, @NativeType("GLint") int vorder, @NativeType("GLfloat const *") float[] points) { + long __functionAddress = GL.getICD().glMap2f; + if (CHECKS) { + check(__functionAddress); + check(points, ustride * uorder * vstride * vorder); + } + callPV(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points, __functionAddress); + } + + /** + * Array version of: {@link #glMap2d Map2d} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glMap2d(@NativeType("GLenum") int target, @NativeType("GLdouble") double u1, @NativeType("GLdouble") double u2, @NativeType("GLint") int ustride, @NativeType("GLint") int uorder, @NativeType("GLdouble") double v1, @NativeType("GLdouble") double v2, @NativeType("GLint") int vstride, @NativeType("GLint") int vorder, @NativeType("GLdouble const *") double[] points) { + long __functionAddress = GL.getICD().glMap2d; + if (CHECKS) { + check(__functionAddress); + check(points, ustride * uorder * vstride * vorder); + } + callPV(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points, __functionAddress); + } + + /** + * Array version of: {@link #glMaterialiv Materialiv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glMaterialiv(@NativeType("GLenum") int face, @NativeType("GLenum") int pname, @NativeType("GLint const *") int[] params) { + long __functionAddress = GL.getICD().glMaterialiv; + if (CHECKS) { + check(__functionAddress); + check(params, 4); + } + callPV(face, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glMaterialfv Materialfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glMaterialfv(@NativeType("GLenum") int face, @NativeType("GLenum") int pname, @NativeType("GLfloat const *") float[] params) { + long __functionAddress = GL.getICD().glMaterialfv; + if (CHECKS) { + check(__functionAddress); + check(params, 4); + } + callPV(face, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glMultMatrixf MultMatrixf} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glMultMatrixf(@NativeType("GLfloat const *") float[] m) { + long __functionAddress = GL.getICD().glMultMatrixf; + if (CHECKS) { + check(__functionAddress); + check(m, 16); + } + callPV(m, __functionAddress); + } + + /** + * Array version of: {@link #glMultMatrixd MultMatrixd} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glMultMatrixd(@NativeType("GLdouble const *") double[] m) { + long __functionAddress = GL.getICD().glMultMatrixd; + if (CHECKS) { + check(__functionAddress); + check(m, 16); + } + callPV(m, __functionAddress); + } + + /** + * Array version of: {@link #glNormal3fv Normal3fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glNormal3fv(@NativeType("GLfloat const *") float[] v) { + long __functionAddress = GL.getICD().glNormal3fv; + if (CHECKS) { + check(__functionAddress); + check(v, 3); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glNormal3sv Normal3sv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glNormal3sv(@NativeType("GLshort const *") short[] v) { + long __functionAddress = GL.getICD().glNormal3sv; + if (CHECKS) { + check(__functionAddress); + check(v, 3); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glNormal3iv Normal3iv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glNormal3iv(@NativeType("GLint const *") int[] v) { + long __functionAddress = GL.getICD().glNormal3iv; + if (CHECKS) { + check(__functionAddress); + check(v, 3); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glNormal3dv Normal3dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glNormal3dv(@NativeType("GLdouble const *") double[] v) { + long __functionAddress = GL.getICD().glNormal3dv; + if (CHECKS) { + check(__functionAddress); + check(v, 3); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glPixelMapfv PixelMapfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glPixelMapfv(@NativeType("GLenum") int map, @NativeType("GLfloat const *") float[] values) { + long __functionAddress = GL.getICD().glPixelMapfv; + if (CHECKS) { + check(__functionAddress); + } + callPV(map, values.length, values, __functionAddress); + } + + /** + * Array version of: {@link #glPixelMapusv PixelMapusv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glPixelMapusv(@NativeType("GLenum") int map, @NativeType("GLushort const *") short[] values) { + long __functionAddress = GL.getICD().glPixelMapusv; + if (CHECKS) { + check(__functionAddress); + } + callPV(map, values.length, values, __functionAddress); + } + + /** + * Array version of: {@link #glPixelMapuiv PixelMapuiv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glPixelMapuiv(@NativeType("GLenum") int map, @NativeType("GLuint const *") int[] values) { + long __functionAddress = GL.getICD().glPixelMapuiv; + if (CHECKS) { + check(__functionAddress); + } + callPV(map, values.length, values, __functionAddress); + } + + /** + * Array version of: {@link #glPrioritizeTextures PrioritizeTextures} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glPrioritizeTextures(@NativeType("GLuint const *") int[] textures, @NativeType("GLfloat const *") float[] priorities) { + long __functionAddress = GL.getICD().glPrioritizeTextures; + if (CHECKS) { + check(__functionAddress); + check(priorities, textures.length); + } + callPPV(textures.length, textures, priorities, __functionAddress); + } + + /** + * Array version of: {@link #glRasterPos2iv RasterPos2iv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos2iv(@NativeType("GLint const *") int[] coords) { + long __functionAddress = GL.getICD().glRasterPos2iv; + if (CHECKS) { + check(__functionAddress); + check(coords, 2); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glRasterPos2sv RasterPos2sv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos2sv(@NativeType("GLshort const *") short[] coords) { + long __functionAddress = GL.getICD().glRasterPos2sv; + if (CHECKS) { + check(__functionAddress); + check(coords, 2); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glRasterPos2fv RasterPos2fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos2fv(@NativeType("GLfloat const *") float[] coords) { + long __functionAddress = GL.getICD().glRasterPos2fv; + if (CHECKS) { + check(__functionAddress); + check(coords, 2); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glRasterPos2dv RasterPos2dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos2dv(@NativeType("GLdouble const *") double[] coords) { + long __functionAddress = GL.getICD().glRasterPos2dv; + if (CHECKS) { + check(__functionAddress); + check(coords, 2); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glRasterPos3iv RasterPos3iv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos3iv(@NativeType("GLint const *") int[] coords) { + long __functionAddress = GL.getICD().glRasterPos3iv; + if (CHECKS) { + check(__functionAddress); + check(coords, 3); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glRasterPos3sv RasterPos3sv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos3sv(@NativeType("GLshort const *") short[] coords) { + long __functionAddress = GL.getICD().glRasterPos3sv; + if (CHECKS) { + check(__functionAddress); + check(coords, 3); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glRasterPos3fv RasterPos3fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos3fv(@NativeType("GLfloat const *") float[] coords) { + long __functionAddress = GL.getICD().glRasterPos3fv; + if (CHECKS) { + check(__functionAddress); + check(coords, 3); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glRasterPos3dv RasterPos3dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos3dv(@NativeType("GLdouble const *") double[] coords) { + long __functionAddress = GL.getICD().glRasterPos3dv; + if (CHECKS) { + check(__functionAddress); + check(coords, 3); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glRasterPos4iv RasterPos4iv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos4iv(@NativeType("GLint const *") int[] coords) { + long __functionAddress = GL.getICD().glRasterPos4iv; + if (CHECKS) { + check(__functionAddress); + check(coords, 4); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glRasterPos4sv RasterPos4sv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos4sv(@NativeType("GLshort const *") short[] coords) { + long __functionAddress = GL.getICD().glRasterPos4sv; + if (CHECKS) { + check(__functionAddress); + check(coords, 4); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glRasterPos4fv RasterPos4fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos4fv(@NativeType("GLfloat const *") float[] coords) { + long __functionAddress = GL.getICD().glRasterPos4fv; + if (CHECKS) { + check(__functionAddress); + check(coords, 4); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glRasterPos4dv RasterPos4dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRasterPos4dv(@NativeType("GLdouble const *") double[] coords) { + long __functionAddress = GL.getICD().glRasterPos4dv; + if (CHECKS) { + check(__functionAddress); + check(coords, 4); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glReadPixels ReadPixels} + * + * @see Reference Page + */ + public static void glReadPixels(@NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void *") short[] pixels) { + GL11C.glReadPixels(x, y, width, height, format, type, pixels); + } + + /** + * Array version of: {@link #glReadPixels ReadPixels} + * + * @see Reference Page + */ + public static void glReadPixels(@NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void *") int[] pixels) { + GL11C.glReadPixels(x, y, width, height, format, type, pixels); + } + + /** + * Array version of: {@link #glReadPixels ReadPixels} + * + * @see Reference Page + */ + public static void glReadPixels(@NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void *") float[] pixels) { + GL11C.glReadPixels(x, y, width, height, format, type, pixels); + } + + /** + * Array version of: {@link #glRectiv Rectiv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRectiv(@NativeType("GLint const *") int[] v1, @NativeType("GLint const *") int[] v2) { + long __functionAddress = GL.getICD().glRectiv; + if (CHECKS) { + check(__functionAddress); + check(v1, 2); + check(v2, 2); + } + callPPV(v1, v2, __functionAddress); + } + + /** + * Array version of: {@link #glRectsv Rectsv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRectsv(@NativeType("GLshort const *") short[] v1, @NativeType("GLshort const *") short[] v2) { + long __functionAddress = GL.getICD().glRectsv; + if (CHECKS) { + check(__functionAddress); + check(v1, 2); + check(v2, 2); + } + callPPV(v1, v2, __functionAddress); + } + + /** + * Array version of: {@link #glRectfv Rectfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRectfv(@NativeType("GLfloat const *") float[] v1, @NativeType("GLfloat const *") float[] v2) { + long __functionAddress = GL.getICD().glRectfv; + if (CHECKS) { + check(__functionAddress); + check(v1, 2); + check(v2, 2); + } + callPPV(v1, v2, __functionAddress); + } + + /** + * Array version of: {@link #glRectdv Rectdv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glRectdv(@NativeType("GLdouble const *") double[] v1, @NativeType("GLdouble const *") double[] v2) { + long __functionAddress = GL.getICD().glRectdv; + if (CHECKS) { + check(__functionAddress); + check(v1, 2); + check(v2, 2); + } + callPPV(v1, v2, __functionAddress); + } + + /** + * Array version of: {@link #glSelectBuffer SelectBuffer} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glSelectBuffer(@NativeType("GLuint *") int[] buffer) { + long __functionAddress = GL.getICD().glSelectBuffer; + if (CHECKS) { + check(__functionAddress); + } + callPV(buffer.length, buffer, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord1fv TexCoord1fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord1fv(@NativeType("GLfloat const *") float[] v) { + long __functionAddress = GL.getICD().glTexCoord1fv; + if (CHECKS) { + check(__functionAddress); + check(v, 1); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord1sv TexCoord1sv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord1sv(@NativeType("GLshort const *") short[] v) { + long __functionAddress = GL.getICD().glTexCoord1sv; + if (CHECKS) { + check(__functionAddress); + check(v, 1); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord1iv TexCoord1iv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord1iv(@NativeType("GLint const *") int[] v) { + long __functionAddress = GL.getICD().glTexCoord1iv; + if (CHECKS) { + check(__functionAddress); + check(v, 1); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord1dv TexCoord1dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord1dv(@NativeType("GLdouble const *") double[] v) { + long __functionAddress = GL.getICD().glTexCoord1dv; + if (CHECKS) { + check(__functionAddress); + check(v, 1); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord2fv TexCoord2fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord2fv(@NativeType("GLfloat const *") float[] v) { + long __functionAddress = GL.getICD().glTexCoord2fv; + if (CHECKS) { + check(__functionAddress); + check(v, 2); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord2sv TexCoord2sv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord2sv(@NativeType("GLshort const *") short[] v) { + long __functionAddress = GL.getICD().glTexCoord2sv; + if (CHECKS) { + check(__functionAddress); + check(v, 2); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord2iv TexCoord2iv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord2iv(@NativeType("GLint const *") int[] v) { + long __functionAddress = GL.getICD().glTexCoord2iv; + if (CHECKS) { + check(__functionAddress); + check(v, 2); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord2dv TexCoord2dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord2dv(@NativeType("GLdouble const *") double[] v) { + long __functionAddress = GL.getICD().glTexCoord2dv; + if (CHECKS) { + check(__functionAddress); + check(v, 2); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord3fv TexCoord3fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord3fv(@NativeType("GLfloat const *") float[] v) { + long __functionAddress = GL.getICD().glTexCoord3fv; + if (CHECKS) { + check(__functionAddress); + check(v, 3); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord3sv TexCoord3sv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord3sv(@NativeType("GLshort const *") short[] v) { + long __functionAddress = GL.getICD().glTexCoord3sv; + if (CHECKS) { + check(__functionAddress); + check(v, 3); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord3iv TexCoord3iv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord3iv(@NativeType("GLint const *") int[] v) { + long __functionAddress = GL.getICD().glTexCoord3iv; + if (CHECKS) { + check(__functionAddress); + check(v, 3); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord3dv TexCoord3dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord3dv(@NativeType("GLdouble const *") double[] v) { + long __functionAddress = GL.getICD().glTexCoord3dv; + if (CHECKS) { + check(__functionAddress); + check(v, 3); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord4fv TexCoord4fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord4fv(@NativeType("GLfloat const *") float[] v) { + long __functionAddress = GL.getICD().glTexCoord4fv; + if (CHECKS) { + check(__functionAddress); + check(v, 4); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord4sv TexCoord4sv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord4sv(@NativeType("GLshort const *") short[] v) { + long __functionAddress = GL.getICD().glTexCoord4sv; + if (CHECKS) { + check(__functionAddress); + check(v, 4); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord4iv TexCoord4iv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord4iv(@NativeType("GLint const *") int[] v) { + long __functionAddress = GL.getICD().glTexCoord4iv; + if (CHECKS) { + check(__functionAddress); + check(v, 4); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexCoord4dv TexCoord4dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexCoord4dv(@NativeType("GLdouble const *") double[] v) { + long __functionAddress = GL.getICD().glTexCoord4dv; + if (CHECKS) { + check(__functionAddress); + check(v, 4); + } + callPV(v, __functionAddress); + } + + /** + * Array version of: {@link #glTexEnviv TexEnviv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexEnviv(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLint const *") int[] params) { + long __functionAddress = GL.getICD().glTexEnviv; + if (CHECKS) { + check(__functionAddress); + check(params, 4); + } + callPV(target, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glTexEnvfv TexEnvfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexEnvfv(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLfloat const *") float[] params) { + long __functionAddress = GL.getICD().glTexEnvfv; + if (CHECKS) { + check(__functionAddress); + check(params, 4); + } + callPV(target, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glTexGeniv TexGeniv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexGeniv(@NativeType("GLenum") int coord, @NativeType("GLenum") int pname, @NativeType("GLint const *") int[] params) { + long __functionAddress = GL.getICD().glTexGeniv; + if (CHECKS) { + check(__functionAddress); + check(params, 4); + } + callPV(coord, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glTexGenfv TexGenfv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexGenfv(@NativeType("GLenum") int coord, @NativeType("GLenum") int pname, @NativeType("GLfloat const *") float[] params) { + long __functionAddress = GL.getICD().glTexGenfv; + if (CHECKS) { + check(__functionAddress); + check(params, 4); + } + callPV(coord, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glTexGendv TexGendv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glTexGendv(@NativeType("GLenum") int coord, @NativeType("GLenum") int pname, @NativeType("GLdouble const *") double[] params) { + long __functionAddress = GL.getICD().glTexGendv; + if (CHECKS) { + check(__functionAddress); + check(params, 4); + } + callPV(coord, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glTexImage1D TexImage1D} + * + * @see Reference Page + */ + public static void glTexImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") short[] pixels) { + GL11C.glTexImage1D(target, level, internalformat, width, border, format, type, pixels); + } + + /** + * Array version of: {@link #glTexImage1D TexImage1D} + * + * @see Reference Page + */ + public static void glTexImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") int[] pixels) { + GL11C.glTexImage1D(target, level, internalformat, width, border, format, type, pixels); + } + + /** + * Array version of: {@link #glTexImage1D TexImage1D} + * + * @see Reference Page + */ + public static void glTexImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") float[] pixels) { + GL11C.glTexImage1D(target, level, internalformat, width, border, format, type, pixels); + } + + /** + * Array version of: {@link #glTexImage1D TexImage1D} + * + * @see Reference Page + */ + public static void glTexImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") double[] pixels) { + GL11C.glTexImage1D(target, level, internalformat, width, border, format, type, pixels); + } + + /** + * Array version of: {@link #glTexImage2D TexImage2D} + * + * @see Reference Page + */ + public static void glTexImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") short[] pixels) { + GL11C.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); + } + + /** + * Array version of: {@link #glTexImage2D TexImage2D} + * + * @see Reference Page + */ + public static void glTexImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") int[] pixels) { + GL11C.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); + } + + /** + * Array version of: {@link #glTexImage2D TexImage2D} + * + * @see Reference Page + */ + public static void glTexImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") float[] pixels) { + GL11C.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); + } + + /** + * Array version of: {@link #glTexImage2D TexImage2D} + * + * @see Reference Page + */ + public static void glTexImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") double[] pixels) { + GL11C.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); + } + + /** + * Array version of: {@link #glTexParameteriv TexParameteriv} + * + * @see Reference Page + */ + public static void glTexParameteriv(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLint const *") int[] params) { + GL11C.glTexParameteriv(target, pname, params); + } + + /** + * Array version of: {@link #glTexParameterfv TexParameterfv} + * + * @see Reference Page + */ + public static void glTexParameterfv(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLfloat const *") float[] params) { + GL11C.glTexParameterfv(target, pname, params); + } + + /** + * Array version of: {@link #glTexSubImage1D TexSubImage1D} + * + * @see Reference Page + */ + public static void glTexSubImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLsizei") int width, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") short[] pixels) { + GL11C.glTexSubImage1D(target, level, xoffset, width, format, type, pixels); + } + + /** + * Array version of: {@link #glTexSubImage1D TexSubImage1D} + * + * @see Reference Page + */ + public static void glTexSubImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLsizei") int width, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") int[] pixels) { + GL11C.glTexSubImage1D(target, level, xoffset, width, format, type, pixels); + } + + /** + * Array version of: {@link #glTexSubImage1D TexSubImage1D} + * + * @see Reference Page + */ + public static void glTexSubImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLsizei") int width, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") float[] pixels) { + GL11C.glTexSubImage1D(target, level, xoffset, width, format, type, pixels); + } + + /** + * Array version of: {@link #glTexSubImage1D TexSubImage1D} + * + * @see Reference Page + */ + public static void glTexSubImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLsizei") int width, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") double[] pixels) { + GL11C.glTexSubImage1D(target, level, xoffset, width, format, type, pixels); + } + + /** + * Array version of: {@link #glTexSubImage2D TexSubImage2D} + * + * @see Reference Page + */ + public static void glTexSubImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") short[] pixels) { + GL11C.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + } + + /** + * Array version of: {@link #glTexSubImage2D TexSubImage2D} + * + * @see Reference Page + */ + public static void glTexSubImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") int[] pixels) { + GL11C.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + } + + /** + * Array version of: {@link #glTexSubImage2D TexSubImage2D} + * + * @see Reference Page + */ + public static void glTexSubImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") float[] pixels) { + GL11C.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + } + + /** + * Array version of: {@link #glTexSubImage2D TexSubImage2D} + * + * @see Reference Page + */ + public static void glTexSubImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") double[] pixels) { + GL11C.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + } + + /** + * Array version of: {@link #glVertex2fv Vertex2fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glVertex2fv(@NativeType("GLfloat const *") float[] coords) { + long __functionAddress = GL.getICD().glVertex2fv; + if (CHECKS) { + check(__functionAddress); + check(coords, 2); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glVertex2sv Vertex2sv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glVertex2sv(@NativeType("GLshort const *") short[] coords) { + long __functionAddress = GL.getICD().glVertex2sv; + if (CHECKS) { + check(__functionAddress); + check(coords, 2); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glVertex2iv Vertex2iv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glVertex2iv(@NativeType("GLint const *") int[] coords) { + long __functionAddress = GL.getICD().glVertex2iv; + if (CHECKS) { + check(__functionAddress); + check(coords, 2); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glVertex2dv Vertex2dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glVertex2dv(@NativeType("GLdouble const *") double[] coords) { + long __functionAddress = GL.getICD().glVertex2dv; + if (CHECKS) { + check(__functionAddress); + check(coords, 2); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glVertex3fv Vertex3fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glVertex3fv(@NativeType("GLfloat const *") float[] coords) { + long __functionAddress = GL.getICD().glVertex3fv; + if (CHECKS) { + check(__functionAddress); + check(coords, 3); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glVertex3sv Vertex3sv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glVertex3sv(@NativeType("GLshort const *") short[] coords) { + long __functionAddress = GL.getICD().glVertex3sv; + if (CHECKS) { + check(__functionAddress); + check(coords, 3); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glVertex3iv Vertex3iv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glVertex3iv(@NativeType("GLint const *") int[] coords) { + long __functionAddress = GL.getICD().glVertex3iv; + if (CHECKS) { + check(__functionAddress); + check(coords, 3); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glVertex3dv Vertex3dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glVertex3dv(@NativeType("GLdouble const *") double[] coords) { + long __functionAddress = GL.getICD().glVertex3dv; + if (CHECKS) { + check(__functionAddress); + check(coords, 3); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glVertex4fv Vertex4fv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glVertex4fv(@NativeType("GLfloat const *") float[] coords) { + long __functionAddress = GL.getICD().glVertex4fv; + if (CHECKS) { + check(__functionAddress); + check(coords, 4); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glVertex4sv Vertex4sv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glVertex4sv(@NativeType("GLshort const *") short[] coords) { + long __functionAddress = GL.getICD().glVertex4sv; + if (CHECKS) { + check(__functionAddress); + check(coords, 4); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glVertex4iv Vertex4iv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glVertex4iv(@NativeType("GLint const *") int[] coords) { + long __functionAddress = GL.getICD().glVertex4iv; + if (CHECKS) { + check(__functionAddress); + check(coords, 4); + } + callPV(coords, __functionAddress); + } + + /** + * Array version of: {@link #glVertex4dv Vertex4dv} + * + * @see Reference Page - This function is deprecated and unavailable in the Core profile + */ + public static void glVertex4dv(@NativeType("GLdouble const *") double[] coords) { + long __functionAddress = GL.getICD().glVertex4dv; + if (CHECKS) { + check(__functionAddress); + check(coords, 4); + } + callPV(coords, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL11C.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL11C.java new file mode 100644 index 00000000..62389e83 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL11C.java @@ -0,0 +1,2661 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * The OpenGL functionality of a forward compatible context, up to version 1.1. + * + *Extensions promoted to core in this release:
+ * + *While a texture object is bound, GL operations on the target to which it is bound affect the bound object, and queries of the target to which it is + * bound return state from the bound object. If texture mapping of the dimensionality of the target to which a texture object is bound is enabled, the + * state of the bound texture object directs the texturing operation.
+ * + * @param target the texture target. One of:| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link #GL_ZERO ZERO} | {@link #GL_ONE ONE} | {@link #GL_SRC_COLOR SRC_COLOR} | {@link #GL_ONE_MINUS_SRC_COLOR ONE_MINUS_SRC_COLOR} | {@link #GL_DST_COLOR DST_COLOR} |
| {@link #GL_ONE_MINUS_DST_COLOR ONE_MINUS_DST_COLOR} | {@link #GL_SRC_ALPHA SRC_ALPHA} | {@link #GL_ONE_MINUS_SRC_ALPHA ONE_MINUS_SRC_ALPHA} | {@link #GL_DST_ALPHA DST_ALPHA} | {@link #GL_ONE_MINUS_DST_ALPHA ONE_MINUS_DST_ALPHA} |
| {@link GL14#GL_CONSTANT_COLOR CONSTANT_COLOR} | {@link GL14#GL_ONE_MINUS_CONSTANT_COLOR ONE_MINUS_CONSTANT_COLOR} | {@link GL14#GL_CONSTANT_ALPHA CONSTANT_ALPHA} | {@link GL14#GL_ONE_MINUS_CONSTANT_ALPHA ONE_MINUS_CONSTANT_ALPHA} | {@link #GL_SRC_ALPHA_SATURATE SRC_ALPHA_SATURATE} |
| {@link GL33#GL_SRC1_COLOR SRC1_COLOR} | {@link GL33#GL_ONE_MINUS_SRC1_COLOR ONE_MINUS_SRC1_COLOR} | {@link GL15#GL_SRC1_ALPHA SRC1_ALPHA} | {@link GL33#GL_ONE_MINUS_SRC1_ALPHA ONE_MINUS_SRC1_ALPHA} |
| {@link #GL_COLOR_BUFFER_BIT COLOR_BUFFER_BIT} | {@link #GL_DEPTH_BUFFER_BIT DEPTH_BUFFER_BIT} | {@link #GL_STENCIL_BUFFER_BIT STENCIL_BUFFER_BIT} |
| {@link #GL_FRONT FRONT} | {@link #GL_BACK BACK} | {@link #GL_FRONT_AND_BACK FRONT_AND_BACK} |
| {@link #GL_NEVER NEVER} | {@link #GL_ALWAYS ALWAYS} | {@link #GL_LESS LESS} | {@link #GL_LEQUAL LEQUAL} | {@link #GL_EQUAL EQUAL} | {@link #GL_GREATER GREATER} | {@link #GL_GEQUAL GEQUAL} | {@link #GL_NOTEQUAL NOTEQUAL} |
first + count – 1 of each enabled non-instanced array are transferred to the GL.
+ *
+ * If an array corresponding to an attribute required by a vertex shader is not enabled, then the corresponding element is taken from the current attribute + * state. If an array is enabled, the corresponding current vertex attribute value is unaffected by the execution of this function.
+ * + * @param mode the kind of primitives being constructed + * @param first the first vertex to transfer to the GL + * @param count the number of vertices after {@code first} to transfer to the GL + * + * @see Reference Page + */ + public static native void glDrawArrays(@NativeType("GLenum") int mode, @NativeType("GLint") int first, @NativeType("GLsizei") int count); + + // --- [ glDrawBuffer ] --- + + /** + * Defines the color buffer to which fragment color zero is written. + * + *Acceptable values for {@code buf} depend on whether the GL is using the default framebuffer (i.e., {@link GL30#GL_DRAW_FRAMEBUFFER_BINDING DRAW_FRAMEBUFFER_BINDING} is zero), or + * a framebuffer object (i.e., {@link GL30#GL_DRAW_FRAMEBUFFER_BINDING DRAW_FRAMEBUFFER_BINDING} is non-zero). In the initial state, the GL is bound to the default framebuffer.
+ * + * @param buf the color buffer to draw to. One of:| {@link #GL_NONE NONE} | {@link #GL_FRONT_LEFT FRONT_LEFT} | {@link #GL_FRONT_RIGHT FRONT_RIGHT} | {@link #GL_BACK_LEFT BACK_LEFT} | {@link #GL_BACK_RIGHT BACK_RIGHT} | {@link #GL_FRONT FRONT} | {@link #GL_BACK BACK} | {@link #GL_LEFT LEFT} |
| {@link #GL_RIGHT RIGHT} | {@link #GL_FRONT_AND_BACK FRONT_AND_BACK} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link #GL_POINTS POINTS} | {@link #GL_LINE_STRIP LINE_STRIP} | {@link #GL_LINE_LOOP LINE_LOOP} | {@link #GL_LINES LINES} | {@link #GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link #GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link #GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link #GL_POINTS POINTS} | {@link #GL_LINE_STRIP LINE_STRIP} | {@link #GL_LINE_LOOP LINE_LOOP} | {@link #GL_LINES LINES} | {@link #GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link #GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link #GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link #GL_POINTS POINTS} | {@link #GL_LINE_STRIP LINE_STRIP} | {@link #GL_LINE_LOOP LINE_LOOP} | {@link #GL_LINES LINES} | {@link #GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link #GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link #GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link #GL_POINTS POINTS} | {@link #GL_LINE_STRIP LINE_STRIP} | {@link #GL_LINE_LOOP LINE_LOOP} | {@link #GL_LINES LINES} | {@link #GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link #GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link #GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link #GL_POINTS POINTS} | {@link #GL_LINE_STRIP LINE_STRIP} | {@link #GL_LINE_LOOP LINE_LOOP} | {@link #GL_LINES LINES} | {@link #GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link #GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link #GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link #GL_CCW CCW} | {@link #GL_CW CW} |
Unused names in textures that have been marked as used for the purposes of {@link #glGenTextures GenTextures} are marked as unused again. Unused names in textures are + * silently ignored, as is the name zero.
+ * + * @param textures contains {@code n} names of texture objects to be deleted + * + * @see Reference Page + */ + public static void glDeleteTextures(@NativeType("GLuint const *") IntBuffer textures) { + nglDeleteTextures(textures.remaining(), memAddress(textures)); + } + + /** + * Deletes texture objects. After a texture object is deleted, it has no contents or dimensionality, and its name is again unused. If a texture that is + * currently bound to any of the target bindings of {@link #glBindTexture BindTexture} is deleted, it is as though {@link #glBindTexture BindTexture} had been executed with the + * same target and texture zero. Additionally, special care must be taken when deleting a texture if any of the images of the texture are attached to a + * framebuffer object. + * + *Unused names in textures that have been marked as used for the purposes of {@link #glGenTextures GenTextures} are marked as unused again. Unused names in textures are + * silently ignored, as is the name zero.
+ * + * @see Reference Page + */ + public static void glDeleteTextures(@NativeType("GLuint const *") int texture) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer textures = stack.ints(texture); + nglDeleteTextures(1, memAddress(textures)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetBooleanv ] --- + + /** Unsafe version of: {@link #glGetBooleanv GetBooleanv} */ + public static native void nglGetBooleanv(int pname, long params); + + /** + * Returns the current boolean value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * @param params a scalar or buffer in which to place the returned data + * + * @see Reference Page + */ + public static void glGetBooleanv(@NativeType("GLenum") int pname, @NativeType("GLboolean *") ByteBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetBooleanv(pname, memAddress(params)); + } + + /** + * Returns the current boolean value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * + * @see Reference Page + */ + @NativeType("void") + public static boolean glGetBoolean(@NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + ByteBuffer params = stack.calloc(1); + nglGetBooleanv(pname, memAddress(params)); + return params.get(0) != 0; + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetFloatv ] --- + + /** Unsafe version of: {@link #glGetFloatv GetFloatv} */ + public static native void nglGetFloatv(int pname, long params); + + /** + * Returns the current float value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * @param params a scalar or buffer in which to place the returned data + * + * @see Reference Page + */ + public static void glGetFloatv(@NativeType("GLenum") int pname, @NativeType("GLfloat *") FloatBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetFloatv(pname, memAddress(params)); + } + + /** + * Returns the current float value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * + * @see Reference Page + */ + @NativeType("void") + public static float glGetFloat(@NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + FloatBuffer params = stack.callocFloat(1); + nglGetFloatv(pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetIntegerv ] --- + + /** Unsafe version of: {@link #glGetIntegerv GetIntegerv} */ + public static native void nglGetIntegerv(int pname, long params); + + /** + * Returns the current integer value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * @param params a scalar or buffer in which to place the returned data + * + * @see Reference Page + */ + public static void glGetIntegerv(@NativeType("GLenum") int pname, @NativeType("GLint *") IntBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetIntegerv(pname, memAddress(params)); + } + + /** + * Returns the current integer value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * + * @see Reference Page + */ + @NativeType("void") + public static int glGetInteger(@NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer params = stack.callocInt(1); + nglGetIntegerv(pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetDoublev ] --- + + /** Unsafe version of: {@link #glGetDoublev GetDoublev} */ + public static native void nglGetDoublev(int pname, long params); + + /** + * Returns the current double value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * @param params a scalar or buffer in which to place the returned data + * + * @see Reference Page + */ + public static void glGetDoublev(@NativeType("GLenum") int pname, @NativeType("GLdouble *") DoubleBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetDoublev(pname, memAddress(params)); + } + + /** + * Returns the current double value of the specified state variable. + * + *LWJGL note: The state that corresponds to the state variable may be a single value or an array of values. In the case of an array of values, + * LWJGL will not validate if {@code params} has enough space to store that array. Doing so would introduce significant overhead, as the + * OpenGL state variables are too many. It is the user's responsibility to avoid JVM crashes by ensuring enough space for the returned values.
+ * + * @param pname the state variable + * + * @see Reference Page + */ + @NativeType("void") + public static double glGetDouble(@NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + DoubleBuffer params = stack.callocDouble(1); + nglGetDoublev(pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetError ] --- + + /** + * Returns error information. + * + *Each detectable error is assigned a numeric code. When an error is detected, a flag is set and the code is recorded. Further errors, if they occur, do + * not affect this recorded code. When {@code GetError} is called, the code is returned and the flag is cleared, so that a further error will again record + * its code. If a call to {@code GetError} returns {@link #GL_NO_ERROR NO_ERROR}, then there has been no detectable error since the last call to {@code GetError} (or since + * the GL was initialized).
+ * + * @see Reference Page + */ + @NativeType("GLenum") + public static native int glGetError(); + + // --- [ glGetPointerv ] --- + + /** Unsafe version of: {@link #glGetPointerv GetPointerv} */ + public static native void nglGetPointerv(int pname, long params); + + /** + * Returns a pointer in the current GL context. + * + * @param pname the pointer to return. One of:| {@link GL43#GL_DEBUG_CALLBACK_FUNCTION DEBUG_CALLBACK_FUNCTION} | {@link GL43#GL_DEBUG_CALLBACK_USER_PARAM DEBUG_CALLBACK_USER_PARAM} |
| {@link GL43#GL_DEBUG_CALLBACK_FUNCTION DEBUG_CALLBACK_FUNCTION} | {@link GL43#GL_DEBUG_CALLBACK_USER_PARAM DEBUG_CALLBACK_USER_PARAM} |
| {@link #GL_RENDERER RENDERER} | {@link #GL_VENDOR VENDOR} | {@link #GL_EXTENSIONS EXTENSIONS} | {@link #GL_VERSION VERSION} | {@link GL20#GL_SHADING_LANGUAGE_VERSION SHADING_LANGUAGE_VERSION} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} | {@link #GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} | {@link GL12#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link #GL_TEXTURE_WIDTH TEXTURE_WIDTH} | {@link #GL_TEXTURE_HEIGHT TEXTURE_HEIGHT} | {@link GL12#GL_TEXTURE_DEPTH TEXTURE_DEPTH} | {@link GL32#GL_TEXTURE_SAMPLES TEXTURE_SAMPLES} |
| {@link GL32#GL_TEXTURE_FIXED_SAMPLE_LOCATIONS TEXTURE_FIXED_SAMPLE_LOCATIONS} | {@link #GL_TEXTURE_INTERNAL_FORMAT TEXTURE_INTERNAL_FORMAT} | {@link #GL_TEXTURE_RED_SIZE TEXTURE_RED_SIZE} | {@link #GL_TEXTURE_GREEN_SIZE TEXTURE_GREEN_SIZE} |
| {@link #GL_TEXTURE_BLUE_SIZE TEXTURE_BLUE_SIZE} | {@link #GL_TEXTURE_ALPHA_SIZE TEXTURE_ALPHA_SIZE} | {@link GL14#GL_TEXTURE_DEPTH_SIZE TEXTURE_DEPTH_SIZE} | {@link GL30#GL_TEXTURE_STENCIL_SIZE TEXTURE_STENCIL_SIZE} |
| {@link GL30#GL_TEXTURE_SHARED_SIZE TEXTURE_SHARED_SIZE} | {@link GL30#GL_TEXTURE_ALPHA_TYPE TEXTURE_ALPHA_TYPE} | {@link GL30#GL_TEXTURE_DEPTH_TYPE TEXTURE_DEPTH_TYPE} | {@link GL13#GL_TEXTURE_COMPRESSED TEXTURE_COMPRESSED} |
| {@link GL13#GL_TEXTURE_COMPRESSED_IMAGE_SIZE TEXTURE_COMPRESSED_IMAGE_SIZE} | {@link GL31#GL_TEXTURE_BUFFER_DATA_STORE_BINDING TEXTURE_BUFFER_DATA_STORE_BINDING} | {@link GL43#GL_TEXTURE_BUFFER_OFFSET TEXTURE_BUFFER_OFFSET} | {@link GL43#GL_TEXTURE_BUFFER_SIZE TEXTURE_BUFFER_SIZE} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} | {@link #GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} | {@link GL12#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link #GL_TEXTURE_WIDTH TEXTURE_WIDTH} | {@link #GL_TEXTURE_HEIGHT TEXTURE_HEIGHT} | {@link GL12#GL_TEXTURE_DEPTH TEXTURE_DEPTH} | {@link GL32#GL_TEXTURE_SAMPLES TEXTURE_SAMPLES} |
| {@link GL32#GL_TEXTURE_FIXED_SAMPLE_LOCATIONS TEXTURE_FIXED_SAMPLE_LOCATIONS} | {@link #GL_TEXTURE_INTERNAL_FORMAT TEXTURE_INTERNAL_FORMAT} | {@link #GL_TEXTURE_RED_SIZE TEXTURE_RED_SIZE} | {@link #GL_TEXTURE_GREEN_SIZE TEXTURE_GREEN_SIZE} |
| {@link #GL_TEXTURE_BLUE_SIZE TEXTURE_BLUE_SIZE} | {@link #GL_TEXTURE_ALPHA_SIZE TEXTURE_ALPHA_SIZE} | {@link GL14#GL_TEXTURE_DEPTH_SIZE TEXTURE_DEPTH_SIZE} | {@link GL30#GL_TEXTURE_STENCIL_SIZE TEXTURE_STENCIL_SIZE} |
| {@link GL30#GL_TEXTURE_SHARED_SIZE TEXTURE_SHARED_SIZE} | {@link GL30#GL_TEXTURE_ALPHA_TYPE TEXTURE_ALPHA_TYPE} | {@link GL30#GL_TEXTURE_DEPTH_TYPE TEXTURE_DEPTH_TYPE} | {@link GL13#GL_TEXTURE_COMPRESSED TEXTURE_COMPRESSED} |
| {@link GL13#GL_TEXTURE_COMPRESSED_IMAGE_SIZE TEXTURE_COMPRESSED_IMAGE_SIZE} | {@link GL31#GL_TEXTURE_BUFFER_DATA_STORE_BINDING TEXTURE_BUFFER_DATA_STORE_BINDING} | {@link GL43#GL_TEXTURE_BUFFER_OFFSET TEXTURE_BUFFER_OFFSET} | {@link GL43#GL_TEXTURE_BUFFER_SIZE TEXTURE_BUFFER_SIZE} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link #GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link #GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link #GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link #GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link #GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
| {@link GL42#GL_IMAGE_FORMAT_COMPATIBILITY_TYPE IMAGE_FORMAT_COMPATIBILITY_TYPE} | {@link GL42#GL_TEXTURE_IMMUTABLE_FORMAT TEXTURE_IMMUTABLE_FORMAT} | {@link GL43#GL_TEXTURE_IMMUTABLE_LEVELS TEXTURE_IMMUTABLE_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LEVEL TEXTURE_VIEW_MIN_LEVEL} |
| {@link GL43#GL_TEXTURE_VIEW_NUM_LEVELS TEXTURE_VIEW_NUM_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LAYER TEXTURE_VIEW_MIN_LAYER} | {@link GL43#GL_TEXTURE_VIEW_NUM_LAYERS TEXTURE_VIEW_NUM_LAYERS} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link #GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link #GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link #GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link #GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link #GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
| {@link GL42#GL_IMAGE_FORMAT_COMPATIBILITY_TYPE IMAGE_FORMAT_COMPATIBILITY_TYPE} | {@link GL42#GL_TEXTURE_IMMUTABLE_FORMAT TEXTURE_IMMUTABLE_FORMAT} | {@link GL43#GL_TEXTURE_IMMUTABLE_LEVELS TEXTURE_IMMUTABLE_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LEVEL TEXTURE_VIEW_MIN_LEVEL} |
| {@link GL43#GL_TEXTURE_VIEW_NUM_LEVELS TEXTURE_VIEW_NUM_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LAYER TEXTURE_VIEW_MIN_LAYER} | {@link GL43#GL_TEXTURE_VIEW_NUM_LAYERS TEXTURE_VIEW_NUM_LAYERS} |
| {@link #GL_LINE_SMOOTH_HINT LINE_SMOOTH_HINT} | {@link #GL_POLYGON_SMOOTH_HINT POLYGON_SMOOTH_HINT} | {@link GL13#GL_TEXTURE_COMPRESSION_HINT TEXTURE_COMPRESSION_HINT} |
| {@link GL20#GL_FRAGMENT_SHADER_DERIVATIVE_HINT FRAGMENT_SHADER_DERIVATIVE_HINT} |
| {@link #GL_FASTEST FASTEST} | {@link #GL_NICEST NICEST} | {@link #GL_DONT_CARE DONT_CARE} |
| {@link #GL_CLEAR CLEAR} | {@link #GL_AND AND} | {@link #GL_AND_REVERSE AND_REVERSE} | {@link #GL_COPY COPY} | {@link #GL_AND_INVERTED AND_INVERTED} | {@link #GL_NOOP NOOP} | {@link #GL_XOR XOR} | {@link #GL_OR OR} | {@link #GL_NOR NOR} | {@link #GL_EQUIV EQUIV} | {@link #GL_INVERT INVERT} | {@link #GL_OR_REVERSE OR_REVERSE} | {@link #GL_COPY_INVERTED COPY_INVERTED} |
| {@link #GL_OR_INVERTED OR_INVERTED} | {@link #GL_NAND NAND} | {@link #GL_SET SET} |
| {@link #GL_UNPACK_SWAP_BYTES UNPACK_SWAP_BYTES} | {@link #GL_UNPACK_LSB_FIRST UNPACK_LSB_FIRST} | {@link #GL_UNPACK_ROW_LENGTH UNPACK_ROW_LENGTH} |
| {@link #GL_UNPACK_SKIP_ROWS UNPACK_SKIP_ROWS} | {@link #GL_UNPACK_SKIP_PIXELS UNPACK_SKIP_PIXELS} | {@link #GL_UNPACK_ALIGNMENT UNPACK_ALIGNMENT} |
| {@link GL12#GL_UNPACK_IMAGE_HEIGHT UNPACK_IMAGE_HEIGHT} | {@link GL12#GL_UNPACK_SKIP_IMAGES UNPACK_SKIP_IMAGES} | {@link GL42#GL_UNPACK_COMPRESSED_BLOCK_WIDTH UNPACK_COMPRESSED_BLOCK_WIDTH} |
| {@link GL42#GL_UNPACK_COMPRESSED_BLOCK_HEIGHT UNPACK_COMPRESSED_BLOCK_HEIGHT} | {@link GL42#GL_UNPACK_COMPRESSED_BLOCK_DEPTH UNPACK_COMPRESSED_BLOCK_DEPTH} | {@link GL42#GL_UNPACK_COMPRESSED_BLOCK_SIZE UNPACK_COMPRESSED_BLOCK_SIZE} |
{@link #GL_FILL FILL} is the default mode of polygon rasterization. Note that these modes affect only the final rasterization of polygons: in particular, a + * polygon's vertices are lit, and the polygon is clipped and possibly culled before these modes are applied. Polygon antialiasing applies only to the + * {@link #GL_FILL FILL} state of PolygonMode. For {@link #GL_POINT POINT} or {@link #GL_LINE LINE}, point antialiasing or line segment antialiasing, respectively, apply.
+ * + * @param face the face for which to set the rasterizing method. One of:| {@link #GL_FRONT FRONT} | {@link #GL_BACK BACK} | {@link #GL_FRONT_AND_BACK FRONT_AND_BACK} |
| {@link #GL_POINT POINT} | {@link #GL_LINE LINE} | {@link #GL_FILL FILL} |
{@code factor} scales the maximum depth slope of the polygon, and {@code units} scales an implementation-dependent constant that relates to the usable + * resolution of the depth buffer. The resulting values are summed to produce the polygon offset value.
+ * + * @param factor the maximum depth slope factor + * @param units the constant scale + * + * @see Reference Page + */ + public static native void glPolygonOffset(@NativeType("GLfloat") float factor, @NativeType("GLfloat") float units); + + // --- [ glReadBuffer ] --- + + /** + * Defines the color buffer from which values are obtained. + * + *Acceptable values for {@code src} depend on whether the GL is using the default framebuffer (i.e., {@link GL30#GL_DRAW_FRAMEBUFFER_BINDING DRAW_FRAMEBUFFER_BINDING} is zero), or + * a framebuffer object (i.e., {@link GL30#GL_DRAW_FRAMEBUFFER_BINDING DRAW_FRAMEBUFFER_BINDING} is non-zero). In the initial state, the GL is bound to the default framebuffer.
+ * + * @param src the color buffer to read from. One of:| {@link #GL_NONE NONE} | {@link #GL_FRONT_LEFT FRONT_LEFT} | {@link #GL_FRONT_RIGHT FRONT_RIGHT} | {@link #GL_BACK_LEFT BACK_LEFT} | {@link #GL_BACK_RIGHT BACK_RIGHT} | {@link #GL_FRONT FRONT} | {@link #GL_BACK BACK} | {@link #GL_LEFT LEFT} |
| {@link #GL_RIGHT RIGHT} | {@link #GL_FRONT_AND_BACK FRONT_AND_BACK} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
left ≤ xw < left + width and bottom ≤ yw < bottom + height for the scissor rectangle, then the scissor
+ * test passes. Otherwise, the test fails and the fragment is discarded.
+ *
+ * @param x the left scissor rectangle coordinate
+ * @param y the bottom scissor rectangle coordinate
+ * @param width the scissor rectangle width
+ * @param height the scissor rectangle height
+ *
+ * @see Reference Page
+ */
+ public static native void glScissor(@NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height);
+
+ // --- [ glStencilFunc ] ---
+
+ /**
+ * Controls the stencil test.
+ *
+ * {@code ref} is an integer reference value that is used in the unsigned stencil comparison. Stencil comparison operations and queries of {@code ref} + * clamp its value to the range [0, 2s – 1], where s is the number of bits in the stencil buffer attached to the draw framebuffer. The s + * least significant bits of {@code mask} are bitwise ANDed with both the reference and the stored stencil value, and the resulting masked values are those that + * participate in the comparison controlled by {@code func}.
+ * + * @param func the stencil comparison function. One of:| {@link #GL_NEVER NEVER} | {@link #GL_ALWAYS ALWAYS} | {@link #GL_LESS LESS} | {@link #GL_LEQUAL LEQUAL} | {@link #GL_EQUAL EQUAL} | {@link #GL_GEQUAL GEQUAL} | {@link #GL_GREATER GREATER} | {@link #GL_NOTEQUAL NOTEQUAL} |
The least significant s bits of {@code mask}, where s is the number of bits in the stencil buffer, specify an integer mask. Where a 1 appears in this + * mask, the corresponding bit in the stencil buffer is written; where a 0 appears, the bit is not written.
+ * + * @param mask the stencil mask + * + * @see Reference Page + */ + public static native void glStencilMask(@NativeType("GLuint") int mask); + + // --- [ glStencilOp ] --- + + /** + * Indicates what happens to the stored stencil value if this or certain subsequent tests fail or pass. + * + *The supported actions are {@link #GL_KEEP KEEP}, {@link #GL_ZERO ZERO}, {@link #GL_REPLACE REPLACE}, {@link #GL_INCR INCR}, {@link #GL_DECR DECR}, {@link #GL_INVERT INVERT}, + * {@link GL14#GL_INCR_WRAP INCR_WRAP} and {@link GL14#GL_DECR_WRAP DECR_WRAP}. These correspond to keeping the current value, setting to zero, replacing with the reference value, + * incrementing with saturation, decrementing with saturation, bitwise inverting it, incrementing without saturation, and decrementing without saturation.
+ * + *For purposes of increment and decrement, the stencil bits are considered as an unsigned integer. Incrementing or decrementing with saturation clamps + * the stencil value at 0 and the maximum representable value. Incrementing or decrementing without saturation will wrap such that incrementing the maximum + * representable value results in 0, and decrementing 0 results in the maximum representable value.
+ * + * @param sfail the action to take if the stencil test fails + * @param dpfail the action to take if the depth buffer test fails + * @param dppass the action to take if the depth buffer test passes + * + * @see Reference Page + */ + public static native void glStencilOp(@NativeType("GLenum") int sfail, @NativeType("GLenum") int dpfail, @NativeType("GLenum") int dppass); + + // --- [ glTexImage1D ] --- + + /** Unsafe version of: {@link #glTexImage1D TexImage1D} */ + public static native void nglTexImage1D(int target, int level, int internalformat, int width, int border, int format, int type, long pixels); + + /** + * One-dimensional version of {@link #glTexImage2D TexImage2D}}. + * + * @param target the texture target. One of:| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link #GL_RED RED} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link #GL_R3_G3_B2 R3_G3_B2} | {@link #GL_RGB4 RGB4} | {@link #GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link #GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link #GL_RGB10 RGB10} | {@link #GL_RGB12 RGB12} | {@link #GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link #GL_RGBA2 RGBA2} | {@link #GL_RGBA4 RGBA4} | {@link #GL_RGB5_A1 RGB5_A1} | {@link #GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link #GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link #GL_RGBA12 RGBA12} | {@link #GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link #GL_RED RED} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link #GL_R3_G3_B2 R3_G3_B2} | {@link #GL_RGB4 RGB4} | {@link #GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link #GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link #GL_RGB10 RGB10} | {@link #GL_RGB12 RGB12} | {@link #GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link #GL_RGBA2 RGBA2} | {@link #GL_RGBA4 RGBA4} | {@link #GL_RGB5_A1 RGB5_A1} | {@link #GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link #GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link #GL_RGBA12 RGBA12} | {@link #GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link #GL_RED RED} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link #GL_R3_G3_B2 R3_G3_B2} | {@link #GL_RGB4 RGB4} | {@link #GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link #GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link #GL_RGB10 RGB10} | {@link #GL_RGB12 RGB12} | {@link #GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link #GL_RGBA2 RGBA2} | {@link #GL_RGBA4 RGBA4} | {@link #GL_RGB5_A1 RGB5_A1} | {@link #GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link #GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link #GL_RGBA12 RGBA12} | {@link #GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link #GL_RED RED} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link #GL_R3_G3_B2 R3_G3_B2} | {@link #GL_RGB4 RGB4} | {@link #GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link #GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link #GL_RGB10 RGB10} | {@link #GL_RGB12 RGB12} | {@link #GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link #GL_RGBA2 RGBA2} | {@link #GL_RGBA4 RGBA4} | {@link #GL_RGB5_A1 RGB5_A1} | {@link #GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link #GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link #GL_RGBA12 RGBA12} | {@link #GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link #GL_RED RED} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link #GL_R3_G3_B2 R3_G3_B2} | {@link #GL_RGB4 RGB4} | {@link #GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link #GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link #GL_RGB10 RGB10} | {@link #GL_RGB12 RGB12} | {@link #GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link #GL_RGBA2 RGBA2} | {@link #GL_RGBA4 RGBA4} | {@link #GL_RGB5_A1 RGB5_A1} | {@link #GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link #GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link #GL_RGBA12 RGBA12} | {@link #GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link #GL_RED RED} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link #GL_R3_G3_B2 R3_G3_B2} | {@link #GL_RGB4 RGB4} | {@link #GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link #GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link #GL_RGB10 RGB10} | {@link #GL_RGB12 RGB12} | {@link #GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link #GL_RGBA2 RGBA2} | {@link #GL_RGBA4 RGBA4} | {@link #GL_RGB5_A1 RGB5_A1} | {@link #GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link #GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link #GL_RGBA12 RGBA12} | {@link #GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} |
{@code x}, {@code y}, {@code width}, and {@code height} correspond precisely to the corresponding arguments to {@link #glReadPixels ReadPixels}; they specify the + * image's width and height, and the lower left (x, y) coordinates of the framebuffer region to be copied.
+ * + *The image is taken from the framebuffer exactly as if these arguments were passed to {@link GL11#glCopyPixels CopyPixels} with argument type set to {@link #GL_COLOR COLOR}, + * {@link #GL_DEPTH DEPTH}, or {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL}, depending on {@code internalformat}. RGBA data is taken from the current color buffer, while depth + * component and stencil index data are taken from the depth and stencil buffers, respectively.
+ * + *Subsequent processing is identical to that described for {@link #glTexImage2D TexImage2D}, beginning with clamping of the R, G, B, A, or depth values, and masking + * of the stencil index values from the resulting pixel groups. Parameters {@code level}, {@code internalformat}, and {@code border} are specified using + * the same values, with the same meanings, as the corresponding arguments of {@link #glTexImage2D TexImage2D}.
+ * + *The constraints on width, height, and border are exactly those for the corresponding arguments of {@link #glTexImage2D TexImage2D}.
+ * + * @param target the texture target. One of:| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} | {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link #GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link #GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link #GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link #GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link #GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_1D TEXTURE_1D} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_RED RED} | {@link #GL_GREEN GREEN} | {@link #GL_BLUE BLUE} | {@link #GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link #GL_RGB RGB} | {@link #GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link #GL_STENCIL_INDEX STENCIL_INDEX} | {@link #GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link #GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link #GL_BYTE BYTE} | {@link #GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link #GL_SHORT SHORT} |
| {@link #GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link #GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
The location of the viewport's bottom-left corner, given by {@code (x, y)}, are clamped to be within the implementation-dependent viewport bounds range. + * The viewport bounds range {@code [min, max]} tuple may be determined by calling {@link #glGetFloatv GetFloatv} with the symbolic + * constant {@link GL41#GL_VIEWPORT_BOUNDS_RANGE VIEWPORT_BOUNDS_RANGE}. Viewport width and height are clamped to implementation-dependent maximums when specified. The maximum + * width and height may be found by calling {@link #glGetFloatv GetFloatv} with the symbolic constant {@link #GL_MAX_VIEWPORT_DIMS MAX_VIEWPORT_DIMS}. The + * maximum viewport dimensions must be greater than or equal to the larger of the visible dimensions of the display being rendered to (if a display + * exists), and the largest renderbuffer image which can be successfully created and attached to a framebuffer object.
+ * + *In the initial state, {@code w} and {@code h} for each viewport are set to the width and height, respectively, of the window into which the GL is to do + * its rendering. If the default framebuffer is bound but no default framebuffer is associated with the GL context, then {@code w} and {@code h} are + * initially set to zero.
+ * + * @param x the left viewport coordinate + * @param y the bottom viewport coordinate + * @param w the viewport width + * @param h the viewport height + * + * @see Reference Page + */ + public static native void glViewport(@NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLsizei") int w, @NativeType("GLsizei") int h); + + /** + * Array version of: {@link #glGenTextures GenTextures} + * + * @see Reference Page + */ + public static void glGenTextures(@NativeType("GLuint *") int[] textures) { + long __functionAddress = GL.getICD().glGenTextures; + if (CHECKS) { + check(__functionAddress); + } + callPV(textures.length, textures, __functionAddress); + } + + /** + * Array version of: {@link #glDeleteTextures DeleteTextures} + * + * @see Reference Page + */ + public static void glDeleteTextures(@NativeType("GLuint const *") int[] textures) { + long __functionAddress = GL.getICD().glDeleteTextures; + if (CHECKS) { + check(__functionAddress); + } + callPV(textures.length, textures, __functionAddress); + } + + /** + * Array version of: {@link #glGetFloatv GetFloatv} + * + * @see Reference Page + */ + public static void glGetFloatv(@NativeType("GLenum") int pname, @NativeType("GLfloat *") float[] params) { + long __functionAddress = GL.getICD().glGetFloatv; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glGetIntegerv GetIntegerv} + * + * @see Reference Page + */ + public static void glGetIntegerv(@NativeType("GLenum") int pname, @NativeType("GLint *") int[] params) { + long __functionAddress = GL.getICD().glGetIntegerv; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glGetDoublev GetDoublev} + * + * @see Reference Page + */ + public static void glGetDoublev(@NativeType("GLenum") int pname, @NativeType("GLdouble *") double[] params) { + long __functionAddress = GL.getICD().glGetDoublev; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glGetTexImage GetTexImage} + * + * @see Reference Page + */ + public static void glGetTexImage(@NativeType("GLenum") int tex, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void *") short[] pixels) { + long __functionAddress = GL.getICD().glGetTexImage; + if (CHECKS) { + check(__functionAddress); + } + callPV(tex, level, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glGetTexImage GetTexImage} + * + * @see Reference Page + */ + public static void glGetTexImage(@NativeType("GLenum") int tex, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void *") int[] pixels) { + long __functionAddress = GL.getICD().glGetTexImage; + if (CHECKS) { + check(__functionAddress); + } + callPV(tex, level, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glGetTexImage GetTexImage} + * + * @see Reference Page + */ + public static void glGetTexImage(@NativeType("GLenum") int tex, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void *") float[] pixels) { + long __functionAddress = GL.getICD().glGetTexImage; + if (CHECKS) { + check(__functionAddress); + } + callPV(tex, level, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glGetTexImage GetTexImage} + * + * @see Reference Page + */ + public static void glGetTexImage(@NativeType("GLenum") int tex, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void *") double[] pixels) { + long __functionAddress = GL.getICD().glGetTexImage; + if (CHECKS) { + check(__functionAddress); + } + callPV(tex, level, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glGetTexLevelParameteriv GetTexLevelParameteriv} + * + * @see Reference Page + */ + public static void glGetTexLevelParameteriv(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] params) { + long __functionAddress = GL.getICD().glGetTexLevelParameteriv; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(target, level, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glGetTexLevelParameterfv GetTexLevelParameterfv} + * + * @see Reference Page + */ + public static void glGetTexLevelParameterfv(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLenum") int pname, @NativeType("GLfloat *") float[] params) { + long __functionAddress = GL.getICD().glGetTexLevelParameterfv; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(target, level, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glGetTexParameteriv GetTexParameteriv} + * + * @see Reference Page + */ + public static void glGetTexParameteriv(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] params) { + long __functionAddress = GL.getICD().glGetTexParameteriv; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(target, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glGetTexParameterfv GetTexParameterfv} + * + * @see Reference Page + */ + public static void glGetTexParameterfv(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLfloat *") float[] params) { + long __functionAddress = GL.getICD().glGetTexParameterfv; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(target, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glReadPixels ReadPixels} + * + * @see Reference Page + */ + public static void glReadPixels(@NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void *") short[] pixels) { + long __functionAddress = GL.getICD().glReadPixels; + if (CHECKS) { + check(__functionAddress); + } + callPV(x, y, width, height, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glReadPixels ReadPixels} + * + * @see Reference Page + */ + public static void glReadPixels(@NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void *") int[] pixels) { + long __functionAddress = GL.getICD().glReadPixels; + if (CHECKS) { + check(__functionAddress); + } + callPV(x, y, width, height, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glReadPixels ReadPixels} + * + * @see Reference Page + */ + public static void glReadPixels(@NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void *") float[] pixels) { + long __functionAddress = GL.getICD().glReadPixels; + if (CHECKS) { + check(__functionAddress); + } + callPV(x, y, width, height, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexImage1D TexImage1D} + * + * @see Reference Page + */ + public static void glTexImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") short[] pixels) { + long __functionAddress = GL.getICD().glTexImage1D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, internalformat, width, border, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexImage1D TexImage1D} + * + * @see Reference Page + */ + public static void glTexImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") int[] pixels) { + long __functionAddress = GL.getICD().glTexImage1D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, internalformat, width, border, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexImage1D TexImage1D} + * + * @see Reference Page + */ + public static void glTexImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") float[] pixels) { + long __functionAddress = GL.getICD().glTexImage1D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, internalformat, width, border, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexImage1D TexImage1D} + * + * @see Reference Page + */ + public static void glTexImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") double[] pixels) { + long __functionAddress = GL.getICD().glTexImage1D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, internalformat, width, border, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexImage2D TexImage2D} + * + * @see Reference Page + */ + public static void glTexImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") short[] pixels) { + long __functionAddress = GL.getICD().glTexImage2D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, internalformat, width, height, border, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexImage2D TexImage2D} + * + * @see Reference Page + */ + public static void glTexImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") int[] pixels) { + long __functionAddress = GL.getICD().glTexImage2D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, internalformat, width, height, border, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexImage2D TexImage2D} + * + * @see Reference Page + */ + public static void glTexImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") float[] pixels) { + long __functionAddress = GL.getICD().glTexImage2D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, internalformat, width, height, border, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexImage2D TexImage2D} + * + * @see Reference Page + */ + public static void glTexImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLint") int border, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") double[] pixels) { + long __functionAddress = GL.getICD().glTexImage2D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, internalformat, width, height, border, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexParameteriv TexParameteriv} + * + * @see Reference Page + */ + public static void glTexParameteriv(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLint const *") int[] params) { + long __functionAddress = GL.getICD().glTexParameteriv; + if (CHECKS) { + check(__functionAddress); + check(params, 4); + } + callPV(target, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glTexParameterfv TexParameterfv} + * + * @see Reference Page + */ + public static void glTexParameterfv(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLfloat const *") float[] params) { + long __functionAddress = GL.getICD().glTexParameterfv; + if (CHECKS) { + check(__functionAddress); + check(params, 4); + } + callPV(target, pname, params, __functionAddress); + } + + /** + * Array version of: {@link #glTexSubImage1D TexSubImage1D} + * + * @see Reference Page + */ + public static void glTexSubImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLsizei") int width, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") short[] pixels) { + long __functionAddress = GL.getICD().glTexSubImage1D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, xoffset, width, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexSubImage1D TexSubImage1D} + * + * @see Reference Page + */ + public static void glTexSubImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLsizei") int width, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") int[] pixels) { + long __functionAddress = GL.getICD().glTexSubImage1D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, xoffset, width, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexSubImage1D TexSubImage1D} + * + * @see Reference Page + */ + public static void glTexSubImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLsizei") int width, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") float[] pixels) { + long __functionAddress = GL.getICD().glTexSubImage1D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, xoffset, width, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexSubImage1D TexSubImage1D} + * + * @see Reference Page + */ + public static void glTexSubImage1D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLsizei") int width, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") double[] pixels) { + long __functionAddress = GL.getICD().glTexSubImage1D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, xoffset, width, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexSubImage2D TexSubImage2D} + * + * @see Reference Page + */ + public static void glTexSubImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") short[] pixels) { + long __functionAddress = GL.getICD().glTexSubImage2D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, xoffset, yoffset, width, height, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexSubImage2D TexSubImage2D} + * + * @see Reference Page + */ + public static void glTexSubImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") int[] pixels) { + long __functionAddress = GL.getICD().glTexSubImage2D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, xoffset, yoffset, width, height, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexSubImage2D TexSubImage2D} + * + * @see Reference Page + */ + public static void glTexSubImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") float[] pixels) { + long __functionAddress = GL.getICD().glTexSubImage2D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, xoffset, yoffset, width, height, format, type, pixels, __functionAddress); + } + + /** + * Array version of: {@link #glTexSubImage2D TexSubImage2D} + * + * @see Reference Page + */ + public static void glTexSubImage2D(@NativeType("GLenum") int target, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @NativeType("void const *") double[] pixels) { + long __functionAddress = GL.getICD().glTexSubImage2D; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, level, xoffset, yoffset, width, height, format, type, pixels, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL12.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL12.java new file mode 100644 index 00000000..e86ac6e8 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL12.java @@ -0,0 +1,742 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * The OpenGL functionality up to version 1.2. Includes the deprecated symbols of the Compatibility Profile. + * + *Extensions promoted to core in this release:
+ * + *Extensions part of the imaging subset:
+ * + *| {@link GL12C#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12C#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} | {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12C#GL_BGR BGR} |
| {@link GL12C#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12C#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12C#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12C#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12C#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12C#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12C#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12C#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL12C#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12C#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} | {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12C#GL_BGR BGR} |
| {@link GL12C#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12C#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12C#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12C#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12C#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12C#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12C#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12C#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL12C#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12C#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} | {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12C#GL_BGR BGR} |
| {@link GL12C#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12C#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12C#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12C#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12C#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12C#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12C#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12C#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL12C#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12C#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} | {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12C#GL_BGR BGR} |
| {@link GL12C#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12C#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12C#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12C#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12C#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12C#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12C#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12C#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL12C#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12C#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} | {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12C#GL_BGR BGR} |
| {@link GL12C#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12C#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12C#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12C#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12C#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12C#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12C#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12C#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL12C#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12C#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} | {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12C#GL_BGR BGR} |
| {@link GL12C#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12C#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12C#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12C#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12C#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12C#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12C#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12C#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL12C#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12C#GL_BGR BGR} |
| {@link GL12C#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12C#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12C#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12C#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12C#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12C#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12C#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12C#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL12C#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12C#GL_BGR BGR} |
| {@link GL12C#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12C#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12C#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12C#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12C#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12C#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12C#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12C#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL12C#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12C#GL_BGR BGR} |
| {@link GL12C#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12C#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12C#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12C#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12C#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12C#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12C#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12C#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL12C#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12C#GL_BGR BGR} |
| {@link GL12C#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12C#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12C#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12C#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12C#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12C#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12C#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12C#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL12C#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12C#GL_BGR BGR} |
| {@link GL12C#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12C#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12C#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12C#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12C#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12C#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12C#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12C#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL12C#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12C#GL_BGR BGR} |
| {@link GL12C#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12C#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12C#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12C#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12C#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12C#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12C#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12C#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12C#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12C#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12C#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL12C#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
Implementations denote recommended maximum amounts of vertex and index data, which may be queried by calling glGet with argument + * {@link GL12C#GL_MAX_ELEMENTS_VERTICES MAX_ELEMENTS_VERTICES} and {@link GL12C#GL_MAX_ELEMENTS_INDICES MAX_ELEMENTS_INDICES}. If end - start + 1 is greater than the value of GL_MAX_ELEMENTS_VERTICES, or if + * count is greater than the value of GL_MAX_ELEMENTS_INDICES, then the call may operate at reduced performance. There is no requirement that all vertices + * in the range start end be referenced. However, the implementation may partially process unused vertices, reducing performance from what could be + * achieved with an optimal index set.
+ * + *When glDrawRangeElements is called, it uses count sequential elements from an enabled array, starting at start to construct a sequence of geometric + * primitives. mode specifies what kind of primitives are constructed, and how the array elements construct these primitives. If more than one array is + * enabled, each is used.
+ * + *Vertex attributes that are modified by glDrawRangeElements have an unspecified value after glDrawRangeElements returns. Attributes that aren't modified + * maintain their previous values.
+ * + *It is an error for indices to lie outside the range start end, but implementations may not check for this situation. Such indices cause + * implementation-dependent behavior.
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
Implementations denote recommended maximum amounts of vertex and index data, which may be queried by calling glGet with argument + * {@link GL12C#GL_MAX_ELEMENTS_VERTICES MAX_ELEMENTS_VERTICES} and {@link GL12C#GL_MAX_ELEMENTS_INDICES MAX_ELEMENTS_INDICES}. If end - start + 1 is greater than the value of GL_MAX_ELEMENTS_VERTICES, or if + * count is greater than the value of GL_MAX_ELEMENTS_INDICES, then the call may operate at reduced performance. There is no requirement that all vertices + * in the range start end be referenced. However, the implementation may partially process unused vertices, reducing performance from what could be + * achieved with an optimal index set.
+ * + *When glDrawRangeElements is called, it uses count sequential elements from an enabled array, starting at start to construct a sequence of geometric + * primitives. mode specifies what kind of primitives are constructed, and how the array elements construct these primitives. If more than one array is + * enabled, each is used.
+ * + *Vertex attributes that are modified by glDrawRangeElements have an unspecified value after glDrawRangeElements returns. Attributes that aren't modified + * maintain their previous values.
+ * + *It is an error for indices to lie outside the range start end, but implementations may not check for this situation. Such indices cause + * implementation-dependent behavior.
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
Implementations denote recommended maximum amounts of vertex and index data, which may be queried by calling glGet with argument + * {@link GL12C#GL_MAX_ELEMENTS_VERTICES MAX_ELEMENTS_VERTICES} and {@link GL12C#GL_MAX_ELEMENTS_INDICES MAX_ELEMENTS_INDICES}. If end - start + 1 is greater than the value of GL_MAX_ELEMENTS_VERTICES, or if + * count is greater than the value of GL_MAX_ELEMENTS_INDICES, then the call may operate at reduced performance. There is no requirement that all vertices + * in the range start end be referenced. However, the implementation may partially process unused vertices, reducing performance from what could be + * achieved with an optimal index set.
+ * + *When glDrawRangeElements is called, it uses count sequential elements from an enabled array, starting at start to construct a sequence of geometric + * primitives. mode specifies what kind of primitives are constructed, and how the array elements construct these primitives. If more than one array is + * enabled, each is used.
+ * + *Vertex attributes that are modified by glDrawRangeElements have an unspecified value after glDrawRangeElements returns. Attributes that aren't modified + * maintain their previous values.
+ * + *It is an error for indices to lie outside the range start end, but implementations may not check for this situation. Such indices cause + * implementation-dependent behavior.
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
Implementations denote recommended maximum amounts of vertex and index data, which may be queried by calling glGet with argument + * {@link GL12C#GL_MAX_ELEMENTS_VERTICES MAX_ELEMENTS_VERTICES} and {@link GL12C#GL_MAX_ELEMENTS_INDICES MAX_ELEMENTS_INDICES}. If end - start + 1 is greater than the value of GL_MAX_ELEMENTS_VERTICES, or if + * count is greater than the value of GL_MAX_ELEMENTS_INDICES, then the call may operate at reduced performance. There is no requirement that all vertices + * in the range start end be referenced. However, the implementation may partially process unused vertices, reducing performance from what could be + * achieved with an optimal index set.
+ * + *When glDrawRangeElements is called, it uses count sequential elements from an enabled array, starting at start to construct a sequence of geometric + * primitives. mode specifies what kind of primitives are constructed, and how the array elements construct these primitives. If more than one array is + * enabled, each is used.
+ * + *Vertex attributes that are modified by glDrawRangeElements have an unspecified value after glDrawRangeElements returns. Attributes that aren't modified + * maintain their previous values.
+ * + *It is an error for indices to lie outside the range start end, but implementations may not check for this situation. Such indices cause + * implementation-dependent behavior.
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
Implementations denote recommended maximum amounts of vertex and index data, which may be queried by calling glGet with argument + * {@link GL12C#GL_MAX_ELEMENTS_VERTICES MAX_ELEMENTS_VERTICES} and {@link GL12C#GL_MAX_ELEMENTS_INDICES MAX_ELEMENTS_INDICES}. If end - start + 1 is greater than the value of GL_MAX_ELEMENTS_VERTICES, or if + * count is greater than the value of GL_MAX_ELEMENTS_INDICES, then the call may operate at reduced performance. There is no requirement that all vertices + * in the range start end be referenced. However, the implementation may partially process unused vertices, reducing performance from what could be + * achieved with an optimal index set.
+ * + *When glDrawRangeElements is called, it uses count sequential elements from an enabled array, starting at start to construct a sequence of geometric + * primitives. mode specifies what kind of primitives are constructed, and how the array elements construct these primitives. If more than one array is + * enabled, each is used.
+ * + *Vertex attributes that are modified by glDrawRangeElements have an unspecified value after glDrawRangeElements returns. Attributes that aren't modified + * maintain their previous values.
+ * + *It is an error for indices to lie outside the range start end, but implementations may not check for this situation. Such indices cause + * implementation-dependent behavior.
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
Extensions promoted to core in this release:
+ * + *Extensions part of the imaging subset:
+ * + *| {@link #GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link #GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} | {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link #GL_BGR BGR} |
| {@link #GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link #GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link #GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link #GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link #GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link #GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link #GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link #GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link #GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link #GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link #GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link #GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link #GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link #GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} | {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link #GL_BGR BGR} |
| {@link #GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link #GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link #GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link #GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link #GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link #GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link #GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link #GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link #GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link #GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link #GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link #GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link #GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link #GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} | {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link #GL_BGR BGR} |
| {@link #GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link #GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link #GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link #GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link #GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link #GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link #GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link #GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link #GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link #GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link #GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link #GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link #GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link #GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} | {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link #GL_BGR BGR} |
| {@link #GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link #GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link #GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link #GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link #GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link #GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link #GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link #GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link #GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link #GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link #GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link #GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link #GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link #GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} | {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link #GL_BGR BGR} |
| {@link #GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link #GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link #GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link #GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link #GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link #GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link #GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link #GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link #GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link #GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link #GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link #GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link #GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link #GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL30#GL_R8 R8} | {@link GL31#GL_R8_SNORM R8_SNORM} | {@link GL30#GL_R16 R16} | {@link GL31#GL_R16_SNORM R16_SNORM} | {@link GL30#GL_RG8 RG8} | {@link GL31#GL_RG8_SNORM RG8_SNORM} |
| {@link GL30#GL_RG16 RG16} | {@link GL31#GL_RG16_SNORM RG16_SNORM} | {@link GL11#GL_R3_G3_B2 R3_G3_B2} | {@link GL11#GL_RGB4 RGB4} | {@link GL11#GL_RGB5 RGB5} | {@link GL41#GL_RGB565 RGB565} |
| {@link GL11#GL_RGB8 RGB8} | {@link GL31#GL_RGB8_SNORM RGB8_SNORM} | {@link GL11#GL_RGB10 RGB10} | {@link GL11#GL_RGB12 RGB12} | {@link GL11#GL_RGB16 RGB16} | {@link GL31#GL_RGB16_SNORM RGB16_SNORM} |
| {@link GL11#GL_RGBA2 RGBA2} | {@link GL11#GL_RGBA4 RGBA4} | {@link GL11#GL_RGB5_A1 RGB5_A1} | {@link GL11#GL_RGBA8 RGBA8} | {@link GL31#GL_RGBA8_SNORM RGBA8_SNORM} | {@link GL11#GL_RGB10_A2 RGB10_A2} |
| {@link GL33#GL_RGB10_A2UI RGB10_A2UI} | {@link GL11#GL_RGBA12 RGBA12} | {@link GL11#GL_RGBA16 RGBA16} | {@link GL31#GL_RGBA16_SNORM RGBA16_SNORM} | {@link GL21#GL_SRGB8 SRGB8} | {@link GL21#GL_SRGB8_ALPHA8 SRGB8_ALPHA8} |
| {@link GL30#GL_R16F R16F} | {@link GL30#GL_RG16F RG16F} | {@link GL30#GL_RGB16F RGB16F} | {@link GL30#GL_RGBA16F RGBA16F} | {@link GL30#GL_R32F R32F} | {@link GL30#GL_RG32F RG32F} |
| {@link GL30#GL_RGB32F RGB32F} | {@link GL30#GL_RGBA32F RGBA32F} | {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} | {@link GL30#GL_RGB9_E5 RGB9_E5} | {@link GL30#GL_R8I R8I} | {@link GL30#GL_R8UI R8UI} |
| {@link GL30#GL_R16I R16I} | {@link GL30#GL_R16UI R16UI} | {@link GL30#GL_R32I R32I} | {@link GL30#GL_R32UI R32UI} | {@link GL30#GL_RG8I RG8I} | {@link GL30#GL_RG8UI RG8UI} |
| {@link GL30#GL_RG16I RG16I} | {@link GL30#GL_RG16UI RG16UI} | {@link GL30#GL_RG32I RG32I} | {@link GL30#GL_RG32UI RG32UI} | {@link GL30#GL_RGB8I RGB8I} | {@link GL30#GL_RGB8UI RGB8UI} |
| {@link GL30#GL_RGB16I RGB16I} | {@link GL30#GL_RGB16UI RGB16UI} | {@link GL30#GL_RGB32I RGB32I} | {@link GL30#GL_RGB32UI RGB32UI} | {@link GL30#GL_RGBA8I RGBA8I} | {@link GL30#GL_RGBA8UI RGBA8UI} |
| {@link GL30#GL_RGBA16I RGBA16I} | {@link GL30#GL_RGBA16UI RGBA16UI} | {@link GL30#GL_RGBA32I RGBA32I} | {@link GL30#GL_RGBA32UI RGBA32UI} | {@link GL14#GL_DEPTH_COMPONENT16 DEPTH_COMPONENT16} | {@link GL14#GL_DEPTH_COMPONENT24 DEPTH_COMPONENT24} |
| {@link GL14#GL_DEPTH_COMPONENT32 DEPTH_COMPONENT32} | {@link GL30#GL_DEPTH24_STENCIL8 DEPTH24_STENCIL8} | {@link GL30#GL_DEPTH_COMPONENT32F DEPTH_COMPONENT32F} | {@link GL30#GL_DEPTH32F_STENCIL8 DEPTH32F_STENCIL8} | {@link GL30#GL_COMPRESSED_RED COMPRESSED_RED} | {@link GL30#GL_COMPRESSED_RG COMPRESSED_RG} |
| {@link GL13#GL_COMPRESSED_RGB COMPRESSED_RGB} | {@link GL13#GL_COMPRESSED_RGBA COMPRESSED_RGBA} | {@link GL21#GL_COMPRESSED_SRGB COMPRESSED_SRGB} | {@link GL21#GL_COMPRESSED_SRGB_ALPHA COMPRESSED_SRGB_ALPHA} | {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} | {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} | {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} | {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} | see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link #GL_BGR BGR} |
| {@link #GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link #GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link #GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link #GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link #GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link #GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link #GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link #GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link #GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link #GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link #GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link #GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link #GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link #GL_BGR BGR} |
| {@link #GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link #GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link #GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link #GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link #GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link #GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link #GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link #GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link #GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link #GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link #GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link #GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link #GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link #GL_BGR BGR} |
| {@link #GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link #GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link #GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link #GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link #GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link #GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link #GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link #GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link #GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link #GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link #GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link #GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link #GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link #GL_BGR BGR} |
| {@link #GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link #GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link #GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link #GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link #GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link #GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link #GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link #GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link #GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link #GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link #GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link #GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link #GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link #GL_BGR BGR} |
| {@link #GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link #GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link #GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link #GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link #GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link #GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link #GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link #GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link #GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link #GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link #GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link #GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link #GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link #GL_BGR BGR} |
| {@link #GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link #GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link #GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link #GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link #GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link #GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link #GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link #GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link #GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link #GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link #GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link #GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link #GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link #GL_BGR BGR} |
| {@link #GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link #GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link #GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link #GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link #GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link #GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link #GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link #GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link #GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link #GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link #GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link #GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link #GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link #GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
Implementations denote recommended maximum amounts of vertex and index data, which may be queried by calling glGet with argument + * {@link #GL_MAX_ELEMENTS_VERTICES MAX_ELEMENTS_VERTICES} and {@link #GL_MAX_ELEMENTS_INDICES MAX_ELEMENTS_INDICES}. If end - start + 1 is greater than the value of GL_MAX_ELEMENTS_VERTICES, or if + * count is greater than the value of GL_MAX_ELEMENTS_INDICES, then the call may operate at reduced performance. There is no requirement that all vertices + * in the range start end be referenced. However, the implementation may partially process unused vertices, reducing performance from what could be + * achieved with an optimal index set.
+ * + *When glDrawRangeElements is called, it uses count sequential elements from an enabled array, starting at start to construct a sequence of geometric + * primitives. mode specifies what kind of primitives are constructed, and how the array elements construct these primitives. If more than one array is + * enabled, each is used.
+ * + *Vertex attributes that are modified by glDrawRangeElements have an unspecified value after glDrawRangeElements returns. Attributes that aren't modified + * maintain their previous values.
+ * + *It is an error for indices to lie outside the range start end, but implementations may not check for this situation. Such indices cause + * implementation-dependent behavior.
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
Implementations denote recommended maximum amounts of vertex and index data, which may be queried by calling glGet with argument + * {@link #GL_MAX_ELEMENTS_VERTICES MAX_ELEMENTS_VERTICES} and {@link #GL_MAX_ELEMENTS_INDICES MAX_ELEMENTS_INDICES}. If end - start + 1 is greater than the value of GL_MAX_ELEMENTS_VERTICES, or if + * count is greater than the value of GL_MAX_ELEMENTS_INDICES, then the call may operate at reduced performance. There is no requirement that all vertices + * in the range start end be referenced. However, the implementation may partially process unused vertices, reducing performance from what could be + * achieved with an optimal index set.
+ * + *When glDrawRangeElements is called, it uses count sequential elements from an enabled array, starting at start to construct a sequence of geometric + * primitives. mode specifies what kind of primitives are constructed, and how the array elements construct these primitives. If more than one array is + * enabled, each is used.
+ * + *Vertex attributes that are modified by glDrawRangeElements have an unspecified value after glDrawRangeElements returns. Attributes that aren't modified + * maintain their previous values.
+ * + *It is an error for indices to lie outside the range start end, but implementations may not check for this situation. Such indices cause + * implementation-dependent behavior.
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
Implementations denote recommended maximum amounts of vertex and index data, which may be queried by calling glGet with argument + * {@link #GL_MAX_ELEMENTS_VERTICES MAX_ELEMENTS_VERTICES} and {@link #GL_MAX_ELEMENTS_INDICES MAX_ELEMENTS_INDICES}. If end - start + 1 is greater than the value of GL_MAX_ELEMENTS_VERTICES, or if + * count is greater than the value of GL_MAX_ELEMENTS_INDICES, then the call may operate at reduced performance. There is no requirement that all vertices + * in the range start end be referenced. However, the implementation may partially process unused vertices, reducing performance from what could be + * achieved with an optimal index set.
+ * + *When glDrawRangeElements is called, it uses count sequential elements from an enabled array, starting at start to construct a sequence of geometric + * primitives. mode specifies what kind of primitives are constructed, and how the array elements construct these primitives. If more than one array is + * enabled, each is used.
+ * + *Vertex attributes that are modified by glDrawRangeElements have an unspecified value after glDrawRangeElements returns. Attributes that aren't modified + * maintain their previous values.
+ * + *It is an error for indices to lie outside the range start end, but implementations may not check for this situation. Such indices cause + * implementation-dependent behavior.
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
Implementations denote recommended maximum amounts of vertex and index data, which may be queried by calling glGet with argument + * {@link #GL_MAX_ELEMENTS_VERTICES MAX_ELEMENTS_VERTICES} and {@link #GL_MAX_ELEMENTS_INDICES MAX_ELEMENTS_INDICES}. If end - start + 1 is greater than the value of GL_MAX_ELEMENTS_VERTICES, or if + * count is greater than the value of GL_MAX_ELEMENTS_INDICES, then the call may operate at reduced performance. There is no requirement that all vertices + * in the range start end be referenced. However, the implementation may partially process unused vertices, reducing performance from what could be + * achieved with an optimal index set.
+ * + *When glDrawRangeElements is called, it uses count sequential elements from an enabled array, starting at start to construct a sequence of geometric + * primitives. mode specifies what kind of primitives are constructed, and how the array elements construct these primitives. If more than one array is + * enabled, each is used.
+ * + *Vertex attributes that are modified by glDrawRangeElements have an unspecified value after glDrawRangeElements returns. Attributes that aren't modified + * maintain their previous values.
+ * + *It is an error for indices to lie outside the range start end, but implementations may not check for this situation. Such indices cause + * implementation-dependent behavior.
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
Implementations denote recommended maximum amounts of vertex and index data, which may be queried by calling glGet with argument + * {@link #GL_MAX_ELEMENTS_VERTICES MAX_ELEMENTS_VERTICES} and {@link #GL_MAX_ELEMENTS_INDICES MAX_ELEMENTS_INDICES}. If end - start + 1 is greater than the value of GL_MAX_ELEMENTS_VERTICES, or if + * count is greater than the value of GL_MAX_ELEMENTS_INDICES, then the call may operate at reduced performance. There is no requirement that all vertices + * in the range start end be referenced. However, the implementation may partially process unused vertices, reducing performance from what could be + * achieved with an optimal index set.
+ * + *When glDrawRangeElements is called, it uses count sequential elements from an enabled array, starting at start to construct a sequence of geometric + * primitives. mode specifies what kind of primitives are constructed, and how the array elements construct these primitives. If more than one array is + * enabled, each is used.
+ * + *Vertex attributes that are modified by glDrawRangeElements have an unspecified value after glDrawRangeElements returns. Attributes that aren't modified + * maintain their previous values.
+ * + *It is an error for indices to lie outside the range start end, but implementations may not check for this situation. Such indices cause + * implementation-dependent behavior.
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
Extensions promoted to core in this release:
+ * + *| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13C#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13C#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13C#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13C#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13C#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13C#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL13C#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13C#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} | {@link GL13C#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} |
| {@link GL13C#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13C#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13C#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL13C#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13C#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} | {@link GL13C#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} |
| {@link GL13C#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13C#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13C#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
Multisampling samples a pixel multiple times at various implementation-dependent subpixel locations to generate antialiasing effects. Multisampling + * transparently antialiases points, lines, polygons, and images if it is enabled.
+ * + *{@code value} is used in constructing a temporary mask used in determining which samples will be used in resolving the final fragment color. This mask + * is bitwise-ANDed with the coverage mask generated from the multisampling computation. If the {@code invert} flag is set, the temporary mask is inverted + * (all bits flipped) and then the bitwise-AND is computed.
+ * + *If an implementation does not have any multisample buffers available, or multisampling is disabled, rasterization occurs with only a single sample + * computing a pixel's final RGB color.
+ * + *Provided an implementation supports multisample buffers, and multisampling is enabled, then a pixel's final color is generated by combining several + * samples per pixel. Each sample contains color, depth, and stencil information, allowing those operations to be performed on each sample.
+ * + * @param value a sample coverage value. The value is clamped to the range [0, 1]. The initial value is 1.0. + * @param invert if the coverage masks should be inverted. The initial value is false. + * + * @see Reference Page + */ + public static void glSampleCoverage(@NativeType("GLfloat") float value, @NativeType("GLboolean") boolean invert) { + GL13C.glSampleCoverage(value, invert); + } + + // --- [ glActiveTexture ] --- + + /** + * Selects which texture unit subsequent texture state calls will affect. The number of texture units an implementation supports is implementation + * dependent. + * + * @param texture which texture unit to make active. One of:| {@link GL13C#GL_TEXTURE0 TEXTURE0} | GL_TEXTURE[1-31] |
| {@link #GL_TEXTURE0 TEXTURE0} | GL_TEXTURE[1-31] |
The matrix is stored as 16 consecutive values, i.e. as:
+ * + *| a1 | a2 | a3 | a4 |
| a5 | a6 | a7 | a8 |
| a9 | a10 | a11 | a12 |
| a13 | a14 | a15 | a16 |
Extensions promoted to core in this release:
+ * + *| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link #GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link #GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link #GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link #GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link #GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link #GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link #GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link #GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} | {@link #GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} |
| {@link #GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link #GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link #GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link #GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link #GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} | {@link #GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} |
| {@link #GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link #GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link #GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
Multisampling samples a pixel multiple times at various implementation-dependent subpixel locations to generate antialiasing effects. Multisampling + * transparently antialiases points, lines, polygons, and images if it is enabled.
+ * + *{@code value} is used in constructing a temporary mask used in determining which samples will be used in resolving the final fragment color. This mask + * is bitwise-ANDed with the coverage mask generated from the multisampling computation. If the {@code invert} flag is set, the temporary mask is inverted + * (all bits flipped) and then the bitwise-AND is computed.
+ * + *If an implementation does not have any multisample buffers available, or multisampling is disabled, rasterization occurs with only a single sample + * computing a pixel's final RGB color.
+ * + *Provided an implementation supports multisample buffers, and multisampling is enabled, then a pixel's final color is generated by combining several + * samples per pixel. Each sample contains color, depth, and stencil information, allowing those operations to be performed on each sample.
+ * + * @param value a sample coverage value. The value is clamped to the range [0, 1]. The initial value is 1.0. + * @param invert if the coverage masks should be inverted. The initial value is false. + * + * @see Reference Page + */ + public static native void glSampleCoverage(@NativeType("GLfloat") float value, @NativeType("GLboolean") boolean invert); + + // --- [ glActiveTexture ] --- + + /** + * Selects which texture unit subsequent texture state calls will affect. The number of texture units an implementation supports is implementation + * dependent. + * + * @param texture which texture unit to make active. One of:| {@link #GL_TEXTURE0 TEXTURE0} | GL_TEXTURE[1-31] |
Extensions promoted to core in this release:
+ * + *| {@link GL14C#GL_FUNC_ADD FUNC_ADD} | {@link GL14C#GL_FUNC_SUBTRACT FUNC_SUBTRACT} | {@link GL14C#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} | {@link GL14C#GL_MIN MIN} | {@link GL14C#GL_MAX MAX} |
| {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} |
| {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} |
| {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} |
| {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
LWJGL note: Use {@link org.lwjgl.system.MemoryUtil#memAddress} to retrieve pointers to the index buffers.
+ * + * @param mode the kind of primitives to render. One of:| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL14C#GL_POINT_FADE_THRESHOLD_SIZE POINT_FADE_THRESHOLD_SIZE} |
| {@link GL14C#GL_POINT_FADE_THRESHOLD_SIZE POINT_FADE_THRESHOLD_SIZE} |
| 3 |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 3 |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 3 |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 3 |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
| 3 |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} |
| {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} |
Extensions promoted to core in this release:
+ * + *| {@link #GL_FUNC_ADD FUNC_ADD} | {@link #GL_FUNC_SUBTRACT FUNC_SUBTRACT} | {@link #GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} | {@link #GL_MIN MIN} | {@link #GL_MAX MAX} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
LWJGL note: Use {@link org.lwjgl.system.MemoryUtil#memAddress} to retrieve pointers to the index buffers.
+ * + * @param mode the kind of primitives to render. One of:| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link #GL_POINT_FADE_THRESHOLD_SIZE POINT_FADE_THRESHOLD_SIZE} |
| {@link #GL_POINT_FADE_THRESHOLD_SIZE POINT_FADE_THRESHOLD_SIZE} |
Extensions promoted to core in this release:
+ * + *| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15C#GL_STREAM_READ STREAM_READ} | {@link GL15C#GL_STREAM_COPY STREAM_COPY} | {@link GL15C#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15C#GL_STATIC_READ STATIC_READ} | {@link GL15C#GL_STATIC_COPY STATIC_COPY} | {@link GL15C#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15C#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15C#GL_DYNAMIC_COPY DYNAMIC_COPY} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15C#GL_STREAM_READ STREAM_READ} | {@link GL15C#GL_STREAM_COPY STREAM_COPY} | {@link GL15C#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15C#GL_STATIC_READ STATIC_READ} | {@link GL15C#GL_STATIC_COPY STATIC_COPY} | {@link GL15C#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15C#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15C#GL_DYNAMIC_COPY DYNAMIC_COPY} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15C#GL_STREAM_READ STREAM_READ} | {@link GL15C#GL_STREAM_COPY STREAM_COPY} | {@link GL15C#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15C#GL_STATIC_READ STATIC_READ} | {@link GL15C#GL_STATIC_COPY STATIC_COPY} | {@link GL15C#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15C#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15C#GL_DYNAMIC_COPY DYNAMIC_COPY} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15C#GL_STREAM_READ STREAM_READ} | {@link GL15C#GL_STREAM_COPY STREAM_COPY} | {@link GL15C#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15C#GL_STATIC_READ STATIC_READ} | {@link GL15C#GL_STATIC_COPY STATIC_COPY} | {@link GL15C#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15C#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15C#GL_DYNAMIC_COPY DYNAMIC_COPY} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15C#GL_STREAM_READ STREAM_READ} | {@link GL15C#GL_STREAM_COPY STREAM_COPY} | {@link GL15C#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15C#GL_STATIC_READ STATIC_READ} | {@link GL15C#GL_STATIC_COPY STATIC_COPY} | {@link GL15C#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15C#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15C#GL_DYNAMIC_COPY DYNAMIC_COPY} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15C#GL_STREAM_READ STREAM_READ} | {@link GL15C#GL_STREAM_COPY STREAM_COPY} | {@link GL15C#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15C#GL_STATIC_READ STATIC_READ} | {@link GL15C#GL_STATIC_COPY STATIC_COPY} | {@link GL15C#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15C#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15C#GL_DYNAMIC_COPY DYNAMIC_COPY} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15C#GL_STREAM_READ STREAM_READ} | {@link GL15C#GL_STREAM_COPY STREAM_COPY} | {@link GL15C#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15C#GL_STATIC_READ STATIC_READ} | {@link GL15C#GL_STATIC_COPY STATIC_COPY} | {@link GL15C#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15C#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15C#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
LWJGL note: This method comes in 3 flavors:
+ * + *| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_READ_ONLY READ_ONLY} | {@link GL15C#GL_WRITE_ONLY WRITE_ONLY} | {@link GL15C#GL_READ_WRITE READ_WRITE} |
LWJGL note: This method comes in 3 flavors:
+ * + *| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_READ_ONLY READ_ONLY} | {@link GL15C#GL_WRITE_ONLY WRITE_ONLY} | {@link GL15C#GL_READ_WRITE READ_WRITE} |
LWJGL note: This method comes in 3 flavors:
+ * + *| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_READ_ONLY READ_ONLY} | {@link GL15C#GL_WRITE_ONLY WRITE_ONLY} | {@link GL15C#GL_READ_WRITE READ_WRITE} |
Returns TRUE unless data values in the buffer’s data store have become corrupted during the period that the buffer was mapped. Such corruption can be + * the result of a screen resolution change or other window system-dependent event that causes system heaps such as those for high-performance graphics + * memory to be discarded. GL implementations must guarantee that such corruption can occur only during the periods that a buffer’s data store is mapped. + * If such corruption has occurred, UnmapBuffer returns FALSE, and the contents of the buffer’s data store become undefined.
+ * + * @param target the target buffer object being unmapped. One of:| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15C#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15C#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15C#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15C#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15C#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15C#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_BUFFER_MAP_POINTER BUFFER_MAP_POINTER} |
| {@link GL15C#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15C#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15C#GL_BUFFER_MAP_POINTER BUFFER_MAP_POINTER} |
| {@link GL15C#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15C#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15C#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15C#GL_QUERY_COUNTER_BITS QUERY_COUNTER_BITS} | {@link GL15C#GL_CURRENT_QUERY CURRENT_QUERY} |
| {@link GL15C#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15C#GL_QUERY_COUNTER_BITS QUERY_COUNTER_BITS} | {@link GL15C#GL_CURRENT_QUERY CURRENT_QUERY} |
| {@link GL15C#GL_QUERY_RESULT QUERY_RESULT} | {@link GL15C#GL_QUERY_RESULT_AVAILABLE QUERY_RESULT_AVAILABLE} |
| {@link GL15C#GL_QUERY_RESULT QUERY_RESULT} | {@link GL15C#GL_QUERY_RESULT_AVAILABLE QUERY_RESULT_AVAILABLE} |
| {@link GL15C#GL_QUERY_RESULT QUERY_RESULT} | {@link GL15C#GL_QUERY_RESULT_AVAILABLE QUERY_RESULT_AVAILABLE} |
| {@link GL15C#GL_QUERY_RESULT QUERY_RESULT} | {@link GL15C#GL_QUERY_RESULT_AVAILABLE QUERY_RESULT_AVAILABLE} |
Extensions promoted to core in this release:
+ * + *| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_STREAM_DRAW STREAM_DRAW} | {@link #GL_STREAM_READ STREAM_READ} | {@link #GL_STREAM_COPY STREAM_COPY} | {@link #GL_STATIC_DRAW STATIC_DRAW} | {@link #GL_STATIC_READ STATIC_READ} | {@link #GL_STATIC_COPY STATIC_COPY} | {@link #GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link #GL_DYNAMIC_READ DYNAMIC_READ} | {@link #GL_DYNAMIC_COPY DYNAMIC_COPY} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_STREAM_DRAW STREAM_DRAW} | {@link #GL_STREAM_READ STREAM_READ} | {@link #GL_STREAM_COPY STREAM_COPY} | {@link #GL_STATIC_DRAW STATIC_DRAW} | {@link #GL_STATIC_READ STATIC_READ} | {@link #GL_STATIC_COPY STATIC_COPY} | {@link #GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link #GL_DYNAMIC_READ DYNAMIC_READ} | {@link #GL_DYNAMIC_COPY DYNAMIC_COPY} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_STREAM_DRAW STREAM_DRAW} | {@link #GL_STREAM_READ STREAM_READ} | {@link #GL_STREAM_COPY STREAM_COPY} | {@link #GL_STATIC_DRAW STATIC_DRAW} | {@link #GL_STATIC_READ STATIC_READ} | {@link #GL_STATIC_COPY STATIC_COPY} | {@link #GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link #GL_DYNAMIC_READ DYNAMIC_READ} | {@link #GL_DYNAMIC_COPY DYNAMIC_COPY} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_STREAM_DRAW STREAM_DRAW} | {@link #GL_STREAM_READ STREAM_READ} | {@link #GL_STREAM_COPY STREAM_COPY} | {@link #GL_STATIC_DRAW STATIC_DRAW} | {@link #GL_STATIC_READ STATIC_READ} | {@link #GL_STATIC_COPY STATIC_COPY} | {@link #GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link #GL_DYNAMIC_READ DYNAMIC_READ} | {@link #GL_DYNAMIC_COPY DYNAMIC_COPY} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_STREAM_DRAW STREAM_DRAW} | {@link #GL_STREAM_READ STREAM_READ} | {@link #GL_STREAM_COPY STREAM_COPY} | {@link #GL_STATIC_DRAW STATIC_DRAW} | {@link #GL_STATIC_READ STATIC_READ} | {@link #GL_STATIC_COPY STATIC_COPY} | {@link #GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link #GL_DYNAMIC_READ DYNAMIC_READ} | {@link #GL_DYNAMIC_COPY DYNAMIC_COPY} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_STREAM_DRAW STREAM_DRAW} | {@link #GL_STREAM_READ STREAM_READ} | {@link #GL_STREAM_COPY STREAM_COPY} | {@link #GL_STATIC_DRAW STATIC_DRAW} | {@link #GL_STATIC_READ STATIC_READ} | {@link #GL_STATIC_COPY STATIC_COPY} | {@link #GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link #GL_DYNAMIC_READ DYNAMIC_READ} | {@link #GL_DYNAMIC_COPY DYNAMIC_COPY} |
{@code usage} is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make + * more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. + * {@code usage} can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access. The + * frequency of access may be one of these:
+ * + *The nature of access may be one of these:
+ * + *| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_STREAM_DRAW STREAM_DRAW} | {@link #GL_STREAM_READ STREAM_READ} | {@link #GL_STREAM_COPY STREAM_COPY} | {@link #GL_STATIC_DRAW STATIC_DRAW} | {@link #GL_STATIC_READ STATIC_READ} | {@link #GL_STATIC_COPY STATIC_COPY} | {@link #GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link #GL_DYNAMIC_READ DYNAMIC_READ} | {@link #GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
LWJGL note: This method comes in 3 flavors:
+ * + *| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_READ_ONLY READ_ONLY} | {@link #GL_WRITE_ONLY WRITE_ONLY} | {@link #GL_READ_WRITE READ_WRITE} |
LWJGL note: This method comes in 3 flavors:
+ * + *| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_READ_ONLY READ_ONLY} | {@link #GL_WRITE_ONLY WRITE_ONLY} | {@link #GL_READ_WRITE READ_WRITE} |
LWJGL note: This method comes in 3 flavors:
+ * + *| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_READ_ONLY READ_ONLY} | {@link #GL_WRITE_ONLY WRITE_ONLY} | {@link #GL_READ_WRITE READ_WRITE} |
Returns TRUE unless data values in the buffer’s data store have become corrupted during the period that the buffer was mapped. Such corruption can be + * the result of a screen resolution change or other window system-dependent event that causes system heaps such as those for high-performance graphics + * memory to be discarded. GL implementations must guarantee that such corruption can occur only during the periods that a buffer’s data store is mapped. + * If such corruption has occurred, UnmapBuffer returns FALSE, and the contents of the buffer’s data store become undefined.
+ * + * @param target the target buffer object being unmapped. One of:| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link #GL_BUFFER_USAGE BUFFER_USAGE} | {@link #GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link #GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link #GL_BUFFER_USAGE BUFFER_USAGE} | {@link #GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link #GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_BUFFER_MAP_POINTER BUFFER_MAP_POINTER} |
| {@link #GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_BUFFER_MAP_POINTER BUFFER_MAP_POINTER} |
| {@link #GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link #GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link #GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link #GL_QUERY_COUNTER_BITS QUERY_COUNTER_BITS} | {@link #GL_CURRENT_QUERY CURRENT_QUERY} |
| {@link #GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link #GL_QUERY_COUNTER_BITS QUERY_COUNTER_BITS} | {@link #GL_CURRENT_QUERY CURRENT_QUERY} |
| {@link #GL_QUERY_RESULT QUERY_RESULT} | {@link #GL_QUERY_RESULT_AVAILABLE QUERY_RESULT_AVAILABLE} |
| {@link #GL_QUERY_RESULT QUERY_RESULT} | {@link #GL_QUERY_RESULT_AVAILABLE QUERY_RESULT_AVAILABLE} |
| {@link #GL_QUERY_RESULT QUERY_RESULT} | {@link #GL_QUERY_RESULT_AVAILABLE QUERY_RESULT_AVAILABLE} |
| {@link #GL_QUERY_RESULT QUERY_RESULT} | {@link #GL_QUERY_RESULT_AVAILABLE QUERY_RESULT_AVAILABLE} |
Extensions promoted to core in this release:
+ * + *| {@link GL20C#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20C#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
In order to create a complete shader program, there must be a way to specify the list of things that will be linked together. Program objects provide + * this mechanism. Shaders that are to be linked together in a program object must first be attached to that program object. glAttachShader attaches the + * shader object specified by shader to the program object specified by program. This indicates that shader will be included in link operations that will + * be performed on program.
+ * + *All operations that can be performed on a shader object are valid whether or not the shader object is attached to a program object. It is permissible to + * attach a shader object to a program object before source code has been loaded into the shader object or before the shader object has been compiled. It + * is permissible to attach multiple shader objects of the same type because each may contain a portion of the complete shader. It is also permissible to + * attach a shader object to more than one program object. If a shader object is deleted while it is attached to a program object, it will be flagged for + * deletion, and deletion will not occur until glDetachShader is called to detach it from all program objects to which it is attached.
+ * + * @param program the program object to which a shader object will be attached + * @param shader the shader object that is to be attached + * + * @see Reference Page + */ + public static void glAttachShader(@NativeType("GLuint") int program, @NativeType("GLuint") int shader) { + GL20C.glAttachShader(program, shader); + } + + // --- [ glDetachShader ] --- + + /** + * Detaches a shader object from a program object to which it is attached. + * + * @param program the program object from which to detach the shader object + * @param shader the shader object to be detached + * + * @see Reference Page + */ + public static void glDetachShader(@NativeType("GLuint") int program, @NativeType("GLuint") int shader) { + GL20C.glDetachShader(program, shader); + } + + // --- [ glShaderSource ] --- + + /** + * Unsafe version of: {@link #glShaderSource ShaderSource} + * + * @param count the number of elements in the string and length arrays + */ + public static void nglShaderSource(int shader, int count, long strings, long length) { + GL20C.nglShaderSource(shader, count, strings, length); + } + + /** + * Sets the source code in {@code shader} to the source code in the array of strings specified by {@code strings}. Any source code previously stored in the + * shader object is completely replaced. The number of strings in the array is specified by {@code count}. If {@code length} is {@code NULL}, each string is + * assumed to be null terminated. If {@code length} is a value other than {@code NULL}, it points to an array containing a string length for each of the + * corresponding elements of {@code strings}. Each element in the length array may contain the length of the corresponding string (the null character is not + * counted as part of the string length) or a value less than 0 to indicate that the string is null terminated. The source code strings are not scanned or + * parsed at this time; they are simply copied into the specified shader object. + * + * @param shader the shader object whose source code is to be replaced + * @param strings an array of pointers to strings containing the source code to be loaded into the shader + * @param length an array of string lengths + * + * @see Reference Page + */ + public static void glShaderSource(@NativeType("GLuint") int shader, @NativeType("GLchar const **") PointerBuffer strings, @Nullable @NativeType("GLint const *") IntBuffer length) { + GL20C.glShaderSource(shader, strings, length); + } + + /** + * Sets the source code in {@code shader} to the source code in the array of strings specified by {@code strings}. Any source code previously stored in the + * shader object is completely replaced. The number of strings in the array is specified by {@code count}. If {@code length} is {@code NULL}, each string is + * assumed to be null terminated. If {@code length} is a value other than {@code NULL}, it points to an array containing a string length for each of the + * corresponding elements of {@code strings}. Each element in the length array may contain the length of the corresponding string (the null character is not + * counted as part of the string length) or a value less than 0 to indicate that the string is null terminated. The source code strings are not scanned or + * parsed at this time; they are simply copied into the specified shader object. + * + * @param shader the shader object whose source code is to be replaced + * @param strings an array of pointers to strings containing the source code to be loaded into the shader + * + * @see Reference Page + */ + public static void glShaderSource(@NativeType("GLuint") int shader, @NativeType("GLchar const **") CharSequence... strings) { + GL20C.glShaderSource(shader, strings); + } + + /** + * Sets the source code in {@code shader} to the source code in the array of strings specified by {@code strings}. Any source code previously stored in the + * shader object is completely replaced. The number of strings in the array is specified by {@code count}. If {@code length} is {@code NULL}, each string is + * assumed to be null terminated. If {@code length} is a value other than {@code NULL}, it points to an array containing a string length for each of the + * corresponding elements of {@code strings}. Each element in the length array may contain the length of the corresponding string (the null character is not + * counted as part of the string length) or a value less than 0 to indicate that the string is null terminated. The source code strings are not scanned or + * parsed at this time; they are simply copied into the specified shader object. + * + * @param shader the shader object whose source code is to be replaced + * + * @see Reference Page + */ + public static void glShaderSource(@NativeType("GLuint") int shader, @NativeType("GLchar const **") CharSequence string) { + GL20C.glShaderSource(shader, string); + } + + // --- [ glCompileShader ] --- + + /** + * Compiles a shader object. + * + * @param shader the shader object to be compiled + * + * @see Reference Page + */ + public static void glCompileShader(@NativeType("GLuint") int shader) { + GL20C.glCompileShader(shader); + } + + // --- [ glLinkProgram ] --- + + /** + * Links a program object. + * + * @param program the program object to be linked + * + * @see Reference Page + */ + public static void glLinkProgram(@NativeType("GLuint") int program) { + GL20C.glLinkProgram(program); + } + + // --- [ glUseProgram ] --- + + /** + * Installs a program object as part of current rendering state. + * + * @param program the program object whose executables are to be used as part of current rendering state + * + * @see Reference Page + */ + public static void glUseProgram(@NativeType("GLuint") int program) { + GL20C.glUseProgram(program); + } + + // --- [ glValidateProgram ] --- + + /** + * Validates a program object. + * + * @param program the program object to be validated + * + * @see Reference Page + */ + public static void glValidateProgram(@NativeType("GLuint") int program) { + GL20C.glValidateProgram(program); + } + + // --- [ glUniform1f ] --- + + /** + * Specifies the value of a float uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform value + * + * @see Reference Page + */ + public static void glUniform1f(@NativeType("GLint") int location, @NativeType("GLfloat") float v0) { + GL20C.glUniform1f(location, v0); + } + + // --- [ glUniform2f ] --- + + /** + * Specifies the value of a vec2 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform x value + * @param v1 the uniform y value + * + * @see Reference Page + */ + public static void glUniform2f(@NativeType("GLint") int location, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1) { + GL20C.glUniform2f(location, v0, v1); + } + + // --- [ glUniform3f ] --- + + /** + * Specifies the value of a vec3 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform x value + * @param v1 the uniform y value + * @param v2 the uniform z value + * + * @see Reference Page + */ + public static void glUniform3f(@NativeType("GLint") int location, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1, @NativeType("GLfloat") float v2) { + GL20C.glUniform3f(location, v0, v1, v2); + } + + // --- [ glUniform4f ] --- + + /** + * Specifies the value of a vec4 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform x value + * @param v1 the uniform y value + * @param v2 the uniform z value + * @param v3 the uniform w value + * + * @see Reference Page + */ + public static void glUniform4f(@NativeType("GLint") int location, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1, @NativeType("GLfloat") float v2, @NativeType("GLfloat") float v3) { + GL20C.glUniform4f(location, v0, v1, v2, v3); + } + + // --- [ glUniform1i ] --- + + /** + * Specifies the value of an int uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform value + * + * @see Reference Page + */ + public static void glUniform1i(@NativeType("GLint") int location, @NativeType("GLint") int v0) { + GL20C.glUniform1i(location, v0); + } + + // --- [ glUniform2i ] --- + + /** + * Specifies the value of an ivec2 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform x value + * @param v1 the uniform y value + * + * @see Reference Page + */ + public static void glUniform2i(@NativeType("GLint") int location, @NativeType("GLint") int v0, @NativeType("GLint") int v1) { + GL20C.glUniform2i(location, v0, v1); + } + + // --- [ glUniform3i ] --- + + /** + * Specifies the value of an ivec3 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform x value + * @param v1 the uniform y value + * @param v2 the uniform z value + * + * @see Reference Page + */ + public static void glUniform3i(@NativeType("GLint") int location, @NativeType("GLint") int v0, @NativeType("GLint") int v1, @NativeType("GLint") int v2) { + GL20C.glUniform3i(location, v0, v1, v2); + } + + // --- [ glUniform4i ] --- + + /** + * Specifies the value of an ivec4 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform x value + * @param v1 the uniform y value + * @param v2 the uniform z value + * @param v3 the uniform w value + * + * @see Reference Page + */ + public static void glUniform4i(@NativeType("GLint") int location, @NativeType("GLint") int v0, @NativeType("GLint") int v1, @NativeType("GLint") int v2, @NativeType("GLint") int v3) { + GL20C.glUniform4i(location, v0, v1, v2, v3); + } + + // --- [ glUniform1fv ] --- + + /** + * Unsafe version of: {@link #glUniform1fv Uniform1fv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static void nglUniform1fv(int location, int count, long value) { + GL20C.nglUniform1fv(location, count, value); + } + + /** + * Specifies the value of a single float uniform variable or a float uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform1fv(@NativeType("GLint") int location, @NativeType("GLfloat const *") FloatBuffer value) { + GL20C.glUniform1fv(location, value); + } + + // --- [ glUniform2fv ] --- + + /** + * Unsafe version of: {@link #glUniform2fv Uniform2fv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static void nglUniform2fv(int location, int count, long value) { + GL20C.nglUniform2fv(location, count, value); + } + + /** + * Specifies the value of a single vec2 uniform variable or a vec2 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform2fv(@NativeType("GLint") int location, @NativeType("GLfloat const *") FloatBuffer value) { + GL20C.glUniform2fv(location, value); + } + + // --- [ glUniform3fv ] --- + + /** + * Unsafe version of: {@link #glUniform3fv Uniform3fv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static void nglUniform3fv(int location, int count, long value) { + GL20C.nglUniform3fv(location, count, value); + } + + /** + * Specifies the value of a single vec3 uniform variable or a vec3 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform3fv(@NativeType("GLint") int location, @NativeType("GLfloat const *") FloatBuffer value) { + GL20C.glUniform3fv(location, value); + } + + // --- [ glUniform4fv ] --- + + /** + * Unsafe version of: {@link #glUniform4fv Uniform4fv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static void nglUniform4fv(int location, int count, long value) { + GL20C.nglUniform4fv(location, count, value); + } + + /** + * Specifies the value of a single vec4 uniform variable or a vec4 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform4fv(@NativeType("GLint") int location, @NativeType("GLfloat const *") FloatBuffer value) { + GL20C.glUniform4fv(location, value); + } + + // --- [ glUniform1iv ] --- + + /** + * Unsafe version of: {@link #glUniform1iv Uniform1iv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static void nglUniform1iv(int location, int count, long value) { + GL20C.nglUniform1iv(location, count, value); + } + + /** + * Specifies the value of a single int uniform variable or a int uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform1iv(@NativeType("GLint") int location, @NativeType("GLint const *") IntBuffer value) { + GL20C.glUniform1iv(location, value); + } + + // --- [ glUniform2iv ] --- + + /** + * Unsafe version of: {@link #glUniform2iv Uniform2iv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static void nglUniform2iv(int location, int count, long value) { + GL20C.nglUniform2iv(location, count, value); + } + + /** + * Specifies the value of a single ivec2 uniform variable or an ivec2 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform2iv(@NativeType("GLint") int location, @NativeType("GLint const *") IntBuffer value) { + GL20C.glUniform2iv(location, value); + } + + // --- [ glUniform3iv ] --- + + /** + * Unsafe version of: {@link #glUniform3iv Uniform3iv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static void nglUniform3iv(int location, int count, long value) { + GL20C.nglUniform3iv(location, count, value); + } + + /** + * Specifies the value of a single ivec3 uniform variable or an ivec3 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform3iv(@NativeType("GLint") int location, @NativeType("GLint const *") IntBuffer value) { + GL20C.glUniform3iv(location, value); + } + + // --- [ glUniform4iv ] --- + + /** + * Unsafe version of: {@link #glUniform4iv Uniform4iv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static void nglUniform4iv(int location, int count, long value) { + GL20C.nglUniform4iv(location, count, value); + } + + /** + * Specifies the value of a single ivec4 uniform variable or an ivec4 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform4iv(@NativeType("GLint") int location, @NativeType("GLint const *") IntBuffer value) { + GL20C.glUniform4iv(location, value); + } + + // --- [ glUniformMatrix2fv ] --- + + /** + * Unsafe version of: {@link #glUniformMatrix2fv UniformMatrix2fv} + * + * @param count the number of matrices that are to be modified. This should be 1 if the targeted uniform variable is not an array of matrices, and 1 or more if it is an array of matrices. + */ + public static void nglUniformMatrix2fv(int location, int count, boolean transpose, long value) { + GL20C.nglUniformMatrix2fv(location, count, transpose, value); + } + + /** + * Specifies the value of a single mat2 uniform variable or a mat2 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param transpose whether to transpose the matrix as the values are loaded into the uniform variable + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniformMatrix2fv(@NativeType("GLint") int location, @NativeType("GLboolean") boolean transpose, @NativeType("GLfloat const *") FloatBuffer value) { + GL20C.glUniformMatrix2fv(location, transpose, value); + } + + // --- [ glUniformMatrix3fv ] --- + + /** + * Unsafe version of: {@link #glUniformMatrix3fv UniformMatrix3fv} + * + * @param count the number of matrices that are to be modified. This should be 1 if the targeted uniform variable is not an array of matrices, and 1 or more if it is an array of matrices. + */ + public static void nglUniformMatrix3fv(int location, int count, boolean transpose, long value) { + GL20C.nglUniformMatrix3fv(location, count, transpose, value); + } + + /** + * Specifies the value of a single mat3 uniform variable or a mat3 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param transpose whether to transpose the matrix as the values are loaded into the uniform variable + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniformMatrix3fv(@NativeType("GLint") int location, @NativeType("GLboolean") boolean transpose, @NativeType("GLfloat const *") FloatBuffer value) { + GL20C.glUniformMatrix3fv(location, transpose, value); + } + + // --- [ glUniformMatrix4fv ] --- + + /** + * Unsafe version of: {@link #glUniformMatrix4fv UniformMatrix4fv} + * + * @param count the number of matrices that are to be modified. This should be 1 if the targeted uniform variable is not an array of matrices, and 1 or more if it is an array of matrices. + */ + public static void nglUniformMatrix4fv(int location, int count, boolean transpose, long value) { + GL20C.nglUniformMatrix4fv(location, count, transpose, value); + } + + /** + * Specifies the value of a single mat4 uniform variable or a mat4 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param transpose whether to transpose the matrix as the values are loaded into the uniform variable + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniformMatrix4fv(@NativeType("GLint") int location, @NativeType("GLboolean") boolean transpose, @NativeType("GLfloat const *") FloatBuffer value) { + GL20C.glUniformMatrix4fv(location, transpose, value); + } + + // --- [ glGetShaderiv ] --- + + /** Unsafe version of: {@link #glGetShaderiv GetShaderiv} */ + public static void nglGetShaderiv(int shader, int pname, long params) { + GL20C.nglGetShaderiv(shader, pname, params); + } + + /** + * Returns a parameter from a shader object. + * + * @param shader the shader object to be queried + * @param pname the object parameter. One of:| {@link GL20C#GL_SHADER_TYPE SHADER_TYPE} | {@link GL20C#GL_DELETE_STATUS DELETE_STATUS} | {@link GL20C#GL_COMPILE_STATUS COMPILE_STATUS} | {@link GL20C#GL_INFO_LOG_LENGTH INFO_LOG_LENGTH} | {@link GL20C#GL_SHADER_SOURCE_LENGTH SHADER_SOURCE_LENGTH} |
| {@link GL20C#GL_SHADER_TYPE SHADER_TYPE} | {@link GL20C#GL_DELETE_STATUS DELETE_STATUS} | {@link GL20C#GL_COMPILE_STATUS COMPILE_STATUS} | {@link GL20C#GL_INFO_LOG_LENGTH INFO_LOG_LENGTH} | {@link GL20C#GL_SHADER_SOURCE_LENGTH SHADER_SOURCE_LENGTH} |
| {@link GL20C#GL_DELETE_STATUS DELETE_STATUS} | {@link GL20C#GL_LINK_STATUS LINK_STATUS} | {@link GL20C#GL_VALIDATE_STATUS VALIDATE_STATUS} |
| {@link GL20C#GL_INFO_LOG_LENGTH INFO_LOG_LENGTH} | {@link GL20C#GL_ATTACHED_SHADERS ATTACHED_SHADERS} | {@link GL20C#GL_ACTIVE_ATTRIBUTES ACTIVE_ATTRIBUTES} |
| {@link GL20C#GL_ACTIVE_ATTRIBUTE_MAX_LENGTH ACTIVE_ATTRIBUTE_MAX_LENGTH} | {@link GL20C#GL_ACTIVE_UNIFORMS ACTIVE_UNIFORMS} | {@link GL20C#GL_ACTIVE_UNIFORM_MAX_LENGTH ACTIVE_UNIFORM_MAX_LENGTH} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_MODE TRANSFORM_FEEDBACK_BUFFER_MODE} | {@link GL30#GL_TRANSFORM_FEEDBACK_VARYINGS TRANSFORM_FEEDBACK_VARYINGS} | {@link GL30#GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH} |
| {@link GL31#GL_ACTIVE_UNIFORM_BLOCKS ACTIVE_UNIFORM_BLOCKS} | {@link GL31#GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH} | {@link GL32#GL_GEOMETRY_VERTICES_OUT GEOMETRY_VERTICES_OUT} |
| {@link GL32#GL_GEOMETRY_INPUT_TYPE GEOMETRY_INPUT_TYPE} | {@link GL32#GL_GEOMETRY_OUTPUT_TYPE GEOMETRY_OUTPUT_TYPE} | {@link GL41#GL_PROGRAM_BINARY_LENGTH PROGRAM_BINARY_LENGTH} |
| {@link GL42#GL_ACTIVE_ATOMIC_COUNTER_BUFFERS ACTIVE_ATOMIC_COUNTER_BUFFERS} | {@link GL43#GL_COMPUTE_WORK_GROUP_SIZE COMPUTE_WORK_GROUP_SIZE} |
| {@link GL20C#GL_DELETE_STATUS DELETE_STATUS} | {@link GL20C#GL_LINK_STATUS LINK_STATUS} | {@link GL20C#GL_VALIDATE_STATUS VALIDATE_STATUS} |
| {@link GL20C#GL_INFO_LOG_LENGTH INFO_LOG_LENGTH} | {@link GL20C#GL_ATTACHED_SHADERS ATTACHED_SHADERS} | {@link GL20C#GL_ACTIVE_ATTRIBUTES ACTIVE_ATTRIBUTES} |
| {@link GL20C#GL_ACTIVE_ATTRIBUTE_MAX_LENGTH ACTIVE_ATTRIBUTE_MAX_LENGTH} | {@link GL20C#GL_ACTIVE_UNIFORMS ACTIVE_UNIFORMS} | {@link GL20C#GL_ACTIVE_UNIFORM_MAX_LENGTH ACTIVE_UNIFORM_MAX_LENGTH} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_MODE TRANSFORM_FEEDBACK_BUFFER_MODE} | {@link GL30#GL_TRANSFORM_FEEDBACK_VARYINGS TRANSFORM_FEEDBACK_VARYINGS} | {@link GL30#GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH} |
| {@link GL31#GL_ACTIVE_UNIFORM_BLOCKS ACTIVE_UNIFORM_BLOCKS} | {@link GL31#GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH} | {@link GL32#GL_GEOMETRY_VERTICES_OUT GEOMETRY_VERTICES_OUT} |
| {@link GL32#GL_GEOMETRY_INPUT_TYPE GEOMETRY_INPUT_TYPE} | {@link GL32#GL_GEOMETRY_OUTPUT_TYPE GEOMETRY_OUTPUT_TYPE} | {@link GL41#GL_PROGRAM_BINARY_LENGTH PROGRAM_BINARY_LENGTH} |
| {@link GL42#GL_ACTIVE_ATOMIC_COUNTER_BUFFERS ACTIVE_ATOMIC_COUNTER_BUFFERS} | {@link GL43#GL_COMPUTE_WORK_GROUP_SIZE COMPUTE_WORK_GROUP_SIZE} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| {@link GL15#GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING VERTEX_ATTRIB_ARRAY_BUFFER_BINDING} | {@link GL20C#GL_VERTEX_ATTRIB_ARRAY_ENABLED VERTEX_ATTRIB_ARRAY_ENABLED} |
| {@link GL20C#GL_VERTEX_ATTRIB_ARRAY_SIZE VERTEX_ATTRIB_ARRAY_SIZE} | {@link GL20C#GL_VERTEX_ATTRIB_ARRAY_STRIDE VERTEX_ATTRIB_ARRAY_STRIDE} |
| {@link GL20C#GL_VERTEX_ATTRIB_ARRAY_TYPE VERTEX_ATTRIB_ARRAY_TYPE} | {@link GL20C#GL_VERTEX_ATTRIB_ARRAY_NORMALIZED VERTEX_ATTRIB_ARRAY_NORMALIZED} |
| {@link GL20C#GL_CURRENT_VERTEX_ATTRIB CURRENT_VERTEX_ATTRIB} | {@link GL30#GL_VERTEX_ATTRIB_ARRAY_INTEGER VERTEX_ATTRIB_ARRAY_INTEGER} |
| {@link GL33#GL_VERTEX_ATTRIB_ARRAY_DIVISOR VERTEX_ATTRIB_ARRAY_DIVISOR} |
| {@link GL15#GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING VERTEX_ATTRIB_ARRAY_BUFFER_BINDING} | {@link GL20C#GL_VERTEX_ATTRIB_ARRAY_ENABLED VERTEX_ATTRIB_ARRAY_ENABLED} |
| {@link GL20C#GL_VERTEX_ATTRIB_ARRAY_SIZE VERTEX_ATTRIB_ARRAY_SIZE} | {@link GL20C#GL_VERTEX_ATTRIB_ARRAY_STRIDE VERTEX_ATTRIB_ARRAY_STRIDE} |
| {@link GL20C#GL_VERTEX_ATTRIB_ARRAY_TYPE VERTEX_ATTRIB_ARRAY_TYPE} | {@link GL20C#GL_VERTEX_ATTRIB_ARRAY_NORMALIZED VERTEX_ATTRIB_ARRAY_NORMALIZED} |
| {@link GL20C#GL_CURRENT_VERTEX_ATTRIB CURRENT_VERTEX_ATTRIB} | {@link GL30#GL_VERTEX_ATTRIB_ARRAY_INTEGER VERTEX_ATTRIB_ARRAY_INTEGER} |
| {@link GL33#GL_VERTEX_ATTRIB_ARRAY_DIVISOR VERTEX_ATTRIB_ARRAY_DIVISOR} |
| {@link GL20C#GL_VERTEX_ATTRIB_ARRAY_POINTER VERTEX_ATTRIB_ARRAY_POINTER} |
| {@link GL20C#GL_VERTEX_ATTRIB_ARRAY_POINTER VERTEX_ATTRIB_ARRAY_POINTER} |
| {@link GL11#GL_NONE NONE} | {@link GL11#GL_FRONT_LEFT FRONT_LEFT} | {@link GL11#GL_FRONT_RIGHT FRONT_RIGHT} | {@link GL11#GL_BACK_LEFT BACK_LEFT} | {@link GL11#GL_BACK_RIGHT BACK_RIGHT} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} |
| GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link GL14#GL_FUNC_ADD FUNC_ADD} | {@link GL14#GL_FUNC_SUBTRACT FUNC_SUBTRACT} | {@link GL14#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} | {@link GL14#GL_MIN MIN} | {@link GL14#GL_MAX MAX} |
| {@link GL11#GL_FRONT FRONT} | {@link GL11#GL_BACK BACK} | {@link GL11#GL_FRONT_AND_BACK FRONT_AND_BACK} |
| {@link GL11#GL_KEEP KEEP} | {@link GL11#GL_ZERO ZERO} | {@link GL11#GL_REPLACE REPLACE} | {@link GL11#GL_INCR INCR} | {@link GL14#GL_INCR_WRAP INCR_WRAP} | {@link GL11#GL_DECR DECR} | {@link GL14#GL_DECR_WRAP DECR_WRAP} | {@link GL11#GL_INVERT INVERT} |
| {@link GL11#GL_FRONT FRONT} | {@link GL11#GL_BACK BACK} | {@link GL11#GL_FRONT_AND_BACK FRONT_AND_BACK} |
| {@link GL11#GL_NEVER NEVER} | {@link GL11#GL_LESS LESS} | {@link GL11#GL_LEQUAL LEQUAL} | {@link GL11#GL_GREATER GREATER} | {@link GL11#GL_GEQUAL GEQUAL} | {@link GL11#GL_EQUAL EQUAL} | {@link GL11#GL_NOTEQUAL NOTEQUAL} | {@link GL11#GL_ALWAYS ALWAYS} |
| {@link GL11#GL_FRONT FRONT} | {@link GL11#GL_BACK BACK} | {@link GL11#GL_FRONT_AND_BACK FRONT_AND_BACK} |
Extensions promoted to core in this release:
+ * + *| {@link #GL_VERTEX_SHADER VERTEX_SHADER} | {@link #GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
In order to create a complete shader program, there must be a way to specify the list of things that will be linked together. Program objects provide + * this mechanism. Shaders that are to be linked together in a program object must first be attached to that program object. glAttachShader attaches the + * shader object specified by shader to the program object specified by program. This indicates that shader will be included in link operations that will + * be performed on program.
+ * + *All operations that can be performed on a shader object are valid whether or not the shader object is attached to a program object. It is permissible to + * attach a shader object to a program object before source code has been loaded into the shader object or before the shader object has been compiled. It + * is permissible to attach multiple shader objects of the same type because each may contain a portion of the complete shader. It is also permissible to + * attach a shader object to more than one program object. If a shader object is deleted while it is attached to a program object, it will be flagged for + * deletion, and deletion will not occur until glDetachShader is called to detach it from all program objects to which it is attached.
+ * + * @param program the program object to which a shader object will be attached + * @param shader the shader object that is to be attached + * + * @see Reference Page + */ + public static native void glAttachShader(@NativeType("GLuint") int program, @NativeType("GLuint") int shader); + + // --- [ glDetachShader ] --- + + /** + * Detaches a shader object from a program object to which it is attached. + * + * @param program the program object from which to detach the shader object + * @param shader the shader object to be detached + * + * @see Reference Page + */ + public static native void glDetachShader(@NativeType("GLuint") int program, @NativeType("GLuint") int shader); + + // --- [ glShaderSource ] --- + + /** + * Unsafe version of: {@link #glShaderSource ShaderSource} + * + * @param count the number of elements in the string and length arrays + */ + public static native void nglShaderSource(int shader, int count, long strings, long length); + + /** + * Sets the source code in {@code shader} to the source code in the array of strings specified by {@code strings}. Any source code previously stored in the + * shader object is completely replaced. The number of strings in the array is specified by {@code count}. If {@code length} is {@code NULL}, each string is + * assumed to be null terminated. If {@code length} is a value other than {@code NULL}, it points to an array containing a string length for each of the + * corresponding elements of {@code strings}. Each element in the length array may contain the length of the corresponding string (the null character is not + * counted as part of the string length) or a value less than 0 to indicate that the string is null terminated. The source code strings are not scanned or + * parsed at this time; they are simply copied into the specified shader object. + * + * @param shader the shader object whose source code is to be replaced + * @param strings an array of pointers to strings containing the source code to be loaded into the shader + * @param length an array of string lengths + * + * @see Reference Page + */ + public static void glShaderSource(@NativeType("GLuint") int shader, @NativeType("GLchar const **") PointerBuffer strings, @Nullable @NativeType("GLint const *") IntBuffer length) { + if (CHECKS) { + checkSafe(length, strings.remaining()); + } + nglShaderSource(shader, strings.remaining(), memAddress(strings), memAddressSafe(length)); + } + + /** + * Sets the source code in {@code shader} to the source code in the array of strings specified by {@code strings}. Any source code previously stored in the + * shader object is completely replaced. The number of strings in the array is specified by {@code count}. If {@code length} is {@code NULL}, each string is + * assumed to be null terminated. If {@code length} is a value other than {@code NULL}, it points to an array containing a string length for each of the + * corresponding elements of {@code strings}. Each element in the length array may contain the length of the corresponding string (the null character is not + * counted as part of the string length) or a value less than 0 to indicate that the string is null terminated. The source code strings are not scanned or + * parsed at this time; they are simply copied into the specified shader object. + * + * @param shader the shader object whose source code is to be replaced + * @param strings an array of pointers to strings containing the source code to be loaded into the shader + * + * @see Reference Page + */ + public static void glShaderSource(@NativeType("GLuint") int shader, @NativeType("GLchar const **") CharSequence... strings) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + long stringsAddress = org.lwjgl.system.APIUtil.apiArrayi(stack, MemoryUtil::memUTF8, strings); + nglShaderSource(shader, strings.length, stringsAddress, stringsAddress - (strings.length << 2)); + org.lwjgl.system.APIUtil.apiArrayFree(stringsAddress, strings.length); + } finally { + stack.setPointer(stackPointer); + } + } + + /** + * Sets the source code in {@code shader} to the source code in the array of strings specified by {@code strings}. Any source code previously stored in the + * shader object is completely replaced. The number of strings in the array is specified by {@code count}. If {@code length} is {@code NULL}, each string is + * assumed to be null terminated. If {@code length} is a value other than {@code NULL}, it points to an array containing a string length for each of the + * corresponding elements of {@code strings}. Each element in the length array may contain the length of the corresponding string (the null character is not + * counted as part of the string length) or a value less than 0 to indicate that the string is null terminated. The source code strings are not scanned or + * parsed at this time; they are simply copied into the specified shader object. + * + * @param shader the shader object whose source code is to be replaced + * + * @see Reference Page + */ + public static void glShaderSource(@NativeType("GLuint") int shader, @NativeType("GLchar const **") CharSequence string) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + long stringsAddress = org.lwjgl.system.APIUtil.apiArrayi(stack, MemoryUtil::memUTF8, string); + nglShaderSource(shader, 1, stringsAddress, stringsAddress - 4); + org.lwjgl.system.APIUtil.apiArrayFree(stringsAddress, 1); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glCompileShader ] --- + + /** + * Compiles a shader object. + * + * @param shader the shader object to be compiled + * + * @see Reference Page + */ + public static native void glCompileShader(@NativeType("GLuint") int shader); + + // --- [ glLinkProgram ] --- + + /** + * Links a program object. + * + * @param program the program object to be linked + * + * @see Reference Page + */ + public static native void glLinkProgram(@NativeType("GLuint") int program); + + // --- [ glUseProgram ] --- + + /** + * Installs a program object as part of current rendering state. + * + * @param program the program object whose executables are to be used as part of current rendering state + * + * @see Reference Page + */ + public static native void glUseProgram(@NativeType("GLuint") int program); + + // --- [ glValidateProgram ] --- + + /** + * Validates a program object. + * + * @param program the program object to be validated + * + * @see Reference Page + */ + public static native void glValidateProgram(@NativeType("GLuint") int program); + + // --- [ glUniform1f ] --- + + /** + * Specifies the value of a float uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform value + * + * @see Reference Page + */ + public static native void glUniform1f(@NativeType("GLint") int location, @NativeType("GLfloat") float v0); + + // --- [ glUniform2f ] --- + + /** + * Specifies the value of a vec2 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform x value + * @param v1 the uniform y value + * + * @see Reference Page + */ + public static native void glUniform2f(@NativeType("GLint") int location, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1); + + // --- [ glUniform3f ] --- + + /** + * Specifies the value of a vec3 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform x value + * @param v1 the uniform y value + * @param v2 the uniform z value + * + * @see Reference Page + */ + public static native void glUniform3f(@NativeType("GLint") int location, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1, @NativeType("GLfloat") float v2); + + // --- [ glUniform4f ] --- + + /** + * Specifies the value of a vec4 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform x value + * @param v1 the uniform y value + * @param v2 the uniform z value + * @param v3 the uniform w value + * + * @see Reference Page + */ + public static native void glUniform4f(@NativeType("GLint") int location, @NativeType("GLfloat") float v0, @NativeType("GLfloat") float v1, @NativeType("GLfloat") float v2, @NativeType("GLfloat") float v3); + + // --- [ glUniform1i ] --- + + /** + * Specifies the value of an int uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform value + * + * @see Reference Page + */ + public static native void glUniform1i(@NativeType("GLint") int location, @NativeType("GLint") int v0); + + // --- [ glUniform2i ] --- + + /** + * Specifies the value of an ivec2 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform x value + * @param v1 the uniform y value + * + * @see Reference Page + */ + public static native void glUniform2i(@NativeType("GLint") int location, @NativeType("GLint") int v0, @NativeType("GLint") int v1); + + // --- [ glUniform3i ] --- + + /** + * Specifies the value of an ivec3 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform x value + * @param v1 the uniform y value + * @param v2 the uniform z value + * + * @see Reference Page + */ + public static native void glUniform3i(@NativeType("GLint") int location, @NativeType("GLint") int v0, @NativeType("GLint") int v1, @NativeType("GLint") int v2); + + // --- [ glUniform4i ] --- + + /** + * Specifies the value of an ivec4 uniform variable for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param v0 the uniform x value + * @param v1 the uniform y value + * @param v2 the uniform z value + * @param v3 the uniform w value + * + * @see Reference Page + */ + public static native void glUniform4i(@NativeType("GLint") int location, @NativeType("GLint") int v0, @NativeType("GLint") int v1, @NativeType("GLint") int v2, @NativeType("GLint") int v3); + + // --- [ glUniform1fv ] --- + + /** + * Unsafe version of: {@link #glUniform1fv Uniform1fv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform1fv(int location, int count, long value); + + /** + * Specifies the value of a single float uniform variable or a float uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform1fv(@NativeType("GLint") int location, @NativeType("GLfloat const *") FloatBuffer value) { + nglUniform1fv(location, value.remaining(), memAddress(value)); + } + + // --- [ glUniform2fv ] --- + + /** + * Unsafe version of: {@link #glUniform2fv Uniform2fv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform2fv(int location, int count, long value); + + /** + * Specifies the value of a single vec2 uniform variable or a vec2 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform2fv(@NativeType("GLint") int location, @NativeType("GLfloat const *") FloatBuffer value) { + nglUniform2fv(location, value.remaining() >> 1, memAddress(value)); + } + + // --- [ glUniform3fv ] --- + + /** + * Unsafe version of: {@link #glUniform3fv Uniform3fv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform3fv(int location, int count, long value); + + /** + * Specifies the value of a single vec3 uniform variable or a vec3 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform3fv(@NativeType("GLint") int location, @NativeType("GLfloat const *") FloatBuffer value) { + nglUniform3fv(location, value.remaining() / 3, memAddress(value)); + } + + // --- [ glUniform4fv ] --- + + /** + * Unsafe version of: {@link #glUniform4fv Uniform4fv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform4fv(int location, int count, long value); + + /** + * Specifies the value of a single vec4 uniform variable or a vec4 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform4fv(@NativeType("GLint") int location, @NativeType("GLfloat const *") FloatBuffer value) { + nglUniform4fv(location, value.remaining() >> 2, memAddress(value)); + } + + // --- [ glUniform1iv ] --- + + /** + * Unsafe version of: {@link #glUniform1iv Uniform1iv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform1iv(int location, int count, long value); + + /** + * Specifies the value of a single int uniform variable or a int uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform1iv(@NativeType("GLint") int location, @NativeType("GLint const *") IntBuffer value) { + nglUniform1iv(location, value.remaining(), memAddress(value)); + } + + // --- [ glUniform2iv ] --- + + /** + * Unsafe version of: {@link #glUniform2iv Uniform2iv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform2iv(int location, int count, long value); + + /** + * Specifies the value of a single ivec2 uniform variable or an ivec2 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform2iv(@NativeType("GLint") int location, @NativeType("GLint const *") IntBuffer value) { + nglUniform2iv(location, value.remaining() >> 1, memAddress(value)); + } + + // --- [ glUniform3iv ] --- + + /** + * Unsafe version of: {@link #glUniform3iv Uniform3iv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform3iv(int location, int count, long value); + + /** + * Specifies the value of a single ivec3 uniform variable or an ivec3 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform3iv(@NativeType("GLint") int location, @NativeType("GLint const *") IntBuffer value) { + nglUniform3iv(location, value.remaining() / 3, memAddress(value)); + } + + // --- [ glUniform4iv ] --- + + /** + * Unsafe version of: {@link #glUniform4iv Uniform4iv} + * + * @param count the number of elements that are to be modified. This should be 1 if the targeted uniform variable is not an array, and 1 or more if it is an array. + */ + public static native void nglUniform4iv(int location, int count, long value); + + /** + * Specifies the value of a single ivec4 uniform variable or an ivec4 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniform4iv(@NativeType("GLint") int location, @NativeType("GLint const *") IntBuffer value) { + nglUniform4iv(location, value.remaining() >> 2, memAddress(value)); + } + + // --- [ glUniformMatrix2fv ] --- + + /** + * Unsafe version of: {@link #glUniformMatrix2fv UniformMatrix2fv} + * + * @param count the number of matrices that are to be modified. This should be 1 if the targeted uniform variable is not an array of matrices, and 1 or more if it is an array of matrices. + */ + public static native void nglUniformMatrix2fv(int location, int count, boolean transpose, long value); + + /** + * Specifies the value of a single mat2 uniform variable or a mat2 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param transpose whether to transpose the matrix as the values are loaded into the uniform variable + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniformMatrix2fv(@NativeType("GLint") int location, @NativeType("GLboolean") boolean transpose, @NativeType("GLfloat const *") FloatBuffer value) { + nglUniformMatrix2fv(location, value.remaining() >> 2, transpose, memAddress(value)); + } + + // --- [ glUniformMatrix3fv ] --- + + /** + * Unsafe version of: {@link #glUniformMatrix3fv UniformMatrix3fv} + * + * @param count the number of matrices that are to be modified. This should be 1 if the targeted uniform variable is not an array of matrices, and 1 or more if it is an array of matrices. + */ + public static native void nglUniformMatrix3fv(int location, int count, boolean transpose, long value); + + /** + * Specifies the value of a single mat3 uniform variable or a mat3 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param transpose whether to transpose the matrix as the values are loaded into the uniform variable + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniformMatrix3fv(@NativeType("GLint") int location, @NativeType("GLboolean") boolean transpose, @NativeType("GLfloat const *") FloatBuffer value) { + nglUniformMatrix3fv(location, value.remaining() / 9, transpose, memAddress(value)); + } + + // --- [ glUniformMatrix4fv ] --- + + /** + * Unsafe version of: {@link #glUniformMatrix4fv UniformMatrix4fv} + * + * @param count the number of matrices that are to be modified. This should be 1 if the targeted uniform variable is not an array of matrices, and 1 or more if it is an array of matrices. + */ + public static native void nglUniformMatrix4fv(int location, int count, boolean transpose, long value); + + /** + * Specifies the value of a single mat4 uniform variable or a mat4 uniform variable array for the current program object. + * + * @param location the location of the uniform variable to be modified + * @param transpose whether to transpose the matrix as the values are loaded into the uniform variable + * @param value a pointer to an array of {@code count} values that will be used to update the specified uniform variable + * + * @see Reference Page + */ + public static void glUniformMatrix4fv(@NativeType("GLint") int location, @NativeType("GLboolean") boolean transpose, @NativeType("GLfloat const *") FloatBuffer value) { + nglUniformMatrix4fv(location, value.remaining() >> 4, transpose, memAddress(value)); + } + + // --- [ glGetShaderiv ] --- + + /** Unsafe version of: {@link #glGetShaderiv GetShaderiv} */ + public static native void nglGetShaderiv(int shader, int pname, long params); + + /** + * Returns a parameter from a shader object. + * + * @param shader the shader object to be queried + * @param pname the object parameter. One of:| {@link #GL_SHADER_TYPE SHADER_TYPE} | {@link #GL_DELETE_STATUS DELETE_STATUS} | {@link #GL_COMPILE_STATUS COMPILE_STATUS} | {@link #GL_INFO_LOG_LENGTH INFO_LOG_LENGTH} | {@link #GL_SHADER_SOURCE_LENGTH SHADER_SOURCE_LENGTH} |
| {@link #GL_SHADER_TYPE SHADER_TYPE} | {@link #GL_DELETE_STATUS DELETE_STATUS} | {@link #GL_COMPILE_STATUS COMPILE_STATUS} | {@link #GL_INFO_LOG_LENGTH INFO_LOG_LENGTH} | {@link #GL_SHADER_SOURCE_LENGTH SHADER_SOURCE_LENGTH} |
| {@link #GL_DELETE_STATUS DELETE_STATUS} | {@link #GL_LINK_STATUS LINK_STATUS} | {@link #GL_VALIDATE_STATUS VALIDATE_STATUS} |
| {@link #GL_INFO_LOG_LENGTH INFO_LOG_LENGTH} | {@link #GL_ATTACHED_SHADERS ATTACHED_SHADERS} | {@link #GL_ACTIVE_ATTRIBUTES ACTIVE_ATTRIBUTES} |
| {@link #GL_ACTIVE_ATTRIBUTE_MAX_LENGTH ACTIVE_ATTRIBUTE_MAX_LENGTH} | {@link #GL_ACTIVE_UNIFORMS ACTIVE_UNIFORMS} | {@link #GL_ACTIVE_UNIFORM_MAX_LENGTH ACTIVE_UNIFORM_MAX_LENGTH} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_MODE TRANSFORM_FEEDBACK_BUFFER_MODE} | {@link GL30#GL_TRANSFORM_FEEDBACK_VARYINGS TRANSFORM_FEEDBACK_VARYINGS} | {@link GL30#GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH} |
| {@link GL31#GL_ACTIVE_UNIFORM_BLOCKS ACTIVE_UNIFORM_BLOCKS} | {@link GL31#GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH} | {@link GL32#GL_GEOMETRY_VERTICES_OUT GEOMETRY_VERTICES_OUT} |
| {@link GL32#GL_GEOMETRY_INPUT_TYPE GEOMETRY_INPUT_TYPE} | {@link GL32#GL_GEOMETRY_OUTPUT_TYPE GEOMETRY_OUTPUT_TYPE} | {@link GL41#GL_PROGRAM_BINARY_LENGTH PROGRAM_BINARY_LENGTH} |
| {@link GL42#GL_ACTIVE_ATOMIC_COUNTER_BUFFERS ACTIVE_ATOMIC_COUNTER_BUFFERS} | {@link GL43#GL_COMPUTE_WORK_GROUP_SIZE COMPUTE_WORK_GROUP_SIZE} |
| {@link #GL_DELETE_STATUS DELETE_STATUS} | {@link #GL_LINK_STATUS LINK_STATUS} | {@link #GL_VALIDATE_STATUS VALIDATE_STATUS} |
| {@link #GL_INFO_LOG_LENGTH INFO_LOG_LENGTH} | {@link #GL_ATTACHED_SHADERS ATTACHED_SHADERS} | {@link #GL_ACTIVE_ATTRIBUTES ACTIVE_ATTRIBUTES} |
| {@link #GL_ACTIVE_ATTRIBUTE_MAX_LENGTH ACTIVE_ATTRIBUTE_MAX_LENGTH} | {@link #GL_ACTIVE_UNIFORMS ACTIVE_UNIFORMS} | {@link #GL_ACTIVE_UNIFORM_MAX_LENGTH ACTIVE_UNIFORM_MAX_LENGTH} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_MODE TRANSFORM_FEEDBACK_BUFFER_MODE} | {@link GL30#GL_TRANSFORM_FEEDBACK_VARYINGS TRANSFORM_FEEDBACK_VARYINGS} | {@link GL30#GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH} |
| {@link GL31#GL_ACTIVE_UNIFORM_BLOCKS ACTIVE_UNIFORM_BLOCKS} | {@link GL31#GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH} | {@link GL32#GL_GEOMETRY_VERTICES_OUT GEOMETRY_VERTICES_OUT} |
| {@link GL32#GL_GEOMETRY_INPUT_TYPE GEOMETRY_INPUT_TYPE} | {@link GL32#GL_GEOMETRY_OUTPUT_TYPE GEOMETRY_OUTPUT_TYPE} | {@link GL41#GL_PROGRAM_BINARY_LENGTH PROGRAM_BINARY_LENGTH} |
| {@link GL42#GL_ACTIVE_ATOMIC_COUNTER_BUFFERS ACTIVE_ATOMIC_COUNTER_BUFFERS} | {@link GL43#GL_COMPUTE_WORK_GROUP_SIZE COMPUTE_WORK_GROUP_SIZE} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_DOUBLE DOUBLE} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} | {@link GL33#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL41#GL_FIXED FIXED} |
| {@link GL15#GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING VERTEX_ATTRIB_ARRAY_BUFFER_BINDING} | {@link #GL_VERTEX_ATTRIB_ARRAY_ENABLED VERTEX_ATTRIB_ARRAY_ENABLED} |
| {@link #GL_VERTEX_ATTRIB_ARRAY_SIZE VERTEX_ATTRIB_ARRAY_SIZE} | {@link #GL_VERTEX_ATTRIB_ARRAY_STRIDE VERTEX_ATTRIB_ARRAY_STRIDE} |
| {@link #GL_VERTEX_ATTRIB_ARRAY_TYPE VERTEX_ATTRIB_ARRAY_TYPE} | {@link #GL_VERTEX_ATTRIB_ARRAY_NORMALIZED VERTEX_ATTRIB_ARRAY_NORMALIZED} |
| {@link #GL_CURRENT_VERTEX_ATTRIB CURRENT_VERTEX_ATTRIB} | {@link GL30#GL_VERTEX_ATTRIB_ARRAY_INTEGER VERTEX_ATTRIB_ARRAY_INTEGER} |
| {@link GL33#GL_VERTEX_ATTRIB_ARRAY_DIVISOR VERTEX_ATTRIB_ARRAY_DIVISOR} |
| {@link GL15#GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING VERTEX_ATTRIB_ARRAY_BUFFER_BINDING} | {@link #GL_VERTEX_ATTRIB_ARRAY_ENABLED VERTEX_ATTRIB_ARRAY_ENABLED} |
| {@link #GL_VERTEX_ATTRIB_ARRAY_SIZE VERTEX_ATTRIB_ARRAY_SIZE} | {@link #GL_VERTEX_ATTRIB_ARRAY_STRIDE VERTEX_ATTRIB_ARRAY_STRIDE} |
| {@link #GL_VERTEX_ATTRIB_ARRAY_TYPE VERTEX_ATTRIB_ARRAY_TYPE} | {@link #GL_VERTEX_ATTRIB_ARRAY_NORMALIZED VERTEX_ATTRIB_ARRAY_NORMALIZED} |
| {@link #GL_CURRENT_VERTEX_ATTRIB CURRENT_VERTEX_ATTRIB} | {@link GL30#GL_VERTEX_ATTRIB_ARRAY_INTEGER VERTEX_ATTRIB_ARRAY_INTEGER} |
| {@link GL33#GL_VERTEX_ATTRIB_ARRAY_DIVISOR VERTEX_ATTRIB_ARRAY_DIVISOR} |
| {@link #GL_VERTEX_ATTRIB_ARRAY_POINTER VERTEX_ATTRIB_ARRAY_POINTER} |
| {@link #GL_VERTEX_ATTRIB_ARRAY_POINTER VERTEX_ATTRIB_ARRAY_POINTER} |
| {@link GL11#GL_NONE NONE} | {@link GL11#GL_FRONT_LEFT FRONT_LEFT} | {@link GL11#GL_FRONT_RIGHT FRONT_RIGHT} | {@link GL11#GL_BACK_LEFT BACK_LEFT} | {@link GL11#GL_BACK_RIGHT BACK_RIGHT} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} |
| GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link GL14#GL_FUNC_ADD FUNC_ADD} | {@link GL14#GL_FUNC_SUBTRACT FUNC_SUBTRACT} | {@link GL14#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} | {@link GL14#GL_MIN MIN} | {@link GL14#GL_MAX MAX} |
| {@link GL11#GL_FRONT FRONT} | {@link GL11#GL_BACK BACK} | {@link GL11#GL_FRONT_AND_BACK FRONT_AND_BACK} |
| {@link GL11#GL_KEEP KEEP} | {@link GL11#GL_ZERO ZERO} | {@link GL11#GL_REPLACE REPLACE} | {@link GL11#GL_INCR INCR} | {@link GL14#GL_INCR_WRAP INCR_WRAP} | {@link GL11#GL_DECR DECR} | {@link GL14#GL_DECR_WRAP DECR_WRAP} | {@link GL11#GL_INVERT INVERT} |
| {@link GL11#GL_FRONT FRONT} | {@link GL11#GL_BACK BACK} | {@link GL11#GL_FRONT_AND_BACK FRONT_AND_BACK} |
| {@link GL11#GL_NEVER NEVER} | {@link GL11#GL_LESS LESS} | {@link GL11#GL_LEQUAL LEQUAL} | {@link GL11#GL_GREATER GREATER} | {@link GL11#GL_GEQUAL GEQUAL} | {@link GL11#GL_EQUAL EQUAL} | {@link GL11#GL_NOTEQUAL NOTEQUAL} | {@link GL11#GL_ALWAYS ALWAYS} |
| {@link GL11#GL_FRONT FRONT} | {@link GL11#GL_BACK BACK} | {@link GL11#GL_FRONT_AND_BACK FRONT_AND_BACK} |
OpenGL 2.1 implementations must support at least revision 1.20 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *OpenGL 2.1 implementations must support at least revision 1.20 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *OpenGL 3.0 implementations are guaranteed to support at least versions 1.10, 1.20 and 1.30 of the shading language, although versions 1.10 and 1.20 are + * deprecated in a forward-compatible context.
+ * + *Extensions promoted to core in this release:
+ * + *Accepted by the {@code type} argument of VertexPointer, NormalPointer, ColorPointer, SecondaryColorPointer, FogCoordPointer, TexCoordPointer, and + * VertexAttribPointer.
+ */ + public static final int GL_HALF_FLOAT = 0x140B; + + /** Accepted by the {@code internalFormat} parameter of TexImage1D, TexImage2D, and TexImage3D. */ + public static final int + GL_RGBA32UI = 0x8D70, + GL_RGB32UI = 0x8D71, + GL_RGBA16UI = 0x8D76, + GL_RGB16UI = 0x8D77, + GL_RGBA8UI = 0x8D7C, + GL_RGB8UI = 0x8D7D, + GL_RGBA32I = 0x8D82, + GL_RGB32I = 0x8D83, + GL_RGBA16I = 0x8D88, + GL_RGB16I = 0x8D89, + GL_RGBA8I = 0x8D8E, + GL_RGB8I = 0x8D8F; + + /** Accepted by the {@code format} parameter of TexImage1D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, DrawPixels and ReadPixels. */ + public static final int + GL_RED_INTEGER = 0x8D94, + GL_GREEN_INTEGER = 0x8D95, + GL_BLUE_INTEGER = 0x8D96, + GL_ALPHA_INTEGER = 0x8D97, + GL_RGB_INTEGER = 0x8D98, + GL_RGBA_INTEGER = 0x8D99, + GL_BGR_INTEGER = 0x8D9A, + GL_BGRA_INTEGER = 0x8D9B; + + /** Accepted by the {@code target} parameter of TexParameteri, TexParameteriv, TexParameterf, TexParameterfv, GenerateMipmap, and BindTexture. */ + public static final int + GL_TEXTURE_1D_ARRAY = 0x8C18, + GL_TEXTURE_2D_ARRAY = 0x8C1A; + + /** Accepted by the {@code target} parameter of TexImage3D, TexSubImage3D, CopyTexSubImage3D, CompressedTexImage3D, and CompressedTexSubImage3D. */ + public static final int GL_PROXY_TEXTURE_2D_ARRAY = 0x8C1B; + + /** + * Accepted by the {@code target} parameter of TexImage2D, TexSubImage2D, CopyTexImage2D, CopyTexSubImage2D, CompressedTexImage2D, and + * CompressedTexSubImage2D. + */ + public static final int GL_PROXY_TEXTURE_1D_ARRAY = 0x8C19; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv and GetFloatv. */ + public static final int + GL_TEXTURE_BINDING_1D_ARRAY = 0x8C1C, + GL_TEXTURE_BINDING_2D_ARRAY = 0x8C1D, + GL_MAX_ARRAY_TEXTURE_LAYERS = 0x88FF; + + /** + * Accepted by the {@code internalformat} parameter of TexImage2D, CopyTexImage2D, and CompressedTexImage2D and the {@code format} parameter of + * CompressedTexSubImage2D. + */ + public static final int + GL_COMPRESSED_RED_RGTC1 = 0x8DBB, + GL_COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC, + GL_COMPRESSED_RG_RGTC2 = 0x8DBD, + GL_COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE; + + /** Accepted by the {@code internalFormat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, and CopyTexImage2D. */ + public static final int + GL_R8 = 0x8229, + GL_R16 = 0x822A, + GL_RG8 = 0x822B, + GL_RG16 = 0x822C, + GL_R16F = 0x822D, + GL_R32F = 0x822E, + GL_RG16F = 0x822F, + GL_RG32F = 0x8230, + GL_R8I = 0x8231, + GL_R8UI = 0x8232, + GL_R16I = 0x8233, + GL_R16UI = 0x8234, + GL_R32I = 0x8235, + GL_R32UI = 0x8236, + GL_RG8I = 0x8237, + GL_RG8UI = 0x8238, + GL_RG16I = 0x8239, + GL_RG16UI = 0x823A, + GL_RG32I = 0x823B, + GL_RG32UI = 0x823C, + GL_RG = 0x8227, + GL_COMPRESSED_RED = 0x8225, + GL_COMPRESSED_RG = 0x8226; + + /** Accepted by the {@code format} parameter of TexImage3D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, and ReadPixels. */ + public static final int GL_RG_INTEGER = 0x8228; + + /** + * Accepted by the {@code target} parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, GetBufferPointerv, + * BindBufferRange, BindBufferOffset and BindBufferBase. + */ + public static final int GL_TRANSFORM_FEEDBACK_BUFFER = 0x8C8E; + + /** Accepted by the {@code param} parameter of GetIntegeri_v and GetBooleani_v. */ + public static final int + GL_TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84, + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85; + + /** + * Accepted by the {@code param} parameter of GetIntegeri_v and GetBooleani_v, and by the {@code pname} parameter of GetBooleanv, + * GetDoublev, GetIntegerv, and GetFloatv. + */ + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F; + + /** Accepted by the {@code bufferMode} parameter of TransformFeedbackVaryings. */ + public static final int + GL_INTERLEAVED_ATTRIBS = 0x8C8C, + GL_SEPARATE_ATTRIBS = 0x8C8D; + + /** Accepted by the {@code target} parameter of BeginQuery, EndQuery, and GetQueryiv. */ + public static final int + GL_PRIMITIVES_GENERATED = 0x8C87, + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_RASTERIZER_DISCARD = 0x8C89; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A, + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B, + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80; + + /** Accepted by the {@code pname} parameter of GetProgramiv. */ + public static final int + GL_TRANSFORM_FEEDBACK_VARYINGS = 0x8C83, + GL_TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F, + GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_VERTEX_ARRAY_BINDING = 0x85B5; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_FRAMEBUFFER_SRGB = 0x8DB9; + + static { GL.initialize(); } + + protected GL30() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetStringi, caps.glClearBufferiv, caps.glClearBufferuiv, caps.glClearBufferfv, caps.glClearBufferfi, caps.glVertexAttribI1i, + caps.glVertexAttribI2i, caps.glVertexAttribI3i, caps.glVertexAttribI4i, caps.glVertexAttribI1ui, caps.glVertexAttribI2ui, caps.glVertexAttribI3ui, + caps.glVertexAttribI4ui, caps.glVertexAttribI1iv, caps.glVertexAttribI2iv, caps.glVertexAttribI3iv, caps.glVertexAttribI4iv, + caps.glVertexAttribI1uiv, caps.glVertexAttribI2uiv, caps.glVertexAttribI3uiv, caps.glVertexAttribI4uiv, caps.glVertexAttribI4bv, + caps.glVertexAttribI4sv, caps.glVertexAttribI4ubv, caps.glVertexAttribI4usv, caps.glVertexAttribIPointer, caps.glGetVertexAttribIiv, + caps.glGetVertexAttribIuiv, caps.glUniform1ui, caps.glUniform2ui, caps.glUniform3ui, caps.glUniform4ui, caps.glUniform1uiv, caps.glUniform2uiv, + caps.glUniform3uiv, caps.glUniform4uiv, caps.glGetUniformuiv, caps.glBindFragDataLocation, caps.glGetFragDataLocation, + caps.glBeginConditionalRender, caps.glEndConditionalRender, caps.glMapBufferRange, caps.glFlushMappedBufferRange, caps.glClampColor, + caps.glIsRenderbuffer, caps.glBindRenderbuffer, caps.glDeleteRenderbuffers, caps.glGenRenderbuffers, caps.glRenderbufferStorage, + caps.glRenderbufferStorageMultisample, caps.glGetRenderbufferParameteriv, caps.glIsFramebuffer, caps.glBindFramebuffer, caps.glDeleteFramebuffers, + caps.glGenFramebuffers, caps.glCheckFramebufferStatus, caps.glFramebufferTexture1D, caps.glFramebufferTexture2D, caps.glFramebufferTexture3D, + caps.glFramebufferTextureLayer, caps.glFramebufferRenderbuffer, caps.glGetFramebufferAttachmentParameteriv, caps.glBlitFramebuffer, + caps.glGenerateMipmap, caps.glTexParameterIiv, caps.glTexParameterIuiv, caps.glGetTexParameterIiv, caps.glGetTexParameterIuiv, caps.glColorMaski, + caps.glGetBooleani_v, caps.glGetIntegeri_v, caps.glEnablei, caps.glDisablei, caps.glIsEnabledi, caps.glBindBufferRange, caps.glBindBufferBase, + caps.glBeginTransformFeedback, caps.glEndTransformFeedback, caps.glTransformFeedbackVaryings, caps.glGetTransformFeedbackVarying, + caps.glBindVertexArray, caps.glDeleteVertexArrays, caps.glGenVertexArrays, caps.glIsVertexArray + ); + } + + // --- [ glGetStringi ] --- + + /** Unsafe version of: {@link #glGetStringi GetStringi} */ + public static long nglGetStringi(int name, int index) { + return GL30C.nglGetStringi(name, index); + } + + /** + * Queries indexed string state. + * + * @param name the indexed state to query. One of:| {@link GL11#GL_EXTENSIONS EXTENSIONS} | {@link GL20#GL_SHADING_LANGUAGE_VERSION SHADING_LANGUAGE_VERSION} |
| {@link GL11#GL_COLOR COLOR} | {@link GL11#GL_STENCIL STENCIL} |
| {@link GL11#GL_COLOR COLOR} |
| {@link GL11#GL_COLOR COLOR} | {@link GL11#GL_DEPTH DEPTH} |
| {@link GL30C#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL20#GL_CURRENT_VERTEX_ATTRIB CURRENT_VERTEX_ATTRIB} |
| {@link GL20#GL_CURRENT_VERTEX_ATTRIB CURRENT_VERTEX_ATTRIB} |
| {@link GL20#GL_CURRENT_VERTEX_ATTRIB CURRENT_VERTEX_ATTRIB} |
| {@link GL20#GL_CURRENT_VERTEX_ATTRIB CURRENT_VERTEX_ATTRIB} |
| {@link GL30C#GL_QUERY_WAIT QUERY_WAIT} | {@link GL30C#GL_QUERY_NO_WAIT QUERY_NO_WAIT} | {@link GL30C#GL_QUERY_BY_REGION_WAIT QUERY_BY_REGION_WAIT} |
| {@link GL30C#GL_QUERY_BY_REGION_NO_WAIT QUERY_BY_REGION_NO_WAIT} | {@link GL45#GL_QUERY_WAIT_INVERTED QUERY_WAIT_INVERTED} | {@link GL45#GL_QUERY_NO_WAIT_INVERTED QUERY_NO_WAIT_INVERTED} |
| {@link GL45#GL_QUERY_BY_REGION_WAIT_INVERTED QUERY_BY_REGION_WAIT_INVERTED} | {@link GL45#GL_QUERY_BY_REGION_NO_WAIT_INVERTED QUERY_BY_REGION_NO_WAIT_INVERTED} |
LWJGL note: This method comes in 2 flavors:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30C#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL30C#GL_MAP_READ_BIT MAP_READ_BIT} | {@link GL30C#GL_MAP_WRITE_BIT MAP_WRITE_BIT} | {@link GL30C#GL_MAP_INVALIDATE_RANGE_BIT MAP_INVALIDATE_RANGE_BIT} | {@link GL30C#GL_MAP_INVALIDATE_BUFFER_BIT MAP_INVALIDATE_BUFFER_BIT} |
| {@link GL30C#GL_MAP_FLUSH_EXPLICIT_BIT MAP_FLUSH_EXPLICIT_BIT} | {@link GL30C#GL_MAP_UNSYNCHRONIZED_BIT MAP_UNSYNCHRONIZED_BIT} |
LWJGL note: This method comes in 2 flavors:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30C#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL30C#GL_MAP_READ_BIT MAP_READ_BIT} | {@link GL30C#GL_MAP_WRITE_BIT MAP_WRITE_BIT} | {@link GL30C#GL_MAP_INVALIDATE_RANGE_BIT MAP_INVALIDATE_RANGE_BIT} | {@link GL30C#GL_MAP_INVALIDATE_BUFFER_BIT MAP_INVALIDATE_BUFFER_BIT} |
| {@link GL30C#GL_MAP_FLUSH_EXPLICIT_BIT MAP_FLUSH_EXPLICIT_BIT} | {@link GL30C#GL_MAP_UNSYNCHRONIZED_BIT MAP_UNSYNCHRONIZED_BIT} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30C#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL30C#GL_CLAMP_READ_COLOR CLAMP_READ_COLOR} |
| {@link GL11#GL_TRUE TRUE} | {@link GL11#GL_FALSE FALSE} | {@link GL30C#GL_FIXED_ONLY FIXED_ONLY} |
| {@link GL30C#GL_RENDERBUFFER RENDERBUFFER} |
| {@link GL30C#GL_RENDERBUFFER RENDERBUFFER} |
{@link #glRenderbufferStorage RenderbufferStorage} is equivalent to calling this method with the samples set to zero.
+ * + * @param target the target of the allocation. Must be:| {@link GL30C#GL_RENDERBUFFER RENDERBUFFER} |
| {@link GL30C#GL_RENDERBUFFER RENDERBUFFER} |
| {@link GL30C#GL_RENDERBUFFER_WIDTH RENDERBUFFER_WIDTH} | {@link GL30C#GL_RENDERBUFFER_HEIGHT RENDERBUFFER_HEIGHT} | {@link GL30C#GL_RENDERBUFFER_INTERNAL_FORMAT RENDERBUFFER_INTERNAL_FORMAT} |
| {@link GL30C#GL_RENDERBUFFER_RED_SIZE RENDERBUFFER_RED_SIZE} | {@link GL30C#GL_RENDERBUFFER_GREEN_SIZE RENDERBUFFER_GREEN_SIZE} | {@link GL30C#GL_RENDERBUFFER_BLUE_SIZE RENDERBUFFER_BLUE_SIZE} |
| {@link GL30C#GL_RENDERBUFFER_ALPHA_SIZE RENDERBUFFER_ALPHA_SIZE} | {@link GL30C#GL_RENDERBUFFER_DEPTH_SIZE RENDERBUFFER_DEPTH_SIZE} | {@link GL30C#GL_RENDERBUFFER_STENCIL_SIZE RENDERBUFFER_STENCIL_SIZE} |
| {@link GL30C#GL_RENDERBUFFER_SAMPLES RENDERBUFFER_SAMPLES} |
| {@link GL30C#GL_RENDERBUFFER RENDERBUFFER} |
| {@link GL30C#GL_RENDERBUFFER_WIDTH RENDERBUFFER_WIDTH} | {@link GL30C#GL_RENDERBUFFER_HEIGHT RENDERBUFFER_HEIGHT} | {@link GL30C#GL_RENDERBUFFER_INTERNAL_FORMAT RENDERBUFFER_INTERNAL_FORMAT} |
| {@link GL30C#GL_RENDERBUFFER_RED_SIZE RENDERBUFFER_RED_SIZE} | {@link GL30C#GL_RENDERBUFFER_GREEN_SIZE RENDERBUFFER_GREEN_SIZE} | {@link GL30C#GL_RENDERBUFFER_BLUE_SIZE RENDERBUFFER_BLUE_SIZE} |
| {@link GL30C#GL_RENDERBUFFER_ALPHA_SIZE RENDERBUFFER_ALPHA_SIZE} | {@link GL30C#GL_RENDERBUFFER_DEPTH_SIZE RENDERBUFFER_DEPTH_SIZE} | {@link GL30C#GL_RENDERBUFFER_STENCIL_SIZE RENDERBUFFER_STENCIL_SIZE} |
| {@link GL30C#GL_RENDERBUFFER_SAMPLES RENDERBUFFER_SAMPLES} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30C#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30C#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30C#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30C#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30C#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30C#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30C#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30C#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30C#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30C#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30C#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30C#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30C#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30C#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30C#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30C#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30C#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30C#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30C#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30C#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30C#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30C#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30C#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30C#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30C#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30C#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30C#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30C#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30C#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30C#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30C#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30C#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30C#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30C#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30C#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30C#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30C#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30C#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30C#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30C#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30C#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30C#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30C#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30C#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30C#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30C#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30C#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30C#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30C#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30C#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30C#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30C#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30C#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30C#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30C#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30C#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30C#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30C#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30C#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30C#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30C#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30C#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30C#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30C#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30C#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30C#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30C#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30C#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30C#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30C#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30C#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30C#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30C#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30C#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30C#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30C#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30C#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30C#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30C#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30C#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30C#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30C#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30C#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30C#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30C#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30C#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30C#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30C#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30C#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30C#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30C#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30C#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30C#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30C#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30C#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30C#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30C#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30C#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30C#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30C#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30C#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30C#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30C#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30C#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30C#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30C#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30C#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30C#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30C#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30C#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30C#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30C#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30C#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30C#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30C#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30C#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30C#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30C#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30C#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30C#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30C#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30C#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30C#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30C#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30C#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30C#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30C#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30C#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30C#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30C#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30C#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30C#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30C#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30C#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30C#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30C#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30C#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30C#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30C#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30C#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30C#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30C#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30C#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30C#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30C#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30C#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30C#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30C#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30C#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30C#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30C#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30C#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30C#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30C#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30C#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30C#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30C#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30C#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30C#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30C#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30C#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30C#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30C#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30C#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30C#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30C#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30C#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30C#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30C#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30C#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30C#GL_RENDERBUFFER RENDERBUFFER} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30C#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30C#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30C#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30C#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30C#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30C#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30C#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30C#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30C#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30C#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30C#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30C#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30C#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30C#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30C#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30C#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30C#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30C#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30C#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30C#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30C#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30C#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30C#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30C#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30C#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30C#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30C#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30C#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30C#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30C#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30C#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30C#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30C#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30C#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME FRAMEBUFFER_ATTACHMENT_OBJECT_NAME} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE FRAMEBUFFER_ATTACHMENT_RED_SIZE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE FRAMEBUFFER_ATTACHMENT_GREEN_SIZE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE FRAMEBUFFER_ATTACHMENT_BLUE_SIZE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE} |
| {@link GL30C#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30C#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30C#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30C#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30C#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30C#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30C#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30C#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30C#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30C#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30C#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30C#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30C#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30C#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30C#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30C#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30C#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30C#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30C#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30C#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30C#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30C#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30C#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30C#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30C#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30C#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30C#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30C#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30C#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30C#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30C#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30C#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30C#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30C#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30C#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30C#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30C#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30C#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME FRAMEBUFFER_ATTACHMENT_OBJECT_NAME} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE FRAMEBUFFER_ATTACHMENT_RED_SIZE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE FRAMEBUFFER_ATTACHMENT_GREEN_SIZE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE FRAMEBUFFER_ATTACHMENT_BLUE_SIZE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE} | {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE} |
| {@link GL30C#GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE} |
| {@link GL11#GL_COLOR_BUFFER_BIT COLOR_BUFFER_BIT} | {@link GL11#GL_DEPTH_BUFFER_BIT DEPTH_BUFFER_BIT} | {@link GL11#GL_STENCIL_BUFFER_BIT STENCIL_BUFFER_BIT} |
| {@link GL11#GL_NEAREST NEAREST} | {@link GL11#GL_LINEAR LINEAR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30C#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL30C#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL30C#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} |
| {@link GL30C#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL30C#GL_INTERLEAVED_ATTRIBS INTERLEAVED_ATTRIBS} | {@link GL30C#GL_SEPARATE_ATTRIBS SEPARATE_ATTRIBS} |
| {@link GL30C#GL_INTERLEAVED_ATTRIBS INTERLEAVED_ATTRIBS} | {@link GL30C#GL_SEPARATE_ATTRIBS SEPARATE_ATTRIBS} |
| {@link GL30C#GL_INTERLEAVED_ATTRIBS INTERLEAVED_ATTRIBS} | {@link GL30C#GL_SEPARATE_ATTRIBS SEPARATE_ATTRIBS} |
OpenGL 3.0 implementations are guaranteed to support at least versions 1.10, 1.20 and 1.30 of the shading language, + * although versions 1.10 and 1.20 are deprecated in a forward-compatible context.
+ * + *Extensions promoted to core in this release:
+ * + *Accepted by the {@code type} argument of VertexPointer, NormalPointer, ColorPointer, SecondaryColorPointer, FogCoordPointer, TexCoordPointer, and + * VertexAttribPointer.
+ */ + public static final int GL_HALF_FLOAT = 0x140B; + + /** Accepted by the {@code internalFormat} parameter of TexImage1D, TexImage2D, and TexImage3D. */ + public static final int + GL_RGBA32UI = 0x8D70, + GL_RGB32UI = 0x8D71, + GL_RGBA16UI = 0x8D76, + GL_RGB16UI = 0x8D77, + GL_RGBA8UI = 0x8D7C, + GL_RGB8UI = 0x8D7D, + GL_RGBA32I = 0x8D82, + GL_RGB32I = 0x8D83, + GL_RGBA16I = 0x8D88, + GL_RGB16I = 0x8D89, + GL_RGBA8I = 0x8D8E, + GL_RGB8I = 0x8D8F; + + /** Accepted by the {@code format} parameter of TexImage1D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, DrawPixels and ReadPixels. */ + public static final int + GL_RED_INTEGER = 0x8D94, + GL_GREEN_INTEGER = 0x8D95, + GL_BLUE_INTEGER = 0x8D96, + GL_RGB_INTEGER = 0x8D98, + GL_RGBA_INTEGER = 0x8D99, + GL_BGR_INTEGER = 0x8D9A, + GL_BGRA_INTEGER = 0x8D9B; + + /** Accepted by the {@code target} parameter of TexParameteri, TexParameteriv, TexParameterf, TexParameterfv, GenerateMipmap, and BindTexture. */ + public static final int + GL_TEXTURE_1D_ARRAY = 0x8C18, + GL_TEXTURE_2D_ARRAY = 0x8C1A; + + /** Accepted by the {@code target} parameter of TexImage3D, TexSubImage3D, CopyTexSubImage3D, CompressedTexImage3D, and CompressedTexSubImage3D. */ + public static final int GL_PROXY_TEXTURE_2D_ARRAY = 0x8C1B; + + /** + * Accepted by the {@code target} parameter of TexImage2D, TexSubImage2D, CopyTexImage2D, CopyTexSubImage2D, CompressedTexImage2D, and + * CompressedTexSubImage2D. + */ + public static final int GL_PROXY_TEXTURE_1D_ARRAY = 0x8C19; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv and GetFloatv. */ + public static final int + GL_TEXTURE_BINDING_1D_ARRAY = 0x8C1C, + GL_TEXTURE_BINDING_2D_ARRAY = 0x8C1D, + GL_MAX_ARRAY_TEXTURE_LAYERS = 0x88FF; + + /** + * Accepted by the {@code internalformat} parameter of TexImage2D, CopyTexImage2D, and CompressedTexImage2D and the {@code format} parameter of + * CompressedTexSubImage2D. + */ + public static final int + GL_COMPRESSED_RED_RGTC1 = 0x8DBB, + GL_COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC, + GL_COMPRESSED_RG_RGTC2 = 0x8DBD, + GL_COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE; + + /** Accepted by the {@code internalFormat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, and CopyTexImage2D. */ + public static final int + GL_R8 = 0x8229, + GL_R16 = 0x822A, + GL_RG8 = 0x822B, + GL_RG16 = 0x822C, + GL_R16F = 0x822D, + GL_R32F = 0x822E, + GL_RG16F = 0x822F, + GL_RG32F = 0x8230, + GL_R8I = 0x8231, + GL_R8UI = 0x8232, + GL_R16I = 0x8233, + GL_R16UI = 0x8234, + GL_R32I = 0x8235, + GL_R32UI = 0x8236, + GL_RG8I = 0x8237, + GL_RG8UI = 0x8238, + GL_RG16I = 0x8239, + GL_RG16UI = 0x823A, + GL_RG32I = 0x823B, + GL_RG32UI = 0x823C, + GL_RG = 0x8227, + GL_COMPRESSED_RED = 0x8225, + GL_COMPRESSED_RG = 0x8226; + + /** Accepted by the {@code format} parameter of TexImage3D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, and ReadPixels. */ + public static final int GL_RG_INTEGER = 0x8228; + + /** + * Accepted by the {@code target} parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, GetBufferPointerv, + * BindBufferRange, BindBufferOffset and BindBufferBase. + */ + public static final int GL_TRANSFORM_FEEDBACK_BUFFER = 0x8C8E; + + /** Accepted by the {@code param} parameter of GetIntegeri_v and GetBooleani_v. */ + public static final int + GL_TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84, + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85; + + /** + * Accepted by the {@code param} parameter of GetIntegeri_v and GetBooleani_v, and by the {@code pname} parameter of GetBooleanv, + * GetDoublev, GetIntegerv, and GetFloatv. + */ + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F; + + /** Accepted by the {@code bufferMode} parameter of TransformFeedbackVaryings. */ + public static final int + GL_INTERLEAVED_ATTRIBS = 0x8C8C, + GL_SEPARATE_ATTRIBS = 0x8C8D; + + /** Accepted by the {@code target} parameter of BeginQuery, EndQuery, and GetQueryiv. */ + public static final int + GL_PRIMITIVES_GENERATED = 0x8C87, + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_RASTERIZER_DISCARD = 0x8C89; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A, + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B, + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80; + + /** Accepted by the {@code pname} parameter of GetProgramiv. */ + public static final int + GL_TRANSFORM_FEEDBACK_VARYINGS = 0x8C83, + GL_TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F, + GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_VERTEX_ARRAY_BINDING = 0x85B5; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_FRAMEBUFFER_SRGB = 0x8DB9; + + static { GL.initialize(); } + + protected GL30C() { + throw new UnsupportedOperationException(); + } + + // --- [ glGetStringi ] --- + + /** Unsafe version of: {@link #glGetStringi GetStringi} */ + public static native long nglGetStringi(int name, int index); + + /** + * Queries indexed string state. + * + * @param name the indexed state to query. One of:| {@link GL11#GL_EXTENSIONS EXTENSIONS} | {@link GL20#GL_SHADING_LANGUAGE_VERSION SHADING_LANGUAGE_VERSION} |
| {@link GL11#GL_COLOR COLOR} | {@link GL11#GL_STENCIL STENCIL} |
| {@link GL11#GL_COLOR COLOR} |
| {@link GL11#GL_COLOR COLOR} | {@link GL11#GL_DEPTH DEPTH} |
| {@link #GL_DEPTH_STENCIL DEPTH_STENCIL} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL20#GL_CURRENT_VERTEX_ATTRIB CURRENT_VERTEX_ATTRIB} |
| {@link GL20#GL_CURRENT_VERTEX_ATTRIB CURRENT_VERTEX_ATTRIB} |
| {@link GL20#GL_CURRENT_VERTEX_ATTRIB CURRENT_VERTEX_ATTRIB} |
| {@link GL20#GL_CURRENT_VERTEX_ATTRIB CURRENT_VERTEX_ATTRIB} |
| {@link #GL_QUERY_WAIT QUERY_WAIT} | {@link #GL_QUERY_NO_WAIT QUERY_NO_WAIT} | {@link #GL_QUERY_BY_REGION_WAIT QUERY_BY_REGION_WAIT} |
| {@link #GL_QUERY_BY_REGION_NO_WAIT QUERY_BY_REGION_NO_WAIT} | {@link GL45#GL_QUERY_WAIT_INVERTED QUERY_WAIT_INVERTED} | {@link GL45#GL_QUERY_NO_WAIT_INVERTED QUERY_NO_WAIT_INVERTED} |
| {@link GL45#GL_QUERY_BY_REGION_WAIT_INVERTED QUERY_BY_REGION_WAIT_INVERTED} | {@link GL45#GL_QUERY_BY_REGION_NO_WAIT_INVERTED QUERY_BY_REGION_NO_WAIT_INVERTED} |
LWJGL note: This method comes in 2 flavors:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link #GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_MAP_READ_BIT MAP_READ_BIT} | {@link #GL_MAP_WRITE_BIT MAP_WRITE_BIT} | {@link #GL_MAP_INVALIDATE_RANGE_BIT MAP_INVALIDATE_RANGE_BIT} | {@link #GL_MAP_INVALIDATE_BUFFER_BIT MAP_INVALIDATE_BUFFER_BIT} |
| {@link #GL_MAP_FLUSH_EXPLICIT_BIT MAP_FLUSH_EXPLICIT_BIT} | {@link #GL_MAP_UNSYNCHRONIZED_BIT MAP_UNSYNCHRONIZED_BIT} |
LWJGL note: This method comes in 2 flavors:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link #GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_MAP_READ_BIT MAP_READ_BIT} | {@link #GL_MAP_WRITE_BIT MAP_WRITE_BIT} | {@link #GL_MAP_INVALIDATE_RANGE_BIT MAP_INVALIDATE_RANGE_BIT} | {@link #GL_MAP_INVALIDATE_BUFFER_BIT MAP_INVALIDATE_BUFFER_BIT} |
| {@link #GL_MAP_FLUSH_EXPLICIT_BIT MAP_FLUSH_EXPLICIT_BIT} | {@link #GL_MAP_UNSYNCHRONIZED_BIT MAP_UNSYNCHRONIZED_BIT} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link #GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link #GL_CLAMP_READ_COLOR CLAMP_READ_COLOR} |
| {@link GL11#GL_TRUE TRUE} | {@link GL11#GL_FALSE FALSE} | {@link #GL_FIXED_ONLY FIXED_ONLY} |
| {@link #GL_RENDERBUFFER RENDERBUFFER} |
| {@link #GL_RENDERBUFFER RENDERBUFFER} |
{@link #glRenderbufferStorage RenderbufferStorage} is equivalent to calling this method with the samples set to zero.
+ * + * @param target the target of the allocation. Must be:| {@link #GL_RENDERBUFFER RENDERBUFFER} |
| {@link #GL_RENDERBUFFER RENDERBUFFER} |
| {@link #GL_RENDERBUFFER_WIDTH RENDERBUFFER_WIDTH} | {@link #GL_RENDERBUFFER_HEIGHT RENDERBUFFER_HEIGHT} | {@link #GL_RENDERBUFFER_INTERNAL_FORMAT RENDERBUFFER_INTERNAL_FORMAT} |
| {@link #GL_RENDERBUFFER_RED_SIZE RENDERBUFFER_RED_SIZE} | {@link #GL_RENDERBUFFER_GREEN_SIZE RENDERBUFFER_GREEN_SIZE} | {@link #GL_RENDERBUFFER_BLUE_SIZE RENDERBUFFER_BLUE_SIZE} |
| {@link #GL_RENDERBUFFER_ALPHA_SIZE RENDERBUFFER_ALPHA_SIZE} | {@link #GL_RENDERBUFFER_DEPTH_SIZE RENDERBUFFER_DEPTH_SIZE} | {@link #GL_RENDERBUFFER_STENCIL_SIZE RENDERBUFFER_STENCIL_SIZE} |
| {@link #GL_RENDERBUFFER_SAMPLES RENDERBUFFER_SAMPLES} |
| {@link #GL_RENDERBUFFER RENDERBUFFER} |
| {@link #GL_RENDERBUFFER_WIDTH RENDERBUFFER_WIDTH} | {@link #GL_RENDERBUFFER_HEIGHT RENDERBUFFER_HEIGHT} | {@link #GL_RENDERBUFFER_INTERNAL_FORMAT RENDERBUFFER_INTERNAL_FORMAT} |
| {@link #GL_RENDERBUFFER_RED_SIZE RENDERBUFFER_RED_SIZE} | {@link #GL_RENDERBUFFER_GREEN_SIZE RENDERBUFFER_GREEN_SIZE} | {@link #GL_RENDERBUFFER_BLUE_SIZE RENDERBUFFER_BLUE_SIZE} |
| {@link #GL_RENDERBUFFER_ALPHA_SIZE RENDERBUFFER_ALPHA_SIZE} | {@link #GL_RENDERBUFFER_DEPTH_SIZE RENDERBUFFER_DEPTH_SIZE} | {@link #GL_RENDERBUFFER_STENCIL_SIZE RENDERBUFFER_STENCIL_SIZE} |
| {@link #GL_RENDERBUFFER_SAMPLES RENDERBUFFER_SAMPLES} |
| {@link #GL_FRAMEBUFFER FRAMEBUFFER} | {@link #GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link #GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link #GL_FRAMEBUFFER FRAMEBUFFER} | {@link #GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link #GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link #GL_FRAMEBUFFER FRAMEBUFFER} | {@link #GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link #GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link #GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link #GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link #GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link #GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link #GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link #GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link #GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link #GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link #GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link #GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link #GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link #GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link #GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link #GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link #GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link #GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link #GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link #GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link #GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link #GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link #GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link #GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link #GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link #GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link #GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link #GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link #GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link #GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link #GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link #GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link #GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link #GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link #GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link #GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link #GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link #GL_FRAMEBUFFER FRAMEBUFFER} | {@link #GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link #GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link #GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link #GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link #GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link #GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link #GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link #GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link #GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link #GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link #GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link #GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link #GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link #GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link #GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link #GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link #GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link #GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link #GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link #GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link #GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link #GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link #GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link #GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link #GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link #GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link #GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link #GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link #GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link #GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link #GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link #GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link #GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link #GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link #GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link #GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link #GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link #GL_FRAMEBUFFER FRAMEBUFFER} | {@link #GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link #GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link #GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link #GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link #GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link #GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link #GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link #GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link #GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link #GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link #GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link #GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link #GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link #GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link #GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link #GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link #GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link #GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link #GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link #GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link #GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link #GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link #GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link #GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link #GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link #GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link #GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link #GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link #GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link #GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link #GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link #GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link #GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link #GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link #GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link #GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link #GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link #GL_FRAMEBUFFER FRAMEBUFFER} | {@link #GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link #GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link #GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link #GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link #GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link #GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link #GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link #GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link #GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link #GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link #GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link #GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link #GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link #GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link #GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link #GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link #GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link #GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link #GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link #GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link #GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link #GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link #GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link #GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link #GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link #GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link #GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link #GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link #GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link #GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link #GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link #GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link #GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link #GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link #GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link #GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link #GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link #GL_FRAMEBUFFER FRAMEBUFFER} | {@link #GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link #GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link #GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link #GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link #GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link #GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link #GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link #GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link #GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link #GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link #GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link #GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link #GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link #GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link #GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link #GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link #GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link #GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link #GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link #GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link #GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link #GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link #GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link #GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link #GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link #GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link #GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link #GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link #GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link #GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link #GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link #GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link #GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link #GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link #GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link #GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link #GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link #GL_RENDERBUFFER RENDERBUFFER} |
| {@link #GL_FRAMEBUFFER FRAMEBUFFER} | {@link #GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link #GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link #GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link #GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link #GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link #GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link #GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link #GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link #GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link #GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link #GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link #GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link #GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link #GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link #GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link #GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link #GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link #GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link #GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link #GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link #GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link #GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link #GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link #GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link #GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link #GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link #GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link #GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link #GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link #GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link #GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link #GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link #GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link #GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link #GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link #GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link #GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link #GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE} | {@link #GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME FRAMEBUFFER_ATTACHMENT_OBJECT_NAME} |
| {@link #GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL} | {@link #GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE} |
| {@link #GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER} | {@link #GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING} |
| {@link #GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE} | {@link #GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE FRAMEBUFFER_ATTACHMENT_RED_SIZE} |
| {@link #GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE FRAMEBUFFER_ATTACHMENT_GREEN_SIZE} | {@link #GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE FRAMEBUFFER_ATTACHMENT_BLUE_SIZE} |
| {@link #GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE} | {@link #GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE} |
| {@link #GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE} |
| {@link #GL_FRAMEBUFFER FRAMEBUFFER} | {@link #GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link #GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link #GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link #GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link #GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link #GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link #GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link #GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link #GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link #GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link #GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link #GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link #GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link #GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link #GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link #GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link #GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link #GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link #GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link #GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link #GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link #GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link #GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link #GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link #GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link #GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link #GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link #GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link #GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link #GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link #GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link #GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link #GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link #GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link #GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link #GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link #GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link #GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE} | {@link #GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME FRAMEBUFFER_ATTACHMENT_OBJECT_NAME} |
| {@link #GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL} | {@link #GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE} |
| {@link #GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER} | {@link #GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING} |
| {@link #GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE} | {@link #GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE FRAMEBUFFER_ATTACHMENT_RED_SIZE} |
| {@link #GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE FRAMEBUFFER_ATTACHMENT_GREEN_SIZE} | {@link #GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE FRAMEBUFFER_ATTACHMENT_BLUE_SIZE} |
| {@link #GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE} | {@link #GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE} |
| {@link #GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE} |
| {@link GL11#GL_COLOR_BUFFER_BIT COLOR_BUFFER_BIT} | {@link GL11#GL_DEPTH_BUFFER_BIT DEPTH_BUFFER_BIT} | {@link GL11#GL_STENCIL_BUFFER_BIT STENCIL_BUFFER_BIT} |
| {@link GL11#GL_NEAREST NEAREST} | {@link GL11#GL_LINEAR LINEAR} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link #GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link #GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link #GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} |
| {@link #GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_INTERLEAVED_ATTRIBS INTERLEAVED_ATTRIBS} | {@link #GL_SEPARATE_ATTRIBS SEPARATE_ATTRIBS} |
| {@link #GL_INTERLEAVED_ATTRIBS INTERLEAVED_ATTRIBS} | {@link #GL_SEPARATE_ATTRIBS SEPARATE_ATTRIBS} |
| {@link #GL_INTERLEAVED_ATTRIBS INTERLEAVED_ATTRIBS} | {@link #GL_SEPARATE_ATTRIBS SEPARATE_ATTRIBS} |
OpenGL 3.1 implementations support revision 1.40 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
An {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if any of readoffset, writeoffset, or size are negative, if readoffset+size exceeds the size of the buffer object + * bound to readtarget, or if writeoffset+size exceeds the size of the buffer object bound to writetarget.
+ * + *An {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if the same buffer object is bound to both readtarget and writetarget, and the ranges [readoffset, readoffset+size) + * and [writeoffset, writeoffset+size) overlap.
+ * + *An {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error is generated if zero is bound to readtarget or writetarget.
+ * + *An {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error is generated if the buffer objects bound to either readtarget or writetarget are mapped.
+ * + * @param readTarget the source buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL31C#GL_COPY_READ_BUFFER COPY_READ_BUFFER} | {@link GL31C#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} |
| {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} | {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31C#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL31C#GL_UNIFORM_BUFFER UNIFORM_BUFFER} |
When a buffer object is attached to a buffer texture, the buffer object's data store is taken as the texture's texel array. The number of texels in the + * buffer texture's texel array is given by
+ * + *{@code floor(buffer_size / (components * sizeof(base_type))},
+ * + *where {@code buffer_size} is the size of the buffer object, in basic machine units and {@code components} and {@code base_type} are the element count + * and base data type for elements. The number of texels in the texel array is then clamped to the implementation-dependent limit {@link GL31C#GL_MAX_TEXTURE_BUFFER_SIZE MAX_TEXTURE_BUFFER_SIZE}. + * When a buffer texture is accessed in a shader, the results of a texel fetch are undefined if the specified texel number is greater than or equal to the + * clamped number of texels in the texel array.
+ * + *When a buffer texture is accessed in a shader, an integer is provided to indicate the texel number being accessed. If no buffer object is bound to the + * buffer texture, the results of the texel access are undefined. Otherwise, the attached buffer object's data store is interpreted as an array of elements + * of the GL data type corresponding to {@code internalformat}. Each texel consists of one to four elements that are mapped to texture components + * (R, G, B, A, L, and I). Element {@code m} of the texel numbered {@code n} is taken from element {@code n} * {@code components} + {@code m} of the + * attached buffer object's data store. Elements and texels are both numbered starting with zero. For texture formats with normalized components, the + * extracted values are converted to floating-point values. The components of the texture are then converted to an (R,G,B,A) vector, and returned to the + * shader as a four-component result vector with components of the appropriate data type for the texture's internal format.
+ * + * @param target the target of the operation. Must be:| {@link GL31C#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL31C#GL_UNIFORM_BLOCK_BINDING UNIFORM_BLOCK_BINDING} | {@link GL31C#GL_UNIFORM_BLOCK_DATA_SIZE UNIFORM_BLOCK_DATA_SIZE} |
| {@link GL31C#GL_UNIFORM_BLOCK_NAME_LENGTH UNIFORM_BLOCK_NAME_LENGTH} | {@link GL31C#GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS UNIFORM_BLOCK_ACTIVE_UNIFORMS} |
| {@link GL31C#GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES} | {@link GL31C#GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER} |
| {@link GL31C#GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER} | {@link GL31C#GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER} |
| {@link GL31C#GL_UNIFORM_BLOCK_BINDING UNIFORM_BLOCK_BINDING} | {@link GL31C#GL_UNIFORM_BLOCK_DATA_SIZE UNIFORM_BLOCK_DATA_SIZE} |
| {@link GL31C#GL_UNIFORM_BLOCK_NAME_LENGTH UNIFORM_BLOCK_NAME_LENGTH} | {@link GL31C#GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS UNIFORM_BLOCK_ACTIVE_UNIFORMS} |
| {@link GL31C#GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES} | {@link GL31C#GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER} |
| {@link GL31C#GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER} | {@link GL31C#GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER} |
OpenGL 3.1 implementations support revision 1.40 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} |
| {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
An {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if any of readoffset, writeoffset, or size are negative, if readoffset+size exceeds the size of the buffer object + * bound to readtarget, or if writeoffset+size exceeds the size of the buffer object bound to writetarget.
+ * + *An {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if the same buffer object is bound to both readtarget and writetarget, and the ranges [readoffset, readoffset+size) + * and [writeoffset, writeoffset+size) overlap.
+ * + *An {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error is generated if zero is bound to readtarget or writetarget.
+ * + *An {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error is generated if the buffer objects bound to either readtarget or writetarget are mapped.
+ * + * @param readTarget the source buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link #GL_COPY_READ_BUFFER COPY_READ_BUFFER} | {@link #GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} |
| {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} | {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link #GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link #GL_UNIFORM_BUFFER UNIFORM_BUFFER} |
When a buffer object is attached to a buffer texture, the buffer object's data store is taken as the texture's texel array. The number of texels in the + * buffer texture's texel array is given by
+ * + *{@code floor(buffer_size / (components * sizeof(base_type))},
+ * + *where {@code buffer_size} is the size of the buffer object, in basic machine units and {@code components} and {@code base_type} are the element count + * and base data type for elements. The number of texels in the texel array is then clamped to the implementation-dependent limit {@link #GL_MAX_TEXTURE_BUFFER_SIZE MAX_TEXTURE_BUFFER_SIZE}. + * When a buffer texture is accessed in a shader, the results of a texel fetch are undefined if the specified texel number is greater than or equal to the + * clamped number of texels in the texel array.
+ * + *When a buffer texture is accessed in a shader, an integer is provided to indicate the texel number being accessed. If no buffer object is bound to the + * buffer texture, the results of the texel access are undefined. Otherwise, the attached buffer object's data store is interpreted as an array of elements + * of the GL data type corresponding to {@code internalformat}. Each texel consists of one to four elements that are mapped to texture components + * (R, G, B, A, L, and I). Element {@code m} of the texel numbered {@code n} is taken from element {@code n} * {@code components} + {@code m} of the + * attached buffer object's data store. Elements and texels are both numbered starting with zero. For texture formats with normalized components, the + * extracted values are converted to floating-point values. The components of the texture are then converted to an (R,G,B,A) vector, and returned to the + * shader as a four-component result vector with components of the appropriate data type for the texture's internal format.
+ * + * @param target the target of the operation. Must be:| {@link #GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link #GL_UNIFORM_BLOCK_BINDING UNIFORM_BLOCK_BINDING} | {@link #GL_UNIFORM_BLOCK_DATA_SIZE UNIFORM_BLOCK_DATA_SIZE} |
| {@link #GL_UNIFORM_BLOCK_NAME_LENGTH UNIFORM_BLOCK_NAME_LENGTH} | {@link #GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS UNIFORM_BLOCK_ACTIVE_UNIFORMS} |
| {@link #GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES} | {@link #GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER} |
| {@link #GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER} | {@link #GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER} |
| {@link #GL_UNIFORM_BLOCK_BINDING UNIFORM_BLOCK_BINDING} | {@link #GL_UNIFORM_BLOCK_DATA_SIZE UNIFORM_BLOCK_DATA_SIZE} |
| {@link #GL_UNIFORM_BLOCK_NAME_LENGTH UNIFORM_BLOCK_NAME_LENGTH} | {@link #GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS UNIFORM_BLOCK_ACTIVE_UNIFORMS} |
| {@link #GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES} | {@link #GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER} |
| {@link #GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER} | {@link #GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER} |
OpenGL 3.2 implementations support revision 1.50 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
LWJGL note: Use {@link org.lwjgl.system.MemoryUtil#memAddress} to retrieve pointers to the index buffers.
+ * + * @param mode the kind of primitives to render. One of:| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32C#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32C#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32C#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32C#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL32C#GL_FIRST_VERTEX_CONVENTION FIRST_VERTEX_CONVENTION} | {@link GL32C#GL_LAST_VERTEX_CONVENTION LAST_VERTEX_CONVENTION} |
| {@link GL32C#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32C#GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} |
| {@link GL32C#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} | {@link GL32C#GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL32C#GL_SAMPLE_POSITION SAMPLE_POSITION} |
| {@link GL32C#GL_SAMPLE_POSITION SAMPLE_POSITION} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL32C#GL_SYNC_GPU_COMMANDS_COMPLETE SYNC_GPU_COMMANDS_COMPLETE} |
The return value is one of four status values:
+ * + *| 0 | {@link GL32C#GL_SYNC_FLUSH_COMMANDS_BIT SYNC_FLUSH_COMMANDS_BIT} |
{@code glWaitSync} will always wait no longer than an implementation-dependent timeout. The duration of this timeout in nanoseconds may be queried by + * with {@link GL32C#GL_MAX_SERVER_WAIT_TIMEOUT MAX_SERVER_WAIT_TIMEOUT}. There is currently no way to determine whether glWaitSync unblocked because the timeout expired or because the + * sync object being waited on was signaled.
+ * + *If an error occurs, {@code glWaitSync} does not cause the GL server to block.
+ * + * @param sync the sync object whose status to wait on + * @param flags a bitfield controlling the command flushing behavior. Must be:| 0 |
| {@link GL32C#GL_TIMEOUT_IGNORED TIMEOUT_IGNORED} |
| {@link GL32C#GL_OBJECT_TYPE OBJECT_TYPE} | {@link GL32C#GL_SYNC_CONDITION SYNC_CONDITION} | {@link GL32C#GL_SYNC_STATUS SYNC_STATUS} | {@link GL32C#GL_SYNC_FLAGS SYNC_FLAGS} |
| {@link GL32C#GL_OBJECT_TYPE OBJECT_TYPE} | {@link GL32C#GL_SYNC_CONDITION SYNC_CONDITION} | {@link GL32C#GL_SYNC_STATUS SYNC_STATUS} | {@link GL32C#GL_SYNC_FLAGS SYNC_FLAGS} |
OpenGL 3.2 implementations support revision 1.50 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
LWJGL note: Use {@link org.lwjgl.system.MemoryUtil#memAddress} to retrieve pointers to the index buffers.
+ * + * @param mode the kind of primitives to render. One of:| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link #GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link #GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link #GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link #GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link #GL_FIRST_VERTEX_CONVENTION FIRST_VERTEX_CONVENTION} | {@link #GL_LAST_VERTEX_CONVENTION LAST_VERTEX_CONVENTION} |
| {@link #GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link #GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} |
| {@link #GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} | {@link #GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link #GL_SAMPLE_POSITION SAMPLE_POSITION} |
| {@link #GL_SAMPLE_POSITION SAMPLE_POSITION} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link #GL_SYNC_GPU_COMMANDS_COMPLETE SYNC_GPU_COMMANDS_COMPLETE} |
The return value is one of four status values:
+ * + *| 0 | {@link #GL_SYNC_FLUSH_COMMANDS_BIT SYNC_FLUSH_COMMANDS_BIT} |
{@code glWaitSync} will always wait no longer than an implementation-dependent timeout. The duration of this timeout in nanoseconds may be queried by + * with {@link #GL_MAX_SERVER_WAIT_TIMEOUT MAX_SERVER_WAIT_TIMEOUT}. There is currently no way to determine whether glWaitSync unblocked because the timeout expired or because the + * sync object being waited on was signaled.
+ * + *If an error occurs, {@code glWaitSync} does not cause the GL server to block.
+ * + * @param sync the sync object whose status to wait on + * @param flags a bitfield controlling the command flushing behavior. Must be:| 0 |
| {@link #GL_TIMEOUT_IGNORED TIMEOUT_IGNORED} |
| {@link #GL_OBJECT_TYPE OBJECT_TYPE} | {@link #GL_SYNC_CONDITION SYNC_CONDITION} | {@link #GL_SYNC_STATUS SYNC_STATUS} | {@link #GL_SYNC_FLAGS SYNC_FLAGS} |
| {@link #GL_OBJECT_TYPE OBJECT_TYPE} | {@link #GL_SYNC_CONDITION SYNC_CONDITION} | {@link #GL_SYNC_STATUS SYNC_STATUS} | {@link #GL_SYNC_FLAGS SYNC_FLAGS} |
OpenGL 3.3 implementations support revision 3.30 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} | {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} |
| {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} | {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} | {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} |
| {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} | {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} |
| {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} | {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| , | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} |
| {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} | {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} |
| {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} | {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| , | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} |
| {@link GL33C#GL_TIMESTAMP TIMESTAMP} |
| {@link GL15#GL_QUERY_RESULT QUERY_RESULT} | {@link GL15#GL_QUERY_RESULT_AVAILABLE QUERY_RESULT_AVAILABLE} |
| {@link GL15#GL_QUERY_RESULT QUERY_RESULT} | {@link GL15#GL_QUERY_RESULT_AVAILABLE QUERY_RESULT_AVAILABLE} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| type | of | packing | used | on | the | data |
| type | of | packing | used | on | the | data |
| type | of | packing | used | on | the | data |
| type | of | packing | used | on | the | data |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL33C#GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
OpenGL 3.3 implementations support revision 3.30 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} | {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} |
| {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} | {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} | {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} |
| {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} | {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} |
| {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} | {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| , | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} |
| {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} | {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} |
| {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} | {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| , | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} |
| {@link #GL_TIMESTAMP TIMESTAMP} |
| {@link GL15#GL_QUERY_RESULT QUERY_RESULT} | {@link GL15#GL_QUERY_RESULT_AVAILABLE QUERY_RESULT_AVAILABLE} |
| {@link GL15#GL_QUERY_RESULT QUERY_RESULT} | {@link GL15#GL_QUERY_RESULT_AVAILABLE QUERY_RESULT_AVAILABLE} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link #GL_INT_2_10_10_10_REV INT_2_10_10_10_REV} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
OpenGL 4.0 implementations support revision 4.00 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL14#GL_FUNC_ADD FUNC_ADD} | {@link GL14#GL_FUNC_SUBTRACT FUNC_SUBTRACT} | {@link GL14#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} | {@link GL14#GL_MIN MIN} | {@link GL14#GL_MAX MAX} |
| {@link GL14#GL_FUNC_ADD FUNC_ADD} | {@link GL14#GL_FUNC_SUBTRACT FUNC_SUBTRACT} | {@link GL14#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} | {@link GL14#GL_MIN MIN} | {@link GL14#GL_MAX MAX} |
| {@link GL14#GL_FUNC_ADD FUNC_ADD} | {@link GL14#GL_FUNC_SUBTRACT FUNC_SUBTRACT} | {@link GL14#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} | {@link GL14#GL_MIN MIN} | {@link GL14#GL_MAX MAX} |
{@code glDrawArraysIndirect} behaves similarly to {@link GL42C#glDrawArraysInstancedBaseInstance DrawArraysInstancedBaseInstance}, except that the parameters to + * glDrawArraysInstancedBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance; // must be 0 unless OpenGL 4.2 is supported
+ * } DrawArraysIndirectCommand;
+ *
+ * const DrawArraysIndirectCommand *cmd = (const DrawArraysIndirectCommand *)indirect;
+ * glDrawArraysInstancedBaseInstance(mode, cmd->first, cmd->count, cmd->primCount, cmd->baseInstance);| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
{@code glDrawArraysIndirect} behaves similarly to {@link GL42C#glDrawArraysInstancedBaseInstance DrawArraysInstancedBaseInstance}, except that the parameters to + * glDrawArraysInstancedBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance; // must be 0 unless OpenGL 4.2 is supported
+ * } DrawArraysIndirectCommand;
+ *
+ * const DrawArraysIndirectCommand *cmd = (const DrawArraysIndirectCommand *)indirect;
+ * glDrawArraysInstancedBaseInstance(mode, cmd->first, cmd->count, cmd->primCount, cmd->baseInstance);| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
{@code glDrawArraysIndirect} behaves similarly to {@link GL42C#glDrawArraysInstancedBaseInstance DrawArraysInstancedBaseInstance}, except that the parameters to + * glDrawArraysInstancedBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance; // must be 0 unless OpenGL 4.2 is supported
+ * } DrawArraysIndirectCommand;
+ *
+ * const DrawArraysIndirectCommand *cmd = (const DrawArraysIndirectCommand *)indirect;
+ * glDrawArraysInstancedBaseInstance(mode, cmd->first, cmd->count, cmd->primCount, cmd->baseInstance);| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
{@code glDrawElementsIndirect} behaves similarly to {@link GL42C#glDrawElementsInstancedBaseVertexBaseInstance DrawElementsInstancedBaseVertexBaseInstance}, execpt that the parameters to + * glDrawElementsInstancedBaseVertexBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;{@code glDrawElementsIndirect} is equivalent to:
+ * + *
+ * void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect) {
+ * const DrawElementsIndirectCommand *cmd = (const DrawElementsIndirectCommand *)indirect;
+ * glDrawElementsInstancedBaseVertexBaseInstance(
+ * mode,
+ * cmd->count,
+ * type,
+ * cmd->firstIndex + size-of-type,
+ * cmd->primCount,
+ * cmd->baseVertex,
+ * cmd->baseInstance
+ * );
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
{@code glDrawElementsIndirect} behaves similarly to {@link GL42C#glDrawElementsInstancedBaseVertexBaseInstance DrawElementsInstancedBaseVertexBaseInstance}, execpt that the parameters to + * glDrawElementsInstancedBaseVertexBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;{@code glDrawElementsIndirect} is equivalent to:
+ * + *
+ * void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect) {
+ * const DrawElementsIndirectCommand *cmd = (const DrawElementsIndirectCommand *)indirect;
+ * glDrawElementsInstancedBaseVertexBaseInstance(
+ * mode,
+ * cmd->count,
+ * type,
+ * cmd->firstIndex + size-of-type,
+ * cmd->primCount,
+ * cmd->baseVertex,
+ * cmd->baseInstance
+ * );
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
{@code glDrawElementsIndirect} behaves similarly to {@link GL42C#glDrawElementsInstancedBaseVertexBaseInstance DrawElementsInstancedBaseVertexBaseInstance}, execpt that the parameters to + * glDrawElementsInstancedBaseVertexBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;{@code glDrawElementsIndirect} is equivalent to:
+ * + *
+ * void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect) {
+ * const DrawElementsIndirectCommand *cmd = (const DrawElementsIndirectCommand *)indirect;
+ * glDrawElementsInstancedBaseVertexBaseInstance(
+ * mode,
+ * cmd->count,
+ * type,
+ * cmd->firstIndex + size-of-type,
+ * cmd->primCount,
+ * cmd->baseVertex,
+ * cmd->baseInstance
+ * );
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL40C#GL_NUM_COMPATIBLE_SUBROUTINES NUM_COMPATIBLE_SUBROUTINES} | {@link GL40C#GL_COMPATIBLE_SUBROUTINES COMPATIBLE_SUBROUTINES} | {@link GL31#GL_UNIFORM_SIZE UNIFORM_SIZE} | {@link GL31#GL_UNIFORM_NAME_LENGTH UNIFORM_NAME_LENGTH} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL40C#GL_NUM_COMPATIBLE_SUBROUTINES NUM_COMPATIBLE_SUBROUTINES} | {@link GL40C#GL_COMPATIBLE_SUBROUTINES COMPATIBLE_SUBROUTINES} | {@link GL31#GL_UNIFORM_SIZE UNIFORM_SIZE} | {@link GL31#GL_UNIFORM_NAME_LENGTH UNIFORM_NAME_LENGTH} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL40C#GL_ACTIVE_SUBROUTINES ACTIVE_SUBROUTINES} | {@link GL40C#GL_ACTIVE_SUBROUTINE_UNIFORMS ACTIVE_SUBROUTINE_UNIFORMS} |
| {@link GL40C#GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS} | {@link GL40C#GL_ACTIVE_SUBROUTINE_MAX_LENGTH ACTIVE_SUBROUTINE_MAX_LENGTH} |
| {@link GL40C#GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link GL40C#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link GL40C#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL40C#GL_ACTIVE_SUBROUTINES ACTIVE_SUBROUTINES} | {@link GL40C#GL_ACTIVE_SUBROUTINE_UNIFORMS ACTIVE_SUBROUTINE_UNIFORMS} |
| {@link GL40C#GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS} | {@link GL40C#GL_ACTIVE_SUBROUTINE_MAX_LENGTH ACTIVE_SUBROUTINE_MAX_LENGTH} |
| {@link GL40C#GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH} |
| {@link GL40C#GL_PATCH_VERTICES PATCH_VERTICES} |
| {@link GL40C#GL_PATCH_DEFAULT_OUTER_LEVEL PATCH_DEFAULT_OUTER_LEVEL} | {@link GL40C#GL_PATCH_DEFAULT_INNER_LEVEL PATCH_DEFAULT_INNER_LEVEL} |
| {@link GL40C#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
When transform feedback operations are paused, transform feedback is still considered active and changing most transform feedback state related to the + * object results in an error. However, a new transform feedback object may be bound while transform feedback is paused. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} + * is generated by PauseTransformFeedback if the currently bound transform feedback is not active or is paused.
+ * + *When transform feedback is active and not paused, all geometric primitives generated must be compatible with the value of {@code primitiveMode} passed + * to {@link GL30C#glBeginTransformFeedback BeginTransformFeedback}. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated by {@link GL11#glBegin Begin} or any operation that implicitly calls {@link GL11#glBegin Begin} + * (such as {@link GL11C#glDrawElements DrawElements}) if {@code mode} is not one of the allowed modes. If a geometry shader is active, its output primitive type is used instead + * of the {@code mode} parameter passed to {@link GL11#glBegin Begin} for the purposes of this error check. Any primitive type may be used while transform feedback is + * paused.
+ * + * @see Reference Page + */ + public static void glPauseTransformFeedback() { + GL40C.glPauseTransformFeedback(); + } + + // --- [ glResumeTransformFeedback ] --- + + /** + * Resumes transform feedback operations for the currently bound transform feedback object. + * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated by {@link #glResumeTransformFeedback ResumeTransformFeedback} if the currently bound transform feedback is not active or is not paused.
+ * + * @see Reference Page + */ + public static void glResumeTransformFeedback() { + GL40C.glResumeTransformFeedback(); + } + + // --- [ glDrawTransformFeedback ] --- + + /** + * Render primitives using a count derived from a transform feedback object. + * + * @param mode what kind of primitives to render. One of:| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40C#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
OpenGL 4.0 implementations support revision 4.00 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL14#GL_FUNC_ADD FUNC_ADD} | {@link GL14#GL_FUNC_SUBTRACT FUNC_SUBTRACT} | {@link GL14#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} | {@link GL14#GL_MIN MIN} | {@link GL14#GL_MAX MAX} |
| {@link GL14#GL_FUNC_ADD FUNC_ADD} | {@link GL14#GL_FUNC_SUBTRACT FUNC_SUBTRACT} | {@link GL14#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} | {@link GL14#GL_MIN MIN} | {@link GL14#GL_MAX MAX} |
| {@link GL14#GL_FUNC_ADD FUNC_ADD} | {@link GL14#GL_FUNC_SUBTRACT FUNC_SUBTRACT} | {@link GL14#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} | {@link GL14#GL_MIN MIN} | {@link GL14#GL_MAX MAX} |
{@code glDrawArraysIndirect} behaves similarly to {@link GL42C#glDrawArraysInstancedBaseInstance DrawArraysInstancedBaseInstance}, except that the parameters to + * glDrawArraysInstancedBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance; // must be 0 unless OpenGL 4.2 is supported
+ * } DrawArraysIndirectCommand;
+ *
+ * const DrawArraysIndirectCommand *cmd = (const DrawArraysIndirectCommand *)indirect;
+ * glDrawArraysInstancedBaseInstance(mode, cmd->first, cmd->count, cmd->primCount, cmd->baseInstance);| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link #GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
{@code glDrawArraysIndirect} behaves similarly to {@link GL42C#glDrawArraysInstancedBaseInstance DrawArraysInstancedBaseInstance}, except that the parameters to + * glDrawArraysInstancedBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance; // must be 0 unless OpenGL 4.2 is supported
+ * } DrawArraysIndirectCommand;
+ *
+ * const DrawArraysIndirectCommand *cmd = (const DrawArraysIndirectCommand *)indirect;
+ * glDrawArraysInstancedBaseInstance(mode, cmd->first, cmd->count, cmd->primCount, cmd->baseInstance);| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link #GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
{@code glDrawArraysIndirect} behaves similarly to {@link GL42C#glDrawArraysInstancedBaseInstance DrawArraysInstancedBaseInstance}, except that the parameters to + * glDrawArraysInstancedBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance; // must be 0 unless OpenGL 4.2 is supported
+ * } DrawArraysIndirectCommand;
+ *
+ * const DrawArraysIndirectCommand *cmd = (const DrawArraysIndirectCommand *)indirect;
+ * glDrawArraysInstancedBaseInstance(mode, cmd->first, cmd->count, cmd->primCount, cmd->baseInstance);| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link #GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
{@code glDrawElementsIndirect} behaves similarly to {@link GL42C#glDrawElementsInstancedBaseVertexBaseInstance DrawElementsInstancedBaseVertexBaseInstance}, execpt that the parameters to + * glDrawElementsInstancedBaseVertexBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;{@code glDrawElementsIndirect} is equivalent to:
+ * + *
+ * void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect) {
+ * const DrawElementsIndirectCommand *cmd = (const DrawElementsIndirectCommand *)indirect;
+ * glDrawElementsInstancedBaseVertexBaseInstance(
+ * mode,
+ * cmd->count,
+ * type,
+ * cmd->firstIndex + size-of-type,
+ * cmd->primCount,
+ * cmd->baseVertex,
+ * cmd->baseInstance
+ * );
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link #GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
{@code glDrawElementsIndirect} behaves similarly to {@link GL42C#glDrawElementsInstancedBaseVertexBaseInstance DrawElementsInstancedBaseVertexBaseInstance}, execpt that the parameters to + * glDrawElementsInstancedBaseVertexBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;{@code glDrawElementsIndirect} is equivalent to:
+ * + *
+ * void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect) {
+ * const DrawElementsIndirectCommand *cmd = (const DrawElementsIndirectCommand *)indirect;
+ * glDrawElementsInstancedBaseVertexBaseInstance(
+ * mode,
+ * cmd->count,
+ * type,
+ * cmd->firstIndex + size-of-type,
+ * cmd->primCount,
+ * cmd->baseVertex,
+ * cmd->baseInstance
+ * );
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link #GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
{@code glDrawElementsIndirect} behaves similarly to {@link GL42C#glDrawElementsInstancedBaseVertexBaseInstance DrawElementsInstancedBaseVertexBaseInstance}, execpt that the parameters to + * glDrawElementsInstancedBaseVertexBaseInstance are stored in memory at the address given by {@code indirect}.
+ * + *The parameters addressed by {@code indirect} are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;{@code glDrawElementsIndirect} is equivalent to:
+ * + *
+ * void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect) {
+ * const DrawElementsIndirectCommand *cmd = (const DrawElementsIndirectCommand *)indirect;
+ * glDrawElementsInstancedBaseVertexBaseInstance(
+ * mode,
+ * cmd->count,
+ * type,
+ * cmd->firstIndex + size-of-type,
+ * cmd->primCount,
+ * cmd->baseVertex,
+ * cmd->baseInstance
+ * );
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link #GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link #GL_NUM_COMPATIBLE_SUBROUTINES NUM_COMPATIBLE_SUBROUTINES} | {@link #GL_COMPATIBLE_SUBROUTINES COMPATIBLE_SUBROUTINES} | {@link GL31#GL_UNIFORM_SIZE UNIFORM_SIZE} | {@link GL31#GL_UNIFORM_NAME_LENGTH UNIFORM_NAME_LENGTH} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link #GL_NUM_COMPATIBLE_SUBROUTINES NUM_COMPATIBLE_SUBROUTINES} | {@link #GL_COMPATIBLE_SUBROUTINES COMPATIBLE_SUBROUTINES} | {@link GL31#GL_UNIFORM_SIZE UNIFORM_SIZE} | {@link GL31#GL_UNIFORM_NAME_LENGTH UNIFORM_NAME_LENGTH} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link #GL_ACTIVE_SUBROUTINES ACTIVE_SUBROUTINES} | {@link #GL_ACTIVE_SUBROUTINE_UNIFORMS ACTIVE_SUBROUTINE_UNIFORMS} |
| {@link #GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS} | {@link #GL_ACTIVE_SUBROUTINE_MAX_LENGTH ACTIVE_SUBROUTINE_MAX_LENGTH} |
| {@link #GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} | {@link #GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} |
| {@link #GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link #GL_ACTIVE_SUBROUTINES ACTIVE_SUBROUTINES} | {@link #GL_ACTIVE_SUBROUTINE_UNIFORMS ACTIVE_SUBROUTINE_UNIFORMS} |
| {@link #GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS} | {@link #GL_ACTIVE_SUBROUTINE_MAX_LENGTH ACTIVE_SUBROUTINE_MAX_LENGTH} |
| {@link #GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH} |
| {@link #GL_PATCH_VERTICES PATCH_VERTICES} |
| {@link #GL_PATCH_DEFAULT_OUTER_LEVEL PATCH_DEFAULT_OUTER_LEVEL} | {@link #GL_PATCH_DEFAULT_INNER_LEVEL PATCH_DEFAULT_INNER_LEVEL} |
| {@link #GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
When transform feedback operations are paused, transform feedback is still considered active and changing most transform feedback state related to the + * object results in an error. However, a new transform feedback object may be bound while transform feedback is paused. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} + * is generated by PauseTransformFeedback if the currently bound transform feedback is not active or is paused.
+ * + *When transform feedback is active and not paused, all geometric primitives generated must be compatible with the value of {@code primitiveMode} passed + * to {@link GL30C#glBeginTransformFeedback BeginTransformFeedback}. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated by {@link GL11#glBegin Begin} or any operation that implicitly calls {@link GL11#glBegin Begin} + * (such as {@link GL11C#glDrawElements DrawElements}) if {@code mode} is not one of the allowed modes. If a geometry shader is active, its output primitive type is used instead + * of the {@code mode} parameter passed to {@link GL11#glBegin Begin} for the purposes of this error check. Any primitive type may be used while transform feedback is + * paused.
+ * + * @see Reference Page + */ + public static native void glPauseTransformFeedback(); + + // --- [ glResumeTransformFeedback ] --- + + /** + * Resumes transform feedback operations for the currently bound transform feedback object. + * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated by {@link #glResumeTransformFeedback ResumeTransformFeedback} if the currently bound transform feedback is not active or is not paused.
+ * + * @see Reference Page + */ + public static native void glResumeTransformFeedback(); + + // --- [ glDrawTransformFeedback ] --- + + /** + * Render primitives using a count derived from a transform feedback object. + * + * @param mode what kind of primitives to render. One of:| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link #GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link #GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
OpenGL 4.1 implementations support revision 4.10 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} |
| {@link GL41C#GL_PROGRAM_BINARY_RETRIEVABLE_HINT PROGRAM_BINARY_RETRIEVABLE_HINT} | {@link GL41C#GL_PROGRAM_SEPARABLE PROGRAM_SEPARABLE} |
{@code glCreateShaderProgram} is equivalent (assuming no errors are generated) to:
+ * + *
+ * const GLuint shader = glCreateShader(type);
+ * if (shader) {
+ * glShaderSource(shader, count, strings, NULL);
+ * glCompileShader(shader);
+ * const GLuint program = glCreateProgram();
+ * if (program) {
+ * GLint compiled = GL_FALSE;
+ * glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+ * glProgramParameteri(program, GL_PROGRAM_SEPARABLE, GL_TRUE);
+ * if (compiled) {
+ * glAttachShader(program, shader);
+ * glLinkProgram(program);
+ * glDetachShader(program, shader);
+ * }
+ * // append-shader-info-log-to-program-info-log
+ * }
+ * glDeleteShader(shader);
+ * return program;
+ * } else {
+ * return 0;
+ * }The program object created by glCreateShaderProgram has its GL_PROGRAM_SEPARABLE status set to GL_TRUE.
+ * + * @param type the type of shader to create + * @param strings an array of pointers to source code strings from which to create the program object + * + * @see Reference Page + */ + @NativeType("GLuint") + public static int glCreateShaderProgramv(@NativeType("GLenum") int type, @NativeType("GLchar const **") PointerBuffer strings) { + return GL41C.glCreateShaderProgramv(type, strings); + } + + /** + * Creates a stand-alone program from an array of null-terminated source code strings. + * + *{@code glCreateShaderProgram} is equivalent (assuming no errors are generated) to:
+ * + *
+ * const GLuint shader = glCreateShader(type);
+ * if (shader) {
+ * glShaderSource(shader, count, strings, NULL);
+ * glCompileShader(shader);
+ * const GLuint program = glCreateProgram();
+ * if (program) {
+ * GLint compiled = GL_FALSE;
+ * glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+ * glProgramParameteri(program, GL_PROGRAM_SEPARABLE, GL_TRUE);
+ * if (compiled) {
+ * glAttachShader(program, shader);
+ * glLinkProgram(program);
+ * glDetachShader(program, shader);
+ * }
+ * // append-shader-info-log-to-program-info-log
+ * }
+ * glDeleteShader(shader);
+ * return program;
+ * } else {
+ * return 0;
+ * }The program object created by glCreateShaderProgram has its GL_PROGRAM_SEPARABLE status set to GL_TRUE.
+ * + * @param type the type of shader to create + * @param strings an array of pointers to source code strings from which to create the program object + * + * @see Reference Page + */ + @NativeType("GLuint") + public static int glCreateShaderProgramv(@NativeType("GLenum") int type, @NativeType("GLchar const **") CharSequence... strings) { + return GL41C.glCreateShaderProgramv(type, strings); + } + + /** + * Creates a stand-alone program from an array of null-terminated source code strings. + * + *{@code glCreateShaderProgram} is equivalent (assuming no errors are generated) to:
+ * + *
+ * const GLuint shader = glCreateShader(type);
+ * if (shader) {
+ * glShaderSource(shader, count, strings, NULL);
+ * glCompileShader(shader);
+ * const GLuint program = glCreateProgram();
+ * if (program) {
+ * GLint compiled = GL_FALSE;
+ * glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+ * glProgramParameteri(program, GL_PROGRAM_SEPARABLE, GL_TRUE);
+ * if (compiled) {
+ * glAttachShader(program, shader);
+ * glLinkProgram(program);
+ * glDetachShader(program, shader);
+ * }
+ * // append-shader-info-log-to-program-info-log
+ * }
+ * glDeleteShader(shader);
+ * return program;
+ * } else {
+ * return 0;
+ * }The program object created by glCreateShaderProgram has its GL_PROGRAM_SEPARABLE status set to GL_TRUE.
+ * + * @param type the type of shader to create + * + * @see Reference Page + */ + @NativeType("GLuint") + public static int glCreateShaderProgramv(@NativeType("GLenum") int type, @NativeType("GLchar const **") CharSequence string) { + return GL41C.glCreateShaderProgramv(type, string); + } + + // --- [ glBindProgramPipeline ] --- + + /** + * Binds a program pipeline to the current context. + * + * @param pipeline the name of the pipeline object to bind to the context + * + * @see Reference Page + */ + public static void glBindProgramPipeline(@NativeType("GLuint") int pipeline) { + GL41C.glBindProgramPipeline(pipeline); + } + + // --- [ glDeleteProgramPipelines ] --- + + /** + * Unsafe version of: {@link #glDeleteProgramPipelines DeleteProgramPipelines} + * + * @param n the number of program pipeline objects to delete + */ + public static void nglDeleteProgramPipelines(int n, long pipelines) { + GL41C.nglDeleteProgramPipelines(n, pipelines); + } + + /** + * Deletes program pipeline objects. + * + * @param pipelines an array of names of program pipeline objects to delete + * + * @see Reference Page + */ + public static void glDeleteProgramPipelines(@NativeType("GLuint const *") IntBuffer pipelines) { + GL41C.glDeleteProgramPipelines(pipelines); + } + + /** + * Deletes program pipeline objects. + * + * @see Reference Page + */ + public static void glDeleteProgramPipelines(@NativeType("GLuint const *") int pipeline) { + GL41C.glDeleteProgramPipelines(pipeline); + } + + // --- [ glGenProgramPipelines ] --- + + /** + * Unsafe version of: {@link #glGenProgramPipelines GenProgramPipelines} + * + * @param n the number of program pipeline object names to reserve + */ + public static void nglGenProgramPipelines(int n, long pipelines) { + GL41C.nglGenProgramPipelines(n, pipelines); + } + + /** + * Reserves program pipeline object names. + * + * @param pipelines an array of into which the reserved names will be written + * + * @see Reference Page + */ + public static void glGenProgramPipelines(@NativeType("GLuint *") IntBuffer pipelines) { + GL41C.glGenProgramPipelines(pipelines); + } + + /** + * Reserves program pipeline object names. + * + * @see Reference Page + */ + @NativeType("void") + public static int glGenProgramPipelines() { + return GL41C.glGenProgramPipelines(); + } + + // --- [ glIsProgramPipeline ] --- + + /** + * Determines if a name corresponds to a program pipeline object. + * + * @param pipeline a value that may be the name of a program pipeline object + * + * @see Reference Page + */ + @NativeType("GLboolean") + public static boolean glIsProgramPipeline(@NativeType("GLuint") int pipeline) { + return GL41C.glIsProgramPipeline(pipeline); + } + + // --- [ glGetProgramPipelineiv ] --- + + /** Unsafe version of: {@link #glGetProgramPipelineiv GetProgramPipelineiv} */ + public static void nglGetProgramPipelineiv(int pipeline, int pname, long params) { + GL41C.nglGetProgramPipelineiv(pipeline, pname, params); + } + + /** + * Retrieves properties of a program pipeline object. + * + * @param pipeline the name of a program pipeline object whose parameter retrieve + * @param pname the name of the parameter to retrieve. One of:| {@link GL41C#GL_ACTIVE_PROGRAM ACTIVE_PROGRAM} | {@link GL20#GL_INFO_LOG_LENGTH INFO_LOG_LENGTH} | {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} |
| {@link GL40#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} | {@link GL40#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL41C#GL_ACTIVE_PROGRAM ACTIVE_PROGRAM} | {@link GL20#GL_INFO_LOG_LENGTH INFO_LOG_LENGTH} | {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} |
| {@link GL40#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} | {@link GL40#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL11#GL_DOUBLE DOUBLE} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_DOUBLE DOUBLE} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_DOUBLE DOUBLE} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
OpenGL 4.1 implementations support revision 4.10 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} |
| {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} |
| {@link #GL_PROGRAM_BINARY_RETRIEVABLE_HINT PROGRAM_BINARY_RETRIEVABLE_HINT} | {@link #GL_PROGRAM_SEPARABLE PROGRAM_SEPARABLE} |
{@code glCreateShaderProgram} is equivalent (assuming no errors are generated) to:
+ * + *
+ * const GLuint shader = glCreateShader(type);
+ * if (shader) {
+ * glShaderSource(shader, count, strings, NULL);
+ * glCompileShader(shader);
+ * const GLuint program = glCreateProgram();
+ * if (program) {
+ * GLint compiled = GL_FALSE;
+ * glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+ * glProgramParameteri(program, GL_PROGRAM_SEPARABLE, GL_TRUE);
+ * if (compiled) {
+ * glAttachShader(program, shader);
+ * glLinkProgram(program);
+ * glDetachShader(program, shader);
+ * }
+ * // append-shader-info-log-to-program-info-log
+ * }
+ * glDeleteShader(shader);
+ * return program;
+ * } else {
+ * return 0;
+ * }The program object created by glCreateShaderProgram has its GL_PROGRAM_SEPARABLE status set to GL_TRUE.
+ * + * @param type the type of shader to create + * @param strings an array of pointers to source code strings from which to create the program object + * + * @see Reference Page + */ + @NativeType("GLuint") + public static int glCreateShaderProgramv(@NativeType("GLenum") int type, @NativeType("GLchar const **") PointerBuffer strings) { + return nglCreateShaderProgramv(type, strings.remaining(), memAddress(strings)); + } + + /** + * Creates a stand-alone program from an array of null-terminated source code strings. + * + *{@code glCreateShaderProgram} is equivalent (assuming no errors are generated) to:
+ * + *
+ * const GLuint shader = glCreateShader(type);
+ * if (shader) {
+ * glShaderSource(shader, count, strings, NULL);
+ * glCompileShader(shader);
+ * const GLuint program = glCreateProgram();
+ * if (program) {
+ * GLint compiled = GL_FALSE;
+ * glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+ * glProgramParameteri(program, GL_PROGRAM_SEPARABLE, GL_TRUE);
+ * if (compiled) {
+ * glAttachShader(program, shader);
+ * glLinkProgram(program);
+ * glDetachShader(program, shader);
+ * }
+ * // append-shader-info-log-to-program-info-log
+ * }
+ * glDeleteShader(shader);
+ * return program;
+ * } else {
+ * return 0;
+ * }The program object created by glCreateShaderProgram has its GL_PROGRAM_SEPARABLE status set to GL_TRUE.
+ * + * @param type the type of shader to create + * @param strings an array of pointers to source code strings from which to create the program object + * + * @see Reference Page + */ + @NativeType("GLuint") + public static int glCreateShaderProgramv(@NativeType("GLenum") int type, @NativeType("GLchar const **") CharSequence... strings) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + long stringsAddress = org.lwjgl.system.APIUtil.apiArray(stack, MemoryUtil::memUTF8, strings); + int __result = nglCreateShaderProgramv(type, strings.length, stringsAddress); + org.lwjgl.system.APIUtil.apiArrayFree(stringsAddress, strings.length); + return __result; + } finally { + stack.setPointer(stackPointer); + } + } + + /** + * Creates a stand-alone program from an array of null-terminated source code strings. + * + *{@code glCreateShaderProgram} is equivalent (assuming no errors are generated) to:
+ * + *
+ * const GLuint shader = glCreateShader(type);
+ * if (shader) {
+ * glShaderSource(shader, count, strings, NULL);
+ * glCompileShader(shader);
+ * const GLuint program = glCreateProgram();
+ * if (program) {
+ * GLint compiled = GL_FALSE;
+ * glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+ * glProgramParameteri(program, GL_PROGRAM_SEPARABLE, GL_TRUE);
+ * if (compiled) {
+ * glAttachShader(program, shader);
+ * glLinkProgram(program);
+ * glDetachShader(program, shader);
+ * }
+ * // append-shader-info-log-to-program-info-log
+ * }
+ * glDeleteShader(shader);
+ * return program;
+ * } else {
+ * return 0;
+ * }The program object created by glCreateShaderProgram has its GL_PROGRAM_SEPARABLE status set to GL_TRUE.
+ * + * @param type the type of shader to create + * + * @see Reference Page + */ + @NativeType("GLuint") + public static int glCreateShaderProgramv(@NativeType("GLenum") int type, @NativeType("GLchar const **") CharSequence string) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + long stringsAddress = org.lwjgl.system.APIUtil.apiArray(stack, MemoryUtil::memUTF8, string); + int __result = nglCreateShaderProgramv(type, 1, stringsAddress); + org.lwjgl.system.APIUtil.apiArrayFree(stringsAddress, 1); + return __result; + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glBindProgramPipeline ] --- + + /** + * Binds a program pipeline to the current context. + * + * @param pipeline the name of the pipeline object to bind to the context + * + * @see Reference Page + */ + public static native void glBindProgramPipeline(@NativeType("GLuint") int pipeline); + + // --- [ glDeleteProgramPipelines ] --- + + /** + * Unsafe version of: {@link #glDeleteProgramPipelines DeleteProgramPipelines} + * + * @param n the number of program pipeline objects to delete + */ + public static native void nglDeleteProgramPipelines(int n, long pipelines); + + /** + * Deletes program pipeline objects. + * + * @param pipelines an array of names of program pipeline objects to delete + * + * @see Reference Page + */ + public static void glDeleteProgramPipelines(@NativeType("GLuint const *") IntBuffer pipelines) { + nglDeleteProgramPipelines(pipelines.remaining(), memAddress(pipelines)); + } + + /** + * Deletes program pipeline objects. + * + * @see Reference Page + */ + public static void glDeleteProgramPipelines(@NativeType("GLuint const *") int pipeline) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer pipelines = stack.ints(pipeline); + nglDeleteProgramPipelines(1, memAddress(pipelines)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGenProgramPipelines ] --- + + /** + * Unsafe version of: {@link #glGenProgramPipelines GenProgramPipelines} + * + * @param n the number of program pipeline object names to reserve + */ + public static native void nglGenProgramPipelines(int n, long pipelines); + + /** + * Reserves program pipeline object names. + * + * @param pipelines an array of into which the reserved names will be written + * + * @see Reference Page + */ + public static void glGenProgramPipelines(@NativeType("GLuint *") IntBuffer pipelines) { + nglGenProgramPipelines(pipelines.remaining(), memAddress(pipelines)); + } + + /** + * Reserves program pipeline object names. + * + * @see Reference Page + */ + @NativeType("void") + public static int glGenProgramPipelines() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer pipelines = stack.callocInt(1); + nglGenProgramPipelines(1, memAddress(pipelines)); + return pipelines.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glIsProgramPipeline ] --- + + /** + * Determines if a name corresponds to a program pipeline object. + * + * @param pipeline a value that may be the name of a program pipeline object + * + * @see Reference Page + */ + @NativeType("GLboolean") + public static native boolean glIsProgramPipeline(@NativeType("GLuint") int pipeline); + + // --- [ glGetProgramPipelineiv ] --- + + /** Unsafe version of: {@link #glGetProgramPipelineiv GetProgramPipelineiv} */ + public static native void nglGetProgramPipelineiv(int pipeline, int pname, long params); + + /** + * Retrieves properties of a program pipeline object. + * + * @param pipeline the name of a program pipeline object whose parameter retrieve + * @param pname the name of the parameter to retrieve. One of:| {@link #GL_ACTIVE_PROGRAM ACTIVE_PROGRAM} | {@link GL20#GL_INFO_LOG_LENGTH INFO_LOG_LENGTH} | {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} |
| {@link GL40#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} | {@link GL40#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link #GL_ACTIVE_PROGRAM ACTIVE_PROGRAM} | {@link GL20#GL_INFO_LOG_LENGTH INFO_LOG_LENGTH} | {@link GL20#GL_VERTEX_SHADER VERTEX_SHADER} | {@link GL20#GL_FRAGMENT_SHADER FRAGMENT_SHADER} | {@link GL32#GL_GEOMETRY_SHADER GEOMETRY_SHADER} |
| {@link GL40#GL_TESS_CONTROL_SHADER TESS_CONTROL_SHADER} | {@link GL40#GL_TESS_EVALUATION_SHADER TESS_EVALUATION_SHADER} |
| {@link GL11#GL_DOUBLE DOUBLE} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_DOUBLE DOUBLE} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL11#GL_DOUBLE DOUBLE} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
OpenGL 4.2 implementations support revision 4.20 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE ATOMIC_COUNTER_BUFFER_DATA_SIZE} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE ATOMIC_COUNTER_BUFFER_DATA_SIZE} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER} |
| {@link GL42C#GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL42C#GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT VERTEX_ATTRIB_ARRAY_BARRIER_BIT} | {@link GL42C#GL_ELEMENT_ARRAY_BARRIER_BIT ELEMENT_ARRAY_BARRIER_BIT} | {@link GL42C#GL_UNIFORM_BARRIER_BIT UNIFORM_BARRIER_BIT} |
| {@link GL42C#GL_TEXTURE_FETCH_BARRIER_BIT TEXTURE_FETCH_BARRIER_BIT} | {@link GL42C#GL_SHADER_IMAGE_ACCESS_BARRIER_BIT SHADER_IMAGE_ACCESS_BARRIER_BIT} | {@link GL42C#GL_COMMAND_BARRIER_BIT COMMAND_BARRIER_BIT} |
| {@link GL42C#GL_PIXEL_BUFFER_BARRIER_BIT PIXEL_BUFFER_BARRIER_BIT} | {@link GL42C#GL_TEXTURE_UPDATE_BARRIER_BIT TEXTURE_UPDATE_BARRIER_BIT} | {@link GL42C#GL_BUFFER_UPDATE_BARRIER_BIT BUFFER_UPDATE_BARRIER_BIT} |
| {@link GL42C#GL_FRAMEBUFFER_BARRIER_BIT FRAMEBUFFER_BARRIER_BIT} | {@link GL42C#GL_TRANSFORM_FEEDBACK_BARRIER_BIT TRANSFORM_FEEDBACK_BARRIER_BIT} | {@link GL42C#GL_ATOMIC_COUNTER_BARRIER_BIT ATOMIC_COUNTER_BARRIER_BIT} |
| {@link GL42C#GL_ALL_BARRIER_BITS ALL_BARRIER_BITS} | {@link GL43#GL_SHADER_STORAGE_BARRIER_BIT SHADER_STORAGE_BARRIER_BIT} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
OpenGL 4.2 implementations support revision 4.20 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link #GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE ATOMIC_COUNTER_BUFFER_DATA_SIZE} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE ATOMIC_COUNTER_BUFFER_DATA_SIZE} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER} |
| {@link #GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_PROXY_TEXTURE_1D PROXY_TEXTURE_1D} |
| {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL11#GL_PROXY_TEXTURE_2D PROXY_TEXTURE_2D} | {@link GL30#GL_PROXY_TEXTURE_1D_ARRAY PROXY_TEXTURE_1D_ARRAY} | {@link GL31#GL_PROXY_TEXTURE_RECTANGLE PROXY_TEXTURE_RECTANGLE} | {@link GL13#GL_PROXY_TEXTURE_CUBE_MAP PROXY_TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL12#GL_PROXY_TEXTURE_3D PROXY_TEXTURE_3D} |
| {@link GL30#GL_PROXY_TEXTURE_2D_ARRAY PROXY_TEXTURE_2D_ARRAY} | {@link GL40#GL_PROXY_TEXTURE_CUBE_MAP_ARRAY PROXY_TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link #GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT VERTEX_ATTRIB_ARRAY_BARRIER_BIT} | {@link #GL_ELEMENT_ARRAY_BARRIER_BIT ELEMENT_ARRAY_BARRIER_BIT} | {@link #GL_UNIFORM_BARRIER_BIT UNIFORM_BARRIER_BIT} |
| {@link #GL_TEXTURE_FETCH_BARRIER_BIT TEXTURE_FETCH_BARRIER_BIT} | {@link #GL_SHADER_IMAGE_ACCESS_BARRIER_BIT SHADER_IMAGE_ACCESS_BARRIER_BIT} | {@link #GL_COMMAND_BARRIER_BIT COMMAND_BARRIER_BIT} |
| {@link #GL_PIXEL_BUFFER_BARRIER_BIT PIXEL_BUFFER_BARRIER_BIT} | {@link #GL_TEXTURE_UPDATE_BARRIER_BIT TEXTURE_UPDATE_BARRIER_BIT} | {@link #GL_BUFFER_UPDATE_BARRIER_BIT BUFFER_UPDATE_BARRIER_BIT} |
| {@link #GL_FRAMEBUFFER_BARRIER_BIT FRAMEBUFFER_BARRIER_BIT} | {@link #GL_TRANSFORM_FEEDBACK_BARRIER_BIT TRANSFORM_FEEDBACK_BARRIER_BIT} | {@link #GL_ATOMIC_COUNTER_BARRIER_BIT ATOMIC_COUNTER_BARRIER_BIT} |
| {@link #GL_ALL_BARRIER_BITS ALL_BARRIER_BITS} | {@link GL43#GL_SHADER_STORAGE_BARRIER_BIT SHADER_STORAGE_BARRIER_BIT} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
OpenGL 4.3 implementations support revision 4.30 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43C#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43C#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
The parameters addressed by indirect are packed a structure, which takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint num_groups_x;
+ * uint num_groups_y;
+ * uint num_groups_z;
+ * } DispatchIndirectCommand;A call to {@code glDispatchComputeIndirect} is equivalent, assuming no errors are generated, to:
+ * + *
+ * cmd = (const DispatchIndirectCommand *)indirect;
+ * glDispatchCompute(cmd->num_groups_x, cmd->num_groups_y, cmd->num_groups_z);If {@code enabled} is {@link GL11#GL_TRUE TRUE}, the referenced subset of messages will be enabled. If {@link GL11#GL_FALSE FALSE}, then those messages will be disabled.
+ * + *This command can reference different subsets of messages by first considering the set of all messages, and filtering out messages based on the following + * ways:
+ * + *Unrecognized message IDs in {@code ids} are ignored. If {@code count} is zero, the value if {@code ids} is ignored.
+ * + *Although messages are grouped into an implicit hierarchy by their sources and types, there is no explicit per-source, per-type or per-severity enabled + * state. Instead, the enabled state is stored individually for each message. There is no difference between disabling all messages from one source in a + * single call, and individually disabling all messages from that source using their types and IDs.
+ * + *If the {@link GL43C#GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled the GL operates the same as if messages of every {@code source}, {@code type} or {@code severity} are disabled.
+ * + * @param source the source of debug messages to enable or disable. One of:| {@link GL43C#GL_DEBUG_SOURCE_API DEBUG_SOURCE_API} | {@link GL43C#GL_DEBUG_SOURCE_WINDOW_SYSTEM DEBUG_SOURCE_WINDOW_SYSTEM} | {@link GL43C#GL_DEBUG_SOURCE_SHADER_COMPILER DEBUG_SOURCE_SHADER_COMPILER} |
| {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} | {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link GL43C#GL_DEBUG_SOURCE_OTHER DEBUG_SOURCE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_ERROR DEBUG_TYPE_ERROR} | {@link GL43C#GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR DEBUG_TYPE_DEPRECATED_BEHAVIOR} | {@link GL43C#GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR DEBUG_TYPE_UNDEFINED_BEHAVIOR} |
| {@link GL43C#GL_DEBUG_TYPE_PORTABILITY DEBUG_TYPE_PORTABILITY} | {@link GL43C#GL_DEBUG_TYPE_PERFORMANCE DEBUG_TYPE_PERFORMANCE} | {@link GL43C#GL_DEBUG_TYPE_OTHER DEBUG_TYPE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_MARKER DEBUG_TYPE_MARKER} |
| {@link GL43C#GL_DEBUG_SEVERITY_HIGH DEBUG_SEVERITY_HIGH} | {@link GL43C#GL_DEBUG_SEVERITY_MEDIUM DEBUG_SEVERITY_MEDIUM} | {@link GL43C#GL_DEBUG_SEVERITY_LOW DEBUG_SEVERITY_LOW} |
| {@link GL43C#GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION} |
If {@code enabled} is {@link GL11#GL_TRUE TRUE}, the referenced subset of messages will be enabled. If {@link GL11#GL_FALSE FALSE}, then those messages will be disabled.
+ * + *This command can reference different subsets of messages by first considering the set of all messages, and filtering out messages based on the following + * ways:
+ * + *Unrecognized message IDs in {@code ids} are ignored. If {@code count} is zero, the value if {@code ids} is ignored.
+ * + *Although messages are grouped into an implicit hierarchy by their sources and types, there is no explicit per-source, per-type or per-severity enabled + * state. Instead, the enabled state is stored individually for each message. There is no difference between disabling all messages from one source in a + * single call, and individually disabling all messages from that source using their types and IDs.
+ * + *If the {@link GL43C#GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled the GL operates the same as if messages of every {@code source}, {@code type} or {@code severity} are disabled.
+ * + * @param source the source of debug messages to enable or disable. One of:| {@link GL43C#GL_DEBUG_SOURCE_API DEBUG_SOURCE_API} | {@link GL43C#GL_DEBUG_SOURCE_WINDOW_SYSTEM DEBUG_SOURCE_WINDOW_SYSTEM} | {@link GL43C#GL_DEBUG_SOURCE_SHADER_COMPILER DEBUG_SOURCE_SHADER_COMPILER} |
| {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} | {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link GL43C#GL_DEBUG_SOURCE_OTHER DEBUG_SOURCE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_ERROR DEBUG_TYPE_ERROR} | {@link GL43C#GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR DEBUG_TYPE_DEPRECATED_BEHAVIOR} | {@link GL43C#GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR DEBUG_TYPE_UNDEFINED_BEHAVIOR} |
| {@link GL43C#GL_DEBUG_TYPE_PORTABILITY DEBUG_TYPE_PORTABILITY} | {@link GL43C#GL_DEBUG_TYPE_PERFORMANCE DEBUG_TYPE_PERFORMANCE} | {@link GL43C#GL_DEBUG_TYPE_OTHER DEBUG_TYPE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_MARKER DEBUG_TYPE_MARKER} |
| {@link GL43C#GL_DEBUG_SEVERITY_HIGH DEBUG_SEVERITY_HIGH} | {@link GL43C#GL_DEBUG_SEVERITY_MEDIUM DEBUG_SEVERITY_MEDIUM} | {@link GL43C#GL_DEBUG_SEVERITY_LOW DEBUG_SEVERITY_LOW} |
| {@link GL43C#GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION} |
The value of {@code id} specifies the ID for the message and {@code severity} indicates its severity level as defined by the caller. The string + * {@code buf} contains the string representation of the message. The parameter {@code length} contains the number of characters in {@code buf}. If + * {@code length} is negative, it is implied that {@code buf} contains a null terminated string. The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} will be generated if the + * number of characters in {@code buf}, excluding the null terminator when {@code length} is negative, is not less than the value of + * {@link GL43C#GL_MAX_DEBUG_MESSAGE_LENGTH MAX_DEBUG_MESSAGE_LENGTH}.
+ * + *If the {@link GL43C#GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled calls to DebugMessageInsert are discarded and do not generate an error.
+ * + * @param source the source of the debug message to insert. One of:| {@link GL43C#GL_DEBUG_SOURCE_API DEBUG_SOURCE_API} | {@link GL43C#GL_DEBUG_SOURCE_WINDOW_SYSTEM DEBUG_SOURCE_WINDOW_SYSTEM} | {@link GL43C#GL_DEBUG_SOURCE_SHADER_COMPILER DEBUG_SOURCE_SHADER_COMPILER} |
| {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} | {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link GL43C#GL_DEBUG_SOURCE_OTHER DEBUG_SOURCE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_ERROR DEBUG_TYPE_ERROR} | {@link GL43C#GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR DEBUG_TYPE_DEPRECATED_BEHAVIOR} | {@link GL43C#GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR DEBUG_TYPE_UNDEFINED_BEHAVIOR} |
| {@link GL43C#GL_DEBUG_TYPE_PORTABILITY DEBUG_TYPE_PORTABILITY} | {@link GL43C#GL_DEBUG_TYPE_PERFORMANCE DEBUG_TYPE_PERFORMANCE} | {@link GL43C#GL_DEBUG_TYPE_OTHER DEBUG_TYPE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_MARKER DEBUG_TYPE_MARKER} |
| {@link GL43C#GL_DEBUG_SEVERITY_HIGH DEBUG_SEVERITY_HIGH} | {@link GL43C#GL_DEBUG_SEVERITY_MEDIUM DEBUG_SEVERITY_MEDIUM} | {@link GL43C#GL_DEBUG_SEVERITY_LOW DEBUG_SEVERITY_LOW} |
| {@link GL43C#GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION} |
The value of {@code id} specifies the ID for the message and {@code severity} indicates its severity level as defined by the caller. The string + * {@code buf} contains the string representation of the message. The parameter {@code length} contains the number of characters in {@code buf}. If + * {@code length} is negative, it is implied that {@code buf} contains a null terminated string. The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} will be generated if the + * number of characters in {@code buf}, excluding the null terminator when {@code length} is negative, is not less than the value of + * {@link GL43C#GL_MAX_DEBUG_MESSAGE_LENGTH MAX_DEBUG_MESSAGE_LENGTH}.
+ * + *If the {@link GL43C#GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled calls to DebugMessageInsert are discarded and do not generate an error.
+ * + * @param source the source of the debug message to insert. One of:| {@link GL43C#GL_DEBUG_SOURCE_API DEBUG_SOURCE_API} | {@link GL43C#GL_DEBUG_SOURCE_WINDOW_SYSTEM DEBUG_SOURCE_WINDOW_SYSTEM} | {@link GL43C#GL_DEBUG_SOURCE_SHADER_COMPILER DEBUG_SOURCE_SHADER_COMPILER} |
| {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} | {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link GL43C#GL_DEBUG_SOURCE_OTHER DEBUG_SOURCE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_ERROR DEBUG_TYPE_ERROR} | {@link GL43C#GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR DEBUG_TYPE_DEPRECATED_BEHAVIOR} | {@link GL43C#GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR DEBUG_TYPE_UNDEFINED_BEHAVIOR} |
| {@link GL43C#GL_DEBUG_TYPE_PORTABILITY DEBUG_TYPE_PORTABILITY} | {@link GL43C#GL_DEBUG_TYPE_PERFORMANCE DEBUG_TYPE_PERFORMANCE} | {@link GL43C#GL_DEBUG_TYPE_OTHER DEBUG_TYPE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_MARKER DEBUG_TYPE_MARKER} |
| {@link GL43C#GL_DEBUG_SEVERITY_HIGH DEBUG_SEVERITY_HIGH} | {@link GL43C#GL_DEBUG_SEVERITY_MEDIUM DEBUG_SEVERITY_MEDIUM} | {@link GL43C#GL_DEBUG_SEVERITY_LOW DEBUG_SEVERITY_LOW} |
| {@link GL43C#GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION} |
The function's prototype must follow the type definition of DEBUGPROC including its platform-dependent calling convention. Anything else will result in + * undefined behavior. Only one debug callback can be specified for the current context, and further calls overwrite the previous callback. Specifying + * {@code NULL} as the value of {@code callback} clears the current callback and disables message output through callbacks. Applications can provide + * user-specified data through the pointer {@code userParam}. The context will store this pointer and will include it as one of the parameters in each call + * to the callback function.
+ * + *If the application has specified a callback function for receiving debug output, the implementation will call that function whenever any enabled message + * is generated. The source, type, ID, and severity of the message are specified by the DEBUGPROC parameters {@code source}, {@code type}, {@code id}, and + * {@code severity}, respectively. The string representation of the message is stored in {@code message} and its length (excluding the null-terminator) is + * stored in {@code length}. The parameter {@code userParam} is the user-specified parameter that was given when calling DebugMessageCallback.
+ * + *Applications can query the current callback function and the current user-specified parameter by obtaining the values of {@link GL43C#GL_DEBUG_CALLBACK_FUNCTION DEBUG_CALLBACK_FUNCTION} and + * {@link GL43C#GL_DEBUG_CALLBACK_USER_PARAM DEBUG_CALLBACK_USER_PARAM}, respectively.
+ * + *Applications that specify a callback function must be aware of certain special conditions when executing code inside a callback when it is called by the + * GL, regardless of the debug source.
+ * + *The memory for {@code message} is owned and managed by the GL, and should only be considered valid for the duration of the function call.
+ * + *The behavior of calling any GL or window system function from within the callback function is undefined and may lead to program termination.
+ * + *Care must also be taken in securing debug callbacks for use with asynchronous debug output by multi-threaded GL implementations.
+ * + *If the {@link GL43C#GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled then the GL will not call the callback function.
+ * + * @param callback a callback function that will be called when a debug message is generated + * @param userParam a user supplied pointer that will be passed on each invocation of {@code callback} + * + * @see Reference Page + */ + public static void glDebugMessageCallback(@Nullable @NativeType("GLDEBUGPROC") GLDebugMessageCallbackI callback, @NativeType("void const *") long userParam) { + GL43C.glDebugMessageCallback(callback, userParam); + } + + // --- [ glGetDebugMessageLog ] --- + + /** + * Unsafe version of: {@link #glGetDebugMessageLog GetDebugMessageLog} + * + * @param bufsize the size of the buffer whose address is given by {@code messageLog} + */ + public static int nglGetDebugMessageLog(int count, int bufsize, long sources, long types, long ids, long severities, long lengths, long messageLog) { + return GL43C.nglGetDebugMessageLog(count, bufsize, sources, types, ids, severities, lengths, messageLog); + } + + /** + * Retrieves messages from the debug message log. + * + *This function fetches a maximum of {@code count} messages from the message log, and will return the number of messages successfully fetched.
+ * + *Messages will be fetched from the log in order of oldest to newest. Those messages that were fetched will be removed from the log.
+ * + *The sources, types, severities, IDs, and string lengths of fetched messages will be stored in the application-provided arrays {@code sources}, + * {@code types}, {@code severities}, {@code ids}, and {@code lengths}, respectively. The application is responsible for allocating enough space for each + * array to hold up to {@code count} elements. The string representations of all fetched messages are stored in the {@code messageLog} array. If multiple + * messages are fetched, their strings are concatenated into the same {@code messageLog} array and will be separated by single null terminators. The last + * string in the array will also be null-terminated. The maximum size of {@code messageLog}, including the space used by all null terminators, is given by + * {@code bufSize}. If {@code bufSize} is less than zero and {@code messageLog} is not {@code NULL}, an {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error will be generated. If a message's + * string, including its null terminator, can not fully fit within the {@code messageLog} array's remaining space, then that message and any subsequent + * messages will not be fetched and will remain in the log. The string lengths stored in the array {@code lengths} include the space for the null + * terminator of each string.
+ * + *Any or all of the arrays {@code sources}, {@code types}, {@code ids}, {@code severities}, {@code lengths} and {@code messageLog} can also be null + * pointers, which causes the attributes for such arrays to be discarded when messages are fetched, however those messages will still be removed from the + * log. Thus to simply delete up to {@code count} messages from the message log while ignoring their attributes, the application can call the function + * with null pointers for all attribute arrays.
+ * + *If the context was created without the {@link GL43C#GL_CONTEXT_FLAG_DEBUG_BIT CONTEXT_FLAG_DEBUG_BIT} in the {@link GL30#GL_CONTEXT_FLAGS CONTEXT_FLAGS} state, then the GL can opt to never add messages to the + * message log so GetDebugMessageLog will always return zero.
+ * + * @param count the number of debug messages to retrieve from the log + * @param sources an array of variables to receive the sources of the retrieved messages + * @param types an array of variables to receive the types of the retrieved messages + * @param ids an array of unsigned integers to receive the ids of the retrieved messages + * @param severities an array of variables to receive the severites of the retrieved messages + * @param lengths an array of variables to receive the lengths of the received messages + * @param messageLog an array of characters that will receive the messages + * + * @see Reference Page + */ + @NativeType("GLuint") + public static int glGetDebugMessageLog(@NativeType("GLuint") int count, @Nullable @NativeType("GLenum *") IntBuffer sources, @Nullable @NativeType("GLenum *") IntBuffer types, @Nullable @NativeType("GLuint *") IntBuffer ids, @Nullable @NativeType("GLenum *") IntBuffer severities, @Nullable @NativeType("GLsizei *") IntBuffer lengths, @Nullable @NativeType("GLchar *") ByteBuffer messageLog) { + return GL43C.glGetDebugMessageLog(count, sources, types, ids, severities, lengths, messageLog); + } + + // --- [ glPushDebugGroup ] --- + + /** + * Unsafe version of: {@link #glPushDebugGroup PushDebugGroup} + * + * @param length the length of the message to be sent to the debug output stream + */ + public static void nglPushDebugGroup(int source, int id, int length, long message) { + GL43C.nglPushDebugGroup(source, id, length, message); + } + + /** + * Pushes a debug group described by the string {@code message} into the command stream. The value of {@code id} specifies the ID of messages generated. + * The parameter {@code length} contains the number of characters in {@code message}. If {@code length} is negative, it is implied that {@code message} + * contains a null terminated string. The message has the specified {@code source} and {@code id}, {@code type} {@link GL43C#GL_DEBUG_TYPE_PUSH_GROUP DEBUG_TYPE_PUSH_GROUP}, and + * {@code severity} {@link GL43C#GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION}. The GL will put a new debug group on top of the debug group stack which inherits the control of the + * volume of debug output of the debug group previously residing on the top of the debug group stack. Because debug groups are strictly hierarchical, any + * additional control of the debug output volume will only apply within the active debug group and the debug groups pushed on top of the active debug group. + * + *An {@link GL11#GL_INVALID_ENUM INVALID_ENUM} error is generated if the value of {@code source} is neither {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} nor {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY}. An + * {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if {@code length} is negative and the number of characters in {@code message}, excluding the null-terminator, is + * not less than the value of {@link GL43C#GL_MAX_DEBUG_MESSAGE_LENGTH MAX_DEBUG_MESSAGE_LENGTH}.
+ * + * @param source the source of the debug message. One of:| {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} |
An {@link GL11#GL_INVALID_ENUM INVALID_ENUM} error is generated if the value of {@code source} is neither {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} nor {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY}. An + * {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if {@code length} is negative and the number of characters in {@code message}, excluding the null-terminator, is + * not less than the value of {@link GL43C#GL_MAX_DEBUG_MESSAGE_LENGTH MAX_DEBUG_MESSAGE_LENGTH}.
+ * + * @param source the source of the debug message. One of:| {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} |
Attempting to pop the default debug group off the stack generates a {@link GL11#GL_STACK_UNDERFLOW STACK_UNDERFLOW} error; pushing a debug group onto a stack containing + * {@link GL43C#GL_MAX_DEBUG_GROUP_STACK_DEPTH MAX_DEBUG_GROUP_STACK_DEPTH} minus one elements will generate a {@link GL11#GL_STACK_OVERFLOW STACK_OVERFLOW} error.
+ * + * @see Reference Page + */ + public static void glPopDebugGroup() { + GL43C.glPopDebugGroup(); + } + + // --- [ glObjectLabel ] --- + + /** + * Unsafe version of: {@link #glObjectLabel ObjectLabel} + * + * @param length the length of the label to be used for the object + */ + public static void nglObjectLabel(int identifier, int name, int length, long label) { + GL43C.nglObjectLabel(identifier, name, length, label); + } + + /** + * Labels a named object identified within a namespace. + * + * @param identifier the namespace from which the name of the object is allocated. One of:| {@link GL43C#GL_BUFFER BUFFER} | {@link GL43C#GL_SHADER SHADER} | {@link GL43C#GL_PROGRAM PROGRAM} | {@link GL43C#GL_QUERY QUERY} | {@link GL43C#GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link GL43C#GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
| {@link GL43C#GL_BUFFER BUFFER} | {@link GL43C#GL_SHADER SHADER} | {@link GL43C#GL_PROGRAM PROGRAM} | {@link GL43C#GL_QUERY QUERY} | {@link GL43C#GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link GL43C#GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
| {@link GL43C#GL_BUFFER BUFFER} | {@link GL43C#GL_SHADER SHADER} | {@link GL43C#GL_PROGRAM PROGRAM} | {@link GL43C#GL_QUERY QUERY} | {@link GL43C#GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link GL43C#GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
| {@link GL43C#GL_BUFFER BUFFER} | {@link GL43C#GL_SHADER SHADER} | {@link GL43C#GL_PROGRAM PROGRAM} | {@link GL43C#GL_QUERY QUERY} | {@link GL43C#GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link GL43C#GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
| {@link GL43C#GL_BUFFER BUFFER} | {@link GL43C#GL_SHADER SHADER} | {@link GL43C#GL_PROGRAM PROGRAM} | {@link GL43C#GL_QUERY QUERY} | {@link GL43C#GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link GL43C#GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
| {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43C#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43C#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43C#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43C#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43C#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43C#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43C#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} |
The parameters addressed by {@code indirect} are packed into an array of structures, each element of which takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance;
+ * } DrawArraysIndirectCommand;A single call to {@code glMultiDrawArraysIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawArraysIndirect(mode, (DrawArraysIndirectCommand*)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawArraysIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
The parameters addressed by {@code indirect} are packed into an array of structures, each element of which takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance;
+ * } DrawArraysIndirectCommand;A single call to {@code glMultiDrawArraysIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawArraysIndirect(mode, (DrawArraysIndirectCommand*)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawArraysIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
The parameters addressed by {@code indirect} are packed into an array of structures, each element of which takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance;
+ * } DrawArraysIndirectCommand;A single call to {@code glMultiDrawArraysIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawArraysIndirect(mode, (DrawArraysIndirectCommand*)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawArraysIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
The parameters addressed by indirect are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;A single call to {@code glMultiDrawElementsIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawElementsIndirect(mode, type, (DrawElementsIndirectCommand *)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawElementsIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
The parameters addressed by indirect are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;A single call to {@code glMultiDrawElementsIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawElementsIndirect(mode, type, (DrawElementsIndirectCommand *)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawElementsIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
The parameters addressed by indirect are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;A single call to {@code glMultiDrawElementsIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawElementsIndirect(mode, type, (DrawElementsIndirectCommand *)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawElementsIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_ACTIVE_RESOURCES ACTIVE_RESOURCES} | {@link GL43C#GL_MAX_NAME_LENGTH MAX_NAME_LENGTH} | {@link GL43C#GL_MAX_NUM_ACTIVE_VARIABLES MAX_NUM_ACTIVE_VARIABLES} |
| {@link GL43C#GL_MAX_NUM_COMPATIBLE_SUBROUTINES MAX_NUM_COMPATIBLE_SUBROUTINES} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_ACTIVE_RESOURCES ACTIVE_RESOURCES} | {@link GL43C#GL_MAX_NAME_LENGTH MAX_NAME_LENGTH} | {@link GL43C#GL_MAX_NUM_ACTIVE_VARIABLES MAX_NUM_ACTIVE_VARIABLES} |
| {@link GL43C#GL_MAX_NUM_COMPATIBLE_SUBROUTINES MAX_NUM_COMPATIBLE_SUBROUTINES} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_UNIFORM UNIFORM} | {@link GL43C#GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link GL43C#GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link GL43C#GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link GL43C#GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link GL43C#GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link GL43C#GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link GL43C#GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link GL43C#GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link GL43C#GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link GL43C#GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link GL43C#GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link GL43C#GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} |
| {@link GL43C#GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} |
| {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
OpenGL 4.3 implementations support revision 4.30 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link #GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link #GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link #GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link #GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link #GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link #GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link #GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link #GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link #GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link #GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link #GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link #GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link #GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link #GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link #GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link #GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
The parameters addressed by indirect are packed a structure, which takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint num_groups_x;
+ * uint num_groups_y;
+ * uint num_groups_z;
+ * } DispatchIndirectCommand;A call to {@code glDispatchComputeIndirect} is equivalent, assuming no errors are generated, to:
+ * + *
+ * cmd = (const DispatchIndirectCommand *)indirect;
+ * glDispatchCompute(cmd->num_groups_x, cmd->num_groups_y, cmd->num_groups_z);If {@code enabled} is {@link GL11#GL_TRUE TRUE}, the referenced subset of messages will be enabled. If {@link GL11#GL_FALSE FALSE}, then those messages will be disabled.
+ * + *This command can reference different subsets of messages by first considering the set of all messages, and filtering out messages based on the following + * ways:
+ * + *Unrecognized message IDs in {@code ids} are ignored. If {@code count} is zero, the value if {@code ids} is ignored.
+ * + *Although messages are grouped into an implicit hierarchy by their sources and types, there is no explicit per-source, per-type or per-severity enabled + * state. Instead, the enabled state is stored individually for each message. There is no difference between disabling all messages from one source in a + * single call, and individually disabling all messages from that source using their types and IDs.
+ * + *If the {@link #GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled the GL operates the same as if messages of every {@code source}, {@code type} or {@code severity} are disabled.
+ * + * @param source the source of debug messages to enable or disable. One of:| {@link #GL_DEBUG_SOURCE_API DEBUG_SOURCE_API} | {@link #GL_DEBUG_SOURCE_WINDOW_SYSTEM DEBUG_SOURCE_WINDOW_SYSTEM} | {@link #GL_DEBUG_SOURCE_SHADER_COMPILER DEBUG_SOURCE_SHADER_COMPILER} |
| {@link #GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} | {@link #GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link #GL_DEBUG_SOURCE_OTHER DEBUG_SOURCE_OTHER} |
| {@link #GL_DEBUG_TYPE_ERROR DEBUG_TYPE_ERROR} | {@link #GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR DEBUG_TYPE_DEPRECATED_BEHAVIOR} | {@link #GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR DEBUG_TYPE_UNDEFINED_BEHAVIOR} |
| {@link #GL_DEBUG_TYPE_PORTABILITY DEBUG_TYPE_PORTABILITY} | {@link #GL_DEBUG_TYPE_PERFORMANCE DEBUG_TYPE_PERFORMANCE} | {@link #GL_DEBUG_TYPE_OTHER DEBUG_TYPE_OTHER} |
| {@link #GL_DEBUG_TYPE_MARKER DEBUG_TYPE_MARKER} |
| {@link #GL_DEBUG_SEVERITY_HIGH DEBUG_SEVERITY_HIGH} | {@link #GL_DEBUG_SEVERITY_MEDIUM DEBUG_SEVERITY_MEDIUM} | {@link #GL_DEBUG_SEVERITY_LOW DEBUG_SEVERITY_LOW} |
| {@link #GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION} |
If {@code enabled} is {@link GL11#GL_TRUE TRUE}, the referenced subset of messages will be enabled. If {@link GL11#GL_FALSE FALSE}, then those messages will be disabled.
+ * + *This command can reference different subsets of messages by first considering the set of all messages, and filtering out messages based on the following + * ways:
+ * + *Unrecognized message IDs in {@code ids} are ignored. If {@code count} is zero, the value if {@code ids} is ignored.
+ * + *Although messages are grouped into an implicit hierarchy by their sources and types, there is no explicit per-source, per-type or per-severity enabled + * state. Instead, the enabled state is stored individually for each message. There is no difference between disabling all messages from one source in a + * single call, and individually disabling all messages from that source using their types and IDs.
+ * + *If the {@link #GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled the GL operates the same as if messages of every {@code source}, {@code type} or {@code severity} are disabled.
+ * + * @param source the source of debug messages to enable or disable. One of:| {@link #GL_DEBUG_SOURCE_API DEBUG_SOURCE_API} | {@link #GL_DEBUG_SOURCE_WINDOW_SYSTEM DEBUG_SOURCE_WINDOW_SYSTEM} | {@link #GL_DEBUG_SOURCE_SHADER_COMPILER DEBUG_SOURCE_SHADER_COMPILER} |
| {@link #GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} | {@link #GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link #GL_DEBUG_SOURCE_OTHER DEBUG_SOURCE_OTHER} |
| {@link #GL_DEBUG_TYPE_ERROR DEBUG_TYPE_ERROR} | {@link #GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR DEBUG_TYPE_DEPRECATED_BEHAVIOR} | {@link #GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR DEBUG_TYPE_UNDEFINED_BEHAVIOR} |
| {@link #GL_DEBUG_TYPE_PORTABILITY DEBUG_TYPE_PORTABILITY} | {@link #GL_DEBUG_TYPE_PERFORMANCE DEBUG_TYPE_PERFORMANCE} | {@link #GL_DEBUG_TYPE_OTHER DEBUG_TYPE_OTHER} |
| {@link #GL_DEBUG_TYPE_MARKER DEBUG_TYPE_MARKER} |
| {@link #GL_DEBUG_SEVERITY_HIGH DEBUG_SEVERITY_HIGH} | {@link #GL_DEBUG_SEVERITY_MEDIUM DEBUG_SEVERITY_MEDIUM} | {@link #GL_DEBUG_SEVERITY_LOW DEBUG_SEVERITY_LOW} |
| {@link #GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION} |
The value of {@code id} specifies the ID for the message and {@code severity} indicates its severity level as defined by the caller. The string + * {@code buf} contains the string representation of the message. The parameter {@code length} contains the number of characters in {@code buf}. If + * {@code length} is negative, it is implied that {@code buf} contains a null terminated string. The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} will be generated if the + * number of characters in {@code buf}, excluding the null terminator when {@code length} is negative, is not less than the value of + * {@link #GL_MAX_DEBUG_MESSAGE_LENGTH MAX_DEBUG_MESSAGE_LENGTH}.
+ * + *If the {@link #GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled calls to DebugMessageInsert are discarded and do not generate an error.
+ * + * @param source the source of the debug message to insert. One of:| {@link #GL_DEBUG_SOURCE_API DEBUG_SOURCE_API} | {@link #GL_DEBUG_SOURCE_WINDOW_SYSTEM DEBUG_SOURCE_WINDOW_SYSTEM} | {@link #GL_DEBUG_SOURCE_SHADER_COMPILER DEBUG_SOURCE_SHADER_COMPILER} |
| {@link #GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} | {@link #GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link #GL_DEBUG_SOURCE_OTHER DEBUG_SOURCE_OTHER} |
| {@link #GL_DEBUG_TYPE_ERROR DEBUG_TYPE_ERROR} | {@link #GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR DEBUG_TYPE_DEPRECATED_BEHAVIOR} | {@link #GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR DEBUG_TYPE_UNDEFINED_BEHAVIOR} |
| {@link #GL_DEBUG_TYPE_PORTABILITY DEBUG_TYPE_PORTABILITY} | {@link #GL_DEBUG_TYPE_PERFORMANCE DEBUG_TYPE_PERFORMANCE} | {@link #GL_DEBUG_TYPE_OTHER DEBUG_TYPE_OTHER} |
| {@link #GL_DEBUG_TYPE_MARKER DEBUG_TYPE_MARKER} |
| {@link #GL_DEBUG_SEVERITY_HIGH DEBUG_SEVERITY_HIGH} | {@link #GL_DEBUG_SEVERITY_MEDIUM DEBUG_SEVERITY_MEDIUM} | {@link #GL_DEBUG_SEVERITY_LOW DEBUG_SEVERITY_LOW} |
| {@link #GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION} |
The value of {@code id} specifies the ID for the message and {@code severity} indicates its severity level as defined by the caller. The string + * {@code buf} contains the string representation of the message. The parameter {@code length} contains the number of characters in {@code buf}. If + * {@code length} is negative, it is implied that {@code buf} contains a null terminated string. The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} will be generated if the + * number of characters in {@code buf}, excluding the null terminator when {@code length} is negative, is not less than the value of + * {@link #GL_MAX_DEBUG_MESSAGE_LENGTH MAX_DEBUG_MESSAGE_LENGTH}.
+ * + *If the {@link #GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled calls to DebugMessageInsert are discarded and do not generate an error.
+ * + * @param source the source of the debug message to insert. One of:| {@link #GL_DEBUG_SOURCE_API DEBUG_SOURCE_API} | {@link #GL_DEBUG_SOURCE_WINDOW_SYSTEM DEBUG_SOURCE_WINDOW_SYSTEM} | {@link #GL_DEBUG_SOURCE_SHADER_COMPILER DEBUG_SOURCE_SHADER_COMPILER} |
| {@link #GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} | {@link #GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link #GL_DEBUG_SOURCE_OTHER DEBUG_SOURCE_OTHER} |
| {@link #GL_DEBUG_TYPE_ERROR DEBUG_TYPE_ERROR} | {@link #GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR DEBUG_TYPE_DEPRECATED_BEHAVIOR} | {@link #GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR DEBUG_TYPE_UNDEFINED_BEHAVIOR} |
| {@link #GL_DEBUG_TYPE_PORTABILITY DEBUG_TYPE_PORTABILITY} | {@link #GL_DEBUG_TYPE_PERFORMANCE DEBUG_TYPE_PERFORMANCE} | {@link #GL_DEBUG_TYPE_OTHER DEBUG_TYPE_OTHER} |
| {@link #GL_DEBUG_TYPE_MARKER DEBUG_TYPE_MARKER} |
| {@link #GL_DEBUG_SEVERITY_HIGH DEBUG_SEVERITY_HIGH} | {@link #GL_DEBUG_SEVERITY_MEDIUM DEBUG_SEVERITY_MEDIUM} | {@link #GL_DEBUG_SEVERITY_LOW DEBUG_SEVERITY_LOW} |
| {@link #GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION} |
The function's prototype must follow the type definition of DEBUGPROC including its platform-dependent calling convention. Anything else will result in + * undefined behavior. Only one debug callback can be specified for the current context, and further calls overwrite the previous callback. Specifying + * {@code NULL} as the value of {@code callback} clears the current callback and disables message output through callbacks. Applications can provide + * user-specified data through the pointer {@code userParam}. The context will store this pointer and will include it as one of the parameters in each call + * to the callback function.
+ * + *If the application has specified a callback function for receiving debug output, the implementation will call that function whenever any enabled message + * is generated. The source, type, ID, and severity of the message are specified by the DEBUGPROC parameters {@code source}, {@code type}, {@code id}, and + * {@code severity}, respectively. The string representation of the message is stored in {@code message} and its length (excluding the null-terminator) is + * stored in {@code length}. The parameter {@code userParam} is the user-specified parameter that was given when calling DebugMessageCallback.
+ * + *Applications can query the current callback function and the current user-specified parameter by obtaining the values of {@link #GL_DEBUG_CALLBACK_FUNCTION DEBUG_CALLBACK_FUNCTION} and + * {@link #GL_DEBUG_CALLBACK_USER_PARAM DEBUG_CALLBACK_USER_PARAM}, respectively.
+ * + *Applications that specify a callback function must be aware of certain special conditions when executing code inside a callback when it is called by the + * GL, regardless of the debug source.
+ * + *The memory for {@code message} is owned and managed by the GL, and should only be considered valid for the duration of the function call.
+ * + *The behavior of calling any GL or window system function from within the callback function is undefined and may lead to program termination.
+ * + *Care must also be taken in securing debug callbacks for use with asynchronous debug output by multi-threaded GL implementations.
+ * + *If the {@link #GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled then the GL will not call the callback function.
+ * + * @param callback a callback function that will be called when a debug message is generated + * @param userParam a user supplied pointer that will be passed on each invocation of {@code callback} + * + * @see Reference Page + */ + public static void glDebugMessageCallback(@Nullable @NativeType("GLDEBUGPROC") GLDebugMessageCallbackI callback, @NativeType("void const *") long userParam) { + nglDebugMessageCallback(memAddressSafe(callback), userParam); + } + + // --- [ glGetDebugMessageLog ] --- + + /** + * Unsafe version of: {@link #glGetDebugMessageLog GetDebugMessageLog} + * + * @param bufsize the size of the buffer whose address is given by {@code messageLog} + */ + public static native int nglGetDebugMessageLog(int count, int bufsize, long sources, long types, long ids, long severities, long lengths, long messageLog); + + /** + * Retrieves messages from the debug message log. + * + *This function fetches a maximum of {@code count} messages from the message log, and will return the number of messages successfully fetched.
+ * + *Messages will be fetched from the log in order of oldest to newest. Those messages that were fetched will be removed from the log.
+ * + *The sources, types, severities, IDs, and string lengths of fetched messages will be stored in the application-provided arrays {@code sources}, + * {@code types}, {@code severities}, {@code ids}, and {@code lengths}, respectively. The application is responsible for allocating enough space for each + * array to hold up to {@code count} elements. The string representations of all fetched messages are stored in the {@code messageLog} array. If multiple + * messages are fetched, their strings are concatenated into the same {@code messageLog} array and will be separated by single null terminators. The last + * string in the array will also be null-terminated. The maximum size of {@code messageLog}, including the space used by all null terminators, is given by + * {@code bufSize}. If {@code bufSize} is less than zero and {@code messageLog} is not {@code NULL}, an {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error will be generated. If a message's + * string, including its null terminator, can not fully fit within the {@code messageLog} array's remaining space, then that message and any subsequent + * messages will not be fetched and will remain in the log. The string lengths stored in the array {@code lengths} include the space for the null + * terminator of each string.
+ * + *Any or all of the arrays {@code sources}, {@code types}, {@code ids}, {@code severities}, {@code lengths} and {@code messageLog} can also be null + * pointers, which causes the attributes for such arrays to be discarded when messages are fetched, however those messages will still be removed from the + * log. Thus to simply delete up to {@code count} messages from the message log while ignoring their attributes, the application can call the function + * with null pointers for all attribute arrays.
+ * + *If the context was created without the {@link #GL_CONTEXT_FLAG_DEBUG_BIT CONTEXT_FLAG_DEBUG_BIT} in the {@link GL30#GL_CONTEXT_FLAGS CONTEXT_FLAGS} state, then the GL can opt to never add messages to the + * message log so GetDebugMessageLog will always return zero.
+ * + * @param count the number of debug messages to retrieve from the log + * @param sources an array of variables to receive the sources of the retrieved messages + * @param types an array of variables to receive the types of the retrieved messages + * @param ids an array of unsigned integers to receive the ids of the retrieved messages + * @param severities an array of variables to receive the severites of the retrieved messages + * @param lengths an array of variables to receive the lengths of the received messages + * @param messageLog an array of characters that will receive the messages + * + * @see Reference Page + */ + @NativeType("GLuint") + public static int glGetDebugMessageLog(@NativeType("GLuint") int count, @Nullable @NativeType("GLenum *") IntBuffer sources, @Nullable @NativeType("GLenum *") IntBuffer types, @Nullable @NativeType("GLuint *") IntBuffer ids, @Nullable @NativeType("GLenum *") IntBuffer severities, @Nullable @NativeType("GLsizei *") IntBuffer lengths, @Nullable @NativeType("GLchar *") ByteBuffer messageLog) { + if (CHECKS) { + checkSafe(sources, count); + checkSafe(types, count); + checkSafe(ids, count); + checkSafe(severities, count); + checkSafe(lengths, count); + } + return nglGetDebugMessageLog(count, remainingSafe(messageLog), memAddressSafe(sources), memAddressSafe(types), memAddressSafe(ids), memAddressSafe(severities), memAddressSafe(lengths), memAddressSafe(messageLog)); + } + + // --- [ glPushDebugGroup ] --- + + /** + * Unsafe version of: {@link #glPushDebugGroup PushDebugGroup} + * + * @param length the length of the message to be sent to the debug output stream + */ + public static native void nglPushDebugGroup(int source, int id, int length, long message); + + /** + * Pushes a debug group described by the string {@code message} into the command stream. The value of {@code id} specifies the ID of messages generated. + * The parameter {@code length} contains the number of characters in {@code message}. If {@code length} is negative, it is implied that {@code message} + * contains a null terminated string. The message has the specified {@code source} and {@code id}, {@code type} {@link #GL_DEBUG_TYPE_PUSH_GROUP DEBUG_TYPE_PUSH_GROUP}, and + * {@code severity} {@link #GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION}. The GL will put a new debug group on top of the debug group stack which inherits the control of the + * volume of debug output of the debug group previously residing on the top of the debug group stack. Because debug groups are strictly hierarchical, any + * additional control of the debug output volume will only apply within the active debug group and the debug groups pushed on top of the active debug group. + * + *An {@link GL11#GL_INVALID_ENUM INVALID_ENUM} error is generated if the value of {@code source} is neither {@link #GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} nor {@link #GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY}. An + * {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if {@code length} is negative and the number of characters in {@code message}, excluding the null-terminator, is + * not less than the value of {@link #GL_MAX_DEBUG_MESSAGE_LENGTH MAX_DEBUG_MESSAGE_LENGTH}.
+ * + * @param source the source of the debug message. One of:| {@link #GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link #GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} |
An {@link GL11#GL_INVALID_ENUM INVALID_ENUM} error is generated if the value of {@code source} is neither {@link #GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} nor {@link #GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY}. An + * {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if {@code length} is negative and the number of characters in {@code message}, excluding the null-terminator, is + * not less than the value of {@link #GL_MAX_DEBUG_MESSAGE_LENGTH MAX_DEBUG_MESSAGE_LENGTH}.
+ * + * @param source the source of the debug message. One of:| {@link #GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link #GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} |
Attempting to pop the default debug group off the stack generates a {@link GL11#GL_STACK_UNDERFLOW STACK_UNDERFLOW} error; pushing a debug group onto a stack containing + * {@link #GL_MAX_DEBUG_GROUP_STACK_DEPTH MAX_DEBUG_GROUP_STACK_DEPTH} minus one elements will generate a {@link GL11#GL_STACK_OVERFLOW STACK_OVERFLOW} error.
+ * + * @see Reference Page + */ + public static native void glPopDebugGroup(); + + // --- [ glObjectLabel ] --- + + /** + * Unsafe version of: {@link #glObjectLabel ObjectLabel} + * + * @param length the length of the label to be used for the object + */ + public static native void nglObjectLabel(int identifier, int name, int length, long label); + + /** + * Labels a named object identified within a namespace. + * + * @param identifier the namespace from which the name of the object is allocated. One of:| {@link #GL_BUFFER BUFFER} | {@link #GL_SHADER SHADER} | {@link #GL_PROGRAM PROGRAM} | {@link #GL_QUERY QUERY} | {@link #GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link #GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
| {@link #GL_BUFFER BUFFER} | {@link #GL_SHADER SHADER} | {@link #GL_PROGRAM PROGRAM} | {@link #GL_QUERY QUERY} | {@link #GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link #GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
| {@link #GL_BUFFER BUFFER} | {@link #GL_SHADER SHADER} | {@link #GL_PROGRAM PROGRAM} | {@link #GL_QUERY QUERY} | {@link #GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link #GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
| {@link #GL_BUFFER BUFFER} | {@link #GL_SHADER SHADER} | {@link #GL_PROGRAM PROGRAM} | {@link #GL_QUERY QUERY} | {@link #GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link #GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
| {@link #GL_BUFFER BUFFER} | {@link #GL_SHADER SHADER} | {@link #GL_PROGRAM PROGRAM} | {@link #GL_QUERY QUERY} | {@link #GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link #GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
| {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} |
| {@link #GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link #GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link #GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link #GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link #GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} |
| {@link #GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link #GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link #GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link #GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link #GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} |
| {@link #GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link #GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link #GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link #GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link #GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} |
The parameters addressed by {@code indirect} are packed into an array of structures, each element of which takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance;
+ * } DrawArraysIndirectCommand;A single call to {@code glMultiDrawArraysIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawArraysIndirect(mode, (DrawArraysIndirectCommand*)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawArraysIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
The parameters addressed by {@code indirect} are packed into an array of structures, each element of which takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance;
+ * } DrawArraysIndirectCommand;A single call to {@code glMultiDrawArraysIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawArraysIndirect(mode, (DrawArraysIndirectCommand*)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawArraysIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
The parameters addressed by {@code indirect} are packed into an array of structures, each element of which takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint first;
+ * uint baseInstance;
+ * } DrawArraysIndirectCommand;A single call to {@code glMultiDrawArraysIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawArraysIndirect(mode, (DrawArraysIndirectCommand*)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawArraysIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
The parameters addressed by indirect are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;A single call to {@code glMultiDrawElementsIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawElementsIndirect(mode, type, (DrawElementsIndirectCommand *)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawElementsIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
The parameters addressed by indirect are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;A single call to {@code glMultiDrawElementsIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawElementsIndirect(mode, type, (DrawElementsIndirectCommand *)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawElementsIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
The parameters addressed by indirect are packed into a structure that takes the form (in C):
+ * + *
+ * typedef struct {
+ * uint count;
+ * uint primCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsIndirectCommand;A single call to {@code glMultiDrawElementsIndirect} is equivalent, assuming no errors are generated to:
+ * + *
+ * const ubyte *ptr = (const ubyte *)indirect;
+ * for ( i = 0; i < drawcount; i++ ) {
+ * DrawElementsIndirect(mode, type, (DrawElementsIndirectCommand *)ptr);
+ * if ( stride == 0 )
+ * ptr += sizeof(DrawElementsIndirectCommand);
+ * else
+ * ptr += stride;
+ * }| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link #GL_UNIFORM UNIFORM} | {@link #GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link #GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link #GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link #GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link #GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link #GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link #GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link #GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link #GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link #GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link #GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link #GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link #GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link #GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link #GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link #GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link #GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link #GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link #GL_ACTIVE_RESOURCES ACTIVE_RESOURCES} | {@link #GL_MAX_NAME_LENGTH MAX_NAME_LENGTH} | {@link #GL_MAX_NUM_ACTIVE_VARIABLES MAX_NUM_ACTIVE_VARIABLES} |
| {@link #GL_MAX_NUM_COMPATIBLE_SUBROUTINES MAX_NUM_COMPATIBLE_SUBROUTINES} |
| {@link #GL_UNIFORM UNIFORM} | {@link #GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link #GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link #GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link #GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link #GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link #GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link #GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link #GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link #GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link #GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link #GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link #GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link #GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link #GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link #GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link #GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link #GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link #GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link #GL_ACTIVE_RESOURCES ACTIVE_RESOURCES} | {@link #GL_MAX_NAME_LENGTH MAX_NAME_LENGTH} | {@link #GL_MAX_NUM_ACTIVE_VARIABLES MAX_NUM_ACTIVE_VARIABLES} |
| {@link #GL_MAX_NUM_COMPATIBLE_SUBROUTINES MAX_NUM_COMPATIBLE_SUBROUTINES} |
| {@link #GL_UNIFORM UNIFORM} | {@link #GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link #GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link #GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link #GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link #GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link #GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link #GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link #GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link #GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link #GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link #GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link #GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link #GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link #GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link #GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link #GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link #GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link #GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link #GL_UNIFORM UNIFORM} | {@link #GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link #GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link #GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link #GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link #GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link #GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link #GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link #GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link #GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link #GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link #GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link #GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link #GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link #GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link #GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link #GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link #GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link #GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link #GL_UNIFORM UNIFORM} | {@link #GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link #GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link #GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link #GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link #GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link #GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link #GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link #GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link #GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link #GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link #GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link #GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link #GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link #GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link #GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link #GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link #GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link #GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link #GL_UNIFORM UNIFORM} | {@link #GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link #GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link #GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link #GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link #GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link #GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link #GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link #GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link #GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link #GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link #GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link #GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link #GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link #GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link #GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link #GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link #GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link #GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link #GL_UNIFORM UNIFORM} | {@link #GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link #GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link #GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link #GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link #GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link #GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link #GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link #GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link #GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link #GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link #GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link #GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link #GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link #GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link #GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link #GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link #GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link #GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link #GL_UNIFORM UNIFORM} | {@link #GL_UNIFORM_BLOCK UNIFORM_BLOCK} | {@link #GL_PROGRAM_INPUT PROGRAM_INPUT} |
| {@link #GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} | {@link #GL_BUFFER_VARIABLE BUFFER_VARIABLE} | {@link #GL_SHADER_STORAGE_BLOCK SHADER_STORAGE_BLOCK} |
| {@link #GL_VERTEX_SUBROUTINE VERTEX_SUBROUTINE} | {@link #GL_TESS_CONTROL_SUBROUTINE TESS_CONTROL_SUBROUTINE} | {@link #GL_TESS_EVALUATION_SUBROUTINE TESS_EVALUATION_SUBROUTINE} |
| {@link #GL_GEOMETRY_SUBROUTINE GEOMETRY_SUBROUTINE} | {@link #GL_FRAGMENT_SUBROUTINE FRAGMENT_SUBROUTINE} | {@link #GL_COMPUTE_SUBROUTINE COMPUTE_SUBROUTINE} |
| {@link #GL_VERTEX_SUBROUTINE_UNIFORM VERTEX_SUBROUTINE_UNIFORM} | {@link #GL_TESS_CONTROL_SUBROUTINE_UNIFORM TESS_CONTROL_SUBROUTINE_UNIFORM} | {@link #GL_TESS_EVALUATION_SUBROUTINE_UNIFORM TESS_EVALUATION_SUBROUTINE_UNIFORM} |
| {@link #GL_GEOMETRY_SUBROUTINE_UNIFORM GEOMETRY_SUBROUTINE_UNIFORM} | {@link #GL_FRAGMENT_SUBROUTINE_UNIFORM FRAGMENT_SUBROUTINE_UNIFORM} | {@link #GL_COMPUTE_SUBROUTINE_UNIFORM COMPUTE_SUBROUTINE_UNIFORM} |
| {@link #GL_TRANSFORM_FEEDBACK_VARYING TRANSFORM_FEEDBACK_VARYING} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} |
| {@link #GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} |
| {@link #GL_PROGRAM_OUTPUT PROGRAM_OUTPUT} |
| {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} | {@link GL32#GL_PROXY_TEXTURE_2D_MULTISAMPLE PROXY_TEXTURE_2D_MULTISAMPLE} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
OpenGL 4.4 implementations support revision 4.40 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44C#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("GLsizeiptr") long size, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, size, flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44C#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") ByteBuffer data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44C#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") ShortBuffer data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44C#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") IntBuffer data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44C#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") FloatBuffer data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44C#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44C#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") DoubleBuffer data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + // --- [ glClearTexSubImage ] --- + + /** Unsafe version of: {@link #glClearTexSubImage ClearTexSubImage} */ + public static void nglClearTexSubImage(int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int format, int type, long data) { + GL44C.nglClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); + } + + /** + * Fills all or part of a texture image with a constant value. + * + *Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
+ * for ( i = 0; i < count; i++ ) {
+ * if ( buffers == NULL ) {
+ * glBindBufferBase(target, first + i, 0);
+ * } else {
+ * glBindBufferBase(target, first + i, buffers[i]);
+ * }
+ * }except that the single general buffer binding corresponding to {@code target} is unmodified, and that buffers will not be created if they do not exist.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
+ * for ( i = 0; i < count; i++ ) {
+ * if ( buffers == NULL ) {
+ * glBindBufferRange(target, first + i, 0, 0, 0);
+ * } else {
+ * glBindBufferRange(target, first + i, buffers[i], offsets[i], sizes[i]);
+ * }
+ * }except that the single general buffer binding corresponding to {@code target} is unmodified, and that buffers will not be created if they do not exist.
+ * + *The values specified in {@code buffers}, {@code offsets}, and {@code sizes} will be checked separately for each binding point. When values for a + * specific binding point are invalid, the state for that binding point will be unchanged and an error will be generated. However, state for other binding + * points will still be changed if their corresponding values are valid.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
{@code BindTextures} is equivalent to:
+ * + *
+ * for ( i = 0; i < count; i++ ) {
+ * uint texture;
+ * if ( textures == NULL ) {
+ * texture = 0;
+ * } else {
+ * texture = textures[i];
+ * }
+ * ActiveTexture(TEXTURE0 + first + i);
+ * if ( texture != 0 ) {
+ * enum target; // target of texture object textures[i]
+ * BindTexture(target, textures[i]);
+ * } else {
+ * for ( target in all supported targets ) {
+ * BindTexture(target, 0);
+ * }
+ * }
+ * }except that the active texture selector retains its original value upon completion of the command, and that textures will not be created if they do not + * exist.
+ * + *The values specified in {@code textures} will be checked separately for each texture image unit. When a value for a specific texture image unit is + * invalid, the state for that texture image unit will be unchanged and an error will be generated. However, state for other texture image units will still + * be changed if their corresponding values are valid.
+ * + * @param first the first texture objects + * @param textures an array of zeros or names of existing texture objects + * + * @see Reference Page + */ + public static void glBindTextures(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") IntBuffer textures) { + GL44C.glBindTextures(first, textures); + } + + // --- [ glBindSamplers ] --- + + /** + * Unsafe version of: {@link #glBindSamplers BindSamplers} + * + * @param count the number of sampler objects + */ + public static void nglBindSamplers(int first, int count, long samplers) { + GL44C.nglBindSamplers(first, count, samplers); + } + + /** + * Binds {@code count} existing sampler objects to texture image units numbered {@code first} through {@code first+count-1}. If {@code samplers} is not + * {@code NULL}, it specifies an array of {@code count} values, each of which must be zero or the name of an existing sampler object. If {@code samplers} is {@code NULL}, + * each affected texture image unit from {@code first} through {@code first+count-1} will be reset to have no bound sampler object. + * + *{@code BindSamplers} is equivalent to:
+ * + *
+ * for ( i = 0; i < count; i++ ) {
+ * if ( samplers == NULL ) {
+ * glBindSampler(first + i, 0);
+ * } else {
+ * glBindSampler(first + i, samplers[i]);
+ * }
+ * }The values specified in {@code samplers} will be checked separately for each texture image unit. When a value for a specific texture image unit is + * invalid, the state for that texture image unit will be unchanged and an error will be generated. However, state for other texture image units will still + * be changed if their corresponding values are valid.
+ * + * @param first the first sampler object + * @param samplers an array of zeros or names of existing sampler objects + * + * @see Reference Page + */ + public static void glBindSamplers(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") IntBuffer samplers) { + GL44C.glBindSamplers(first, samplers); + } + + // --- [ glBindImageTextures ] --- + + /** + * Unsafe version of: {@link #glBindImageTextures BindImageTextures} + * + * @param count the number of image units + */ + public static void nglBindImageTextures(int first, int count, long textures) { + GL44C.nglBindImageTextures(first, count, textures); + } + + /** + * Binds {@code count} existing texture objects to image units numbered {@code first} through {@code first+count-1}. If {@code textures} is not {@code NULL}, it + * specifies an array of {@code count} values, each of which must be zero or the name of an existing texture object. If {@code textures} is {@code NULL}, each + * affected image unit from {@code first} through {@code first+count-1} will be reset to have no bound texture object. + * + *When binding a non-zero texture object to an image unit, the image unit {@code level}, {@code layered}, {@code layer}, and {@code access} parameters are + * set to zero, {@link GL11#GL_TRUE TRUE}, zero, and {@link GL15#GL_READ_WRITE READ_WRITE}, respectively. The image unit {@code format} parameter is taken from the internal + * format of the texture image at level zero of the texture object identified by {@code textures}. For cube map textures, the internal format of the + * {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} image of level zero is used. For multisample, multisample array, buffer, and rectangle textures, the internal + * format of the single texture level is used.
+ * + *When unbinding a texture object from an image unit, the image unit parameters {@code level}, {@code layered}, {@code layer}, and {@code format} will be + * reset to their default values of zero, {@link GL11#GL_FALSE FALSE}, 0, and {@link GL30#GL_R8 R8}, respectively.
+ * + *{@code BindImageTextures} is equivalent to:
+ * + *
+ * for ( i = 0; i < count; i++ ) {
+ * if ( textures == NULL || textures[i] = 0 ) {
+ * glBindImageTexture(first + i, 0, 0, FALSE, 0, READ_ONLY, R8);
+ * } else {
+ * glBindImageTexture(first + i, textures[i], 0, TRUE, 0, READ_WRITE, lookupInternalFormat(textures[i]));
+ * }
+ * }where {@code lookupInternalFormat} returns the internal format of the specified texture object.
+ * + *The values specified in {@code textures} will be checked separately for each image unit. When a value for a specific image unit is invalid, the state + * for that image unit will be unchanged and an error will be generated. However, state for other image units will still be changed if their corresponding + * values are valid.
+ * + * @param first the first image unit + * @param textures an array of zeros or names of existing texture objects + * + * @see Reference Page + */ + public static void glBindImageTextures(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") IntBuffer textures) { + GL44C.glBindImageTextures(first, textures); + } + + // --- [ glBindVertexBuffers ] --- + + /** + * Unsafe version of: {@link #glBindVertexBuffers BindVertexBuffers} + * + * @param count the number of vertex buffer binding points + */ + public static void nglBindVertexBuffers(int first, int count, long buffers, long offsets, long strides) { + GL44C.nglBindVertexBuffers(first, count, buffers, offsets, strides); + } + + /** + * Binds {@code count} existing buffer objects to vertex buffer binding points numbered {@code first} through {@code first+count-1}. If {@code buffers} is + * not {@code NULL}, it specifies an array of {@code count} values, each of which must be zero or the name of an existing buffer object. {@code offsets} and + * {@code strides} specify arrays of {@code count} values indicating the offset of the first element and stride between elements in each buffer, + * respectively. If {@code buffers} is {@code NULL}, each affected vertex buffer binding point from {@code first} through {@code first+count-1} will be reset to + * have no bound buffer object. In this case, the offsets and strides associated with the binding points are set to default values, ignoring + * {@code offsets} and {@code strides}. + * + *{@code BindVertexBuffers} is equivalent to:
+ * + *
+ * for ( i = 0; i < count; i++ ) {
+ * if ( buffers == NULL ) {
+ * glBindVertexBuffer(first + i, 0, 0, 16);
+ * } else {
+ * glBindVertexBuffer(first + i, buffers[i], offsets[i], strides[i]);
+ * }
+ * }except that buffers will not be created if they do not exist.
+ * + *The values specified in {@code buffers}, {@code offsets}, and {@code strides} will be checked separately for each vertex buffer binding point. When a + * value for a specific binding point is invalid, the state for that binding point will be unchanged and an error will be generated. However, state for + * other binding points will still be changed if their corresponding values are valid.
+ * + * @param first the first vertex buffer binding point + * @param buffers an array of zeros or names of existing buffers objects + * @param offsets an array of offses + * @param strides an array of stride values + * + * @see Reference Page + */ + public static void glBindVertexBuffers(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") IntBuffer buffers, @Nullable @NativeType("GLintptr const *") PointerBuffer offsets, @Nullable @NativeType("GLsizei const *") IntBuffer strides) { + GL44C.glBindVertexBuffers(first, buffers, offsets, strides); + } + + /** + * Array version of: {@link #glBufferStorage BufferStorage} + * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") short[] data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** + * Array version of: {@link #glBufferStorage BufferStorage} + * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") int[] data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** + * Array version of: {@link #glBufferStorage BufferStorage} + * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") float[] data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** + * Array version of: {@link #glBufferStorage BufferStorage} + * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") double[] data, @NativeType("GLbitfield") int flags) { + GL44C.glBufferStorage(target, data, flags); + } + + /** + * Array version of: {@link #glClearTexSubImage ClearTexSubImage} + * + * @see Reference Page + */ + public static void glClearTexSubImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLint") int zoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") short[] data) { + GL44C.glClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); + } + + /** + * Array version of: {@link #glClearTexSubImage ClearTexSubImage} + * + * @see Reference Page + */ + public static void glClearTexSubImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLint") int zoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") int[] data) { + GL44C.glClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); + } + + /** + * Array version of: {@link #glClearTexSubImage ClearTexSubImage} + * + * @see Reference Page + */ + public static void glClearTexSubImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLint") int zoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") float[] data) { + GL44C.glClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); + } + + /** + * Array version of: {@link #glClearTexSubImage ClearTexSubImage} + * + * @see Reference Page + */ + public static void glClearTexSubImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLint") int zoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") double[] data) { + GL44C.glClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); + } + + /** + * Array version of: {@link #glClearTexImage ClearTexImage} + * + * @see Reference Page + */ + public static void glClearTexImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") short[] data) { + GL44C.glClearTexImage(texture, level, format, type, data); + } + + /** + * Array version of: {@link #glClearTexImage ClearTexImage} + * + * @see Reference Page + */ + public static void glClearTexImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") int[] data) { + GL44C.glClearTexImage(texture, level, format, type, data); + } + + /** + * Array version of: {@link #glClearTexImage ClearTexImage} + * + * @see Reference Page + */ + public static void glClearTexImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") float[] data) { + GL44C.glClearTexImage(texture, level, format, type, data); + } + + /** + * Array version of: {@link #glClearTexImage ClearTexImage} + * + * @see Reference Page + */ + public static void glClearTexImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") double[] data) { + GL44C.glClearTexImage(texture, level, format, type, data); + } + + /** + * Array version of: {@link #glBindBuffersBase BindBuffersBase} + * + * @see Reference Page + */ + public static void glBindBuffersBase(@NativeType("GLenum") int target, @NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] buffers) { + GL44C.glBindBuffersBase(target, first, buffers); + } + + /** + * Array version of: {@link #glBindBuffersRange BindBuffersRange} + * + * @see Reference Page + */ + public static void glBindBuffersRange(@NativeType("GLenum") int target, @NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] buffers, @Nullable @NativeType("GLintptr const *") PointerBuffer offsets, @Nullable @NativeType("GLsizeiptr const *") PointerBuffer sizes) { + GL44C.glBindBuffersRange(target, first, buffers, offsets, sizes); + } + + /** + * Array version of: {@link #glBindTextures BindTextures} + * + * @see Reference Page + */ + public static void glBindTextures(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] textures) { + GL44C.glBindTextures(first, textures); + } + + /** + * Array version of: {@link #glBindSamplers BindSamplers} + * + * @see Reference Page + */ + public static void glBindSamplers(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] samplers) { + GL44C.glBindSamplers(first, samplers); + } + + /** + * Array version of: {@link #glBindImageTextures BindImageTextures} + * + * @see Reference Page + */ + public static void glBindImageTextures(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] textures) { + GL44C.glBindImageTextures(first, textures); + } + + /** + * Array version of: {@link #glBindVertexBuffers BindVertexBuffers} + * + * @see Reference Page + */ + public static void glBindVertexBuffers(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] buffers, @Nullable @NativeType("GLintptr const *") PointerBuffer offsets, @Nullable @NativeType("GLsizei const *") int[] strides) { + GL44C.glBindVertexBuffers(first, buffers, offsets, strides); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL44C.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL44C.java new file mode 100644 index 00000000..6d235565 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL44C.java @@ -0,0 +1,1239 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * The OpenGL functionality up to version 4.4. Includes only Core Profile symbols. + * + *OpenGL 4.4 implementations support revision 4.40 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link #GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("GLsizeiptr") long size, @NativeType("GLbitfield") int flags) { + nglBufferStorage(target, size, NULL, flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link #GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") ByteBuffer data, @NativeType("GLbitfield") int flags) { + nglBufferStorage(target, data.remaining(), memAddress(data), flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link #GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") ShortBuffer data, @NativeType("GLbitfield") int flags) { + nglBufferStorage(target, Integer.toUnsignedLong(data.remaining()) << 1, memAddress(data), flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link #GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") IntBuffer data, @NativeType("GLbitfield") int flags) { + nglBufferStorage(target, Integer.toUnsignedLong(data.remaining()) << 2, memAddress(data), flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link #GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") FloatBuffer data, @NativeType("GLbitfield") int flags) { + nglBufferStorage(target, Integer.toUnsignedLong(data.remaining()) << 2, memAddress(data), flags); + } + + /** + * Creates the data store of a buffer object. + * + *The data store of the buffer object bound to {@code target} is allocated as a result of a call to this function and cannot be de-allocated until the + * buffer is deleted with a call to {@link GL15C#glDeleteBuffers DeleteBuffers}. Such a store may not be re-allocated through further calls to {@code BufferStorage} + * or {@link GL15C#glBufferData BufferData}.
+ * + *{@code BufferStorage} deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to + * another thread, it is as though {@link GL15C#glUnmapBuffer UnmapBuffer} is executed in each such context prior to deleting the existing data store.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
If {@code flags} contains {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link #GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link #GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") DoubleBuffer data, @NativeType("GLbitfield") int flags) { + nglBufferStorage(target, Integer.toUnsignedLong(data.remaining()) << 3, memAddress(data), flags); + } + + // --- [ glClearTexSubImage ] --- + + /** Unsafe version of: {@link #glClearTexSubImage ClearTexSubImage} */ + public static native void nglClearTexSubImage(int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int format, int type, long data); + + /** + * Fills all or part of a texture image with a constant value. + * + *Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
Arguments {@code xoffset}, {@code yoffset}, and {@code zoffset} specify the lower left texel coordinates of a {@code width}-wide by {@code height}-high + * by {@code depth}-deep rectangular subregion of the texel array and are interpreted as they are in {@link GL12C#glTexSubImage3D TexSubImage3D}.
+ * + *For 1D array textures, {@code yoffset} is interpreted as the first layer to be cleared and {@code height} is the number of layers to clear. For 2D array + * textures, {@code zoffset} is interpreted as the first layer to be cleared and {@code depth} is the number of layers to clear. Cube map textures are + * treated as an array of six slices in the z-dimension, where the value of {@code zoffset} is interpreted as specifying the cube map face for the + * corresponding {@code layer} and {@code depth} is the number of faces to clear. For cube map array textures, {@code zoffset} is the first layer-face to + * clear, and {@code depth} is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.
+ * + *Negative values of {@code xoffset}, {@code yoffset}, and {@code zoffset} correspond to the coordinates of border texels.
+ * + * @param texture the texture to clear. It is an error if {@code texture} is zero or not the name of a texture object, if {@code texture} is a buffer texture, or if + * the texture image has a compressed internal format + * @param level the texture level to clear + * @param xoffset the x coordinate of the texel subregion + * @param yoffset the y coordinate of the texel subregion + * @param zoffset the z coordinate of the texel subregion + * @param width the subregion width + * @param height the subregion height + * @param depth the subregion depth + * @param format the format of the source data. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
+ * for ( i = 0; i < count; i++ ) {
+ * if ( buffers == NULL ) {
+ * glBindBufferBase(target, first + i, 0);
+ * } else {
+ * glBindBufferBase(target, first + i, buffers[i]);
+ * }
+ * }except that the single general buffer binding corresponding to {@code target} is unmodified, and that buffers will not be created if they do not exist.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
+ * for ( i = 0; i < count; i++ ) {
+ * if ( buffers == NULL ) {
+ * glBindBufferRange(target, first + i, 0, 0, 0);
+ * } else {
+ * glBindBufferRange(target, first + i, buffers[i], offsets[i], sizes[i]);
+ * }
+ * }except that the single general buffer binding corresponding to {@code target} is unmodified, and that buffers will not be created if they do not exist.
+ * + *The values specified in {@code buffers}, {@code offsets}, and {@code sizes} will be checked separately for each binding point. When values for a + * specific binding point are invalid, the state for that binding point will be unchanged and an error will be generated. However, state for other binding + * points will still be changed if their corresponding values are valid.
+ * + * @param target the buffer object target. One of:| {@link GL15#GL_ARRAY_BUFFER ARRAY_BUFFER} | {@link GL15#GL_ELEMENT_ARRAY_BUFFER ELEMENT_ARRAY_BUFFER} | {@link GL21#GL_PIXEL_PACK_BUFFER PIXEL_PACK_BUFFER} | {@link GL21#GL_PIXEL_UNPACK_BUFFER PIXEL_UNPACK_BUFFER} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER TRANSFORM_FEEDBACK_BUFFER} | {@link GL31#GL_UNIFORM_BUFFER UNIFORM_BUFFER} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL31#GL_COPY_READ_BUFFER COPY_READ_BUFFER} |
| {@link GL31#GL_COPY_WRITE_BUFFER COPY_WRITE_BUFFER} | {@link GL40#GL_DRAW_INDIRECT_BUFFER DRAW_INDIRECT_BUFFER} | {@link GL42#GL_ATOMIC_COUNTER_BUFFER ATOMIC_COUNTER_BUFFER} | {@link GL43#GL_DISPATCH_INDIRECT_BUFFER DISPATCH_INDIRECT_BUFFER} |
| {@link GL43#GL_SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER} | {@link ARBIndirectParameters#GL_PARAMETER_BUFFER_ARB PARAMETER_BUFFER_ARB} |
{@code BindTextures} is equivalent to:
+ * + *
+ * for ( i = 0; i < count; i++ ) {
+ * uint texture;
+ * if ( textures == NULL ) {
+ * texture = 0;
+ * } else {
+ * texture = textures[i];
+ * }
+ * ActiveTexture(TEXTURE0 + first + i);
+ * if ( texture != 0 ) {
+ * enum target; // target of texture object textures[i]
+ * BindTexture(target, textures[i]);
+ * } else {
+ * for ( target in all supported targets ) {
+ * BindTexture(target, 0);
+ * }
+ * }
+ * }except that the active texture selector retains its original value upon completion of the command, and that textures will not be created if they do not + * exist.
+ * + *The values specified in {@code textures} will be checked separately for each texture image unit. When a value for a specific texture image unit is + * invalid, the state for that texture image unit will be unchanged and an error will be generated. However, state for other texture image units will still + * be changed if their corresponding values are valid.
+ * + * @param first the first texture objects + * @param textures an array of zeros or names of existing texture objects + * + * @see Reference Page + */ + public static void glBindTextures(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") IntBuffer textures) { + nglBindTextures(first, remainingSafe(textures), memAddressSafe(textures)); + } + + // --- [ glBindSamplers ] --- + + /** + * Unsafe version of: {@link #glBindSamplers BindSamplers} + * + * @param count the number of sampler objects + */ + public static native void nglBindSamplers(int first, int count, long samplers); + + /** + * Binds {@code count} existing sampler objects to texture image units numbered {@code first} through {@code first+count-1}. If {@code samplers} is not + * {@code NULL}, it specifies an array of {@code count} values, each of which must be zero or the name of an existing sampler object. If {@code samplers} is {@code NULL}, + * each affected texture image unit from {@code first} through {@code first+count-1} will be reset to have no bound sampler object. + * + *{@code BindSamplers} is equivalent to:
+ * + *
+ * for ( i = 0; i < count; i++ ) {
+ * if ( samplers == NULL ) {
+ * glBindSampler(first + i, 0);
+ * } else {
+ * glBindSampler(first + i, samplers[i]);
+ * }
+ * }The values specified in {@code samplers} will be checked separately for each texture image unit. When a value for a specific texture image unit is + * invalid, the state for that texture image unit will be unchanged and an error will be generated. However, state for other texture image units will still + * be changed if their corresponding values are valid.
+ * + * @param first the first sampler object + * @param samplers an array of zeros or names of existing sampler objects + * + * @see Reference Page + */ + public static void glBindSamplers(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") IntBuffer samplers) { + nglBindSamplers(first, remainingSafe(samplers), memAddressSafe(samplers)); + } + + // --- [ glBindImageTextures ] --- + + /** + * Unsafe version of: {@link #glBindImageTextures BindImageTextures} + * + * @param count the number of image units + */ + public static native void nglBindImageTextures(int first, int count, long textures); + + /** + * Binds {@code count} existing texture objects to image units numbered {@code first} through {@code first+count-1}. If {@code textures} is not {@code NULL}, it + * specifies an array of {@code count} values, each of which must be zero or the name of an existing texture object. If {@code textures} is {@code NULL}, each + * affected image unit from {@code first} through {@code first+count-1} will be reset to have no bound texture object. + * + *When binding a non-zero texture object to an image unit, the image unit {@code level}, {@code layered}, {@code layer}, and {@code access} parameters are + * set to zero, {@link GL11#GL_TRUE TRUE}, zero, and {@link GL15#GL_READ_WRITE READ_WRITE}, respectively. The image unit {@code format} parameter is taken from the internal + * format of the texture image at level zero of the texture object identified by {@code textures}. For cube map textures, the internal format of the + * {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} image of level zero is used. For multisample, multisample array, buffer, and rectangle textures, the internal + * format of the single texture level is used.
+ * + *When unbinding a texture object from an image unit, the image unit parameters {@code level}, {@code layered}, {@code layer}, and {@code format} will be + * reset to their default values of zero, {@link GL11#GL_FALSE FALSE}, 0, and {@link GL30#GL_R8 R8}, respectively.
+ * + *{@code BindImageTextures} is equivalent to:
+ * + *
+ * for ( i = 0; i < count; i++ ) {
+ * if ( textures == NULL || textures[i] = 0 ) {
+ * glBindImageTexture(first + i, 0, 0, FALSE, 0, READ_ONLY, R8);
+ * } else {
+ * glBindImageTexture(first + i, textures[i], 0, TRUE, 0, READ_WRITE, lookupInternalFormat(textures[i]));
+ * }
+ * }where {@code lookupInternalFormat} returns the internal format of the specified texture object.
+ * + *The values specified in {@code textures} will be checked separately for each image unit. When a value for a specific image unit is invalid, the state + * for that image unit will be unchanged and an error will be generated. However, state for other image units will still be changed if their corresponding + * values are valid.
+ * + * @param first the first image unit + * @param textures an array of zeros or names of existing texture objects + * + * @see Reference Page + */ + public static void glBindImageTextures(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") IntBuffer textures) { + nglBindImageTextures(first, remainingSafe(textures), memAddressSafe(textures)); + } + + // --- [ glBindVertexBuffers ] --- + + /** + * Unsafe version of: {@link #glBindVertexBuffers BindVertexBuffers} + * + * @param count the number of vertex buffer binding points + */ + public static native void nglBindVertexBuffers(int first, int count, long buffers, long offsets, long strides); + + /** + * Binds {@code count} existing buffer objects to vertex buffer binding points numbered {@code first} through {@code first+count-1}. If {@code buffers} is + * not {@code NULL}, it specifies an array of {@code count} values, each of which must be zero or the name of an existing buffer object. {@code offsets} and + * {@code strides} specify arrays of {@code count} values indicating the offset of the first element and stride between elements in each buffer, + * respectively. If {@code buffers} is {@code NULL}, each affected vertex buffer binding point from {@code first} through {@code first+count-1} will be reset to + * have no bound buffer object. In this case, the offsets and strides associated with the binding points are set to default values, ignoring + * {@code offsets} and {@code strides}. + * + *{@code BindVertexBuffers} is equivalent to:
+ * + *
+ * for ( i = 0; i < count; i++ ) {
+ * if ( buffers == NULL ) {
+ * glBindVertexBuffer(first + i, 0, 0, 16);
+ * } else {
+ * glBindVertexBuffer(first + i, buffers[i], offsets[i], strides[i]);
+ * }
+ * }except that buffers will not be created if they do not exist.
+ * + *The values specified in {@code buffers}, {@code offsets}, and {@code strides} will be checked separately for each vertex buffer binding point. When a + * value for a specific binding point is invalid, the state for that binding point will be unchanged and an error will be generated. However, state for + * other binding points will still be changed if their corresponding values are valid.
+ * + * @param first the first vertex buffer binding point + * @param buffers an array of zeros or names of existing buffers objects + * @param offsets an array of offses + * @param strides an array of stride values + * + * @see Reference Page + */ + public static void glBindVertexBuffers(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") IntBuffer buffers, @Nullable @NativeType("GLintptr const *") PointerBuffer offsets, @Nullable @NativeType("GLsizei const *") IntBuffer strides) { + if (CHECKS) { + checkSafe(offsets, remainingSafe(buffers)); + checkSafe(strides, remainingSafe(buffers)); + } + nglBindVertexBuffers(first, remainingSafe(buffers), memAddressSafe(buffers), memAddressSafe(offsets), memAddressSafe(strides)); + } + + /** + * Array version of: {@link #glBufferStorage BufferStorage} + * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") short[] data, @NativeType("GLbitfield") int flags) { + long __functionAddress = GL.getICD().glBufferStorage; + if (CHECKS) { + check(__functionAddress); + } + callPPV(target, Integer.toUnsignedLong(data.length) << 1, data, flags, __functionAddress); + } + + /** + * Array version of: {@link #glBufferStorage BufferStorage} + * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") int[] data, @NativeType("GLbitfield") int flags) { + long __functionAddress = GL.getICD().glBufferStorage; + if (CHECKS) { + check(__functionAddress); + } + callPPV(target, Integer.toUnsignedLong(data.length) << 2, data, flags, __functionAddress); + } + + /** + * Array version of: {@link #glBufferStorage BufferStorage} + * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") float[] data, @NativeType("GLbitfield") int flags) { + long __functionAddress = GL.getICD().glBufferStorage; + if (CHECKS) { + check(__functionAddress); + } + callPPV(target, Integer.toUnsignedLong(data.length) << 2, data, flags, __functionAddress); + } + + /** + * Array version of: {@link #glBufferStorage BufferStorage} + * + * @see Reference Page + */ + public static void glBufferStorage(@NativeType("GLenum") int target, @NativeType("void const *") double[] data, @NativeType("GLbitfield") int flags) { + long __functionAddress = GL.getICD().glBufferStorage; + if (CHECKS) { + check(__functionAddress); + } + callPPV(target, Integer.toUnsignedLong(data.length) << 3, data, flags, __functionAddress); + } + + /** + * Array version of: {@link #glClearTexSubImage ClearTexSubImage} + * + * @see Reference Page + */ + public static void glClearTexSubImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLint") int zoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") short[] data) { + long __functionAddress = GL.getICD().glClearTexSubImage; + if (CHECKS) { + check(__functionAddress); + } + callPV(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data, __functionAddress); + } + + /** + * Array version of: {@link #glClearTexSubImage ClearTexSubImage} + * + * @see Reference Page + */ + public static void glClearTexSubImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLint") int zoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") int[] data) { + long __functionAddress = GL.getICD().glClearTexSubImage; + if (CHECKS) { + check(__functionAddress); + } + callPV(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data, __functionAddress); + } + + /** + * Array version of: {@link #glClearTexSubImage ClearTexSubImage} + * + * @see Reference Page + */ + public static void glClearTexSubImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLint") int zoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") float[] data) { + long __functionAddress = GL.getICD().glClearTexSubImage; + if (CHECKS) { + check(__functionAddress); + } + callPV(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data, __functionAddress); + } + + /** + * Array version of: {@link #glClearTexSubImage ClearTexSubImage} + * + * @see Reference Page + */ + public static void glClearTexSubImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLint") int xoffset, @NativeType("GLint") int yoffset, @NativeType("GLint") int zoffset, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") double[] data) { + long __functionAddress = GL.getICD().glClearTexSubImage; + if (CHECKS) { + check(__functionAddress); + } + callPV(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data, __functionAddress); + } + + /** + * Array version of: {@link #glClearTexImage ClearTexImage} + * + * @see Reference Page + */ + public static void glClearTexImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") short[] data) { + long __functionAddress = GL.getICD().glClearTexImage; + if (CHECKS) { + check(__functionAddress); + } + callPV(texture, level, format, type, data, __functionAddress); + } + + /** + * Array version of: {@link #glClearTexImage ClearTexImage} + * + * @see Reference Page + */ + public static void glClearTexImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") int[] data) { + long __functionAddress = GL.getICD().glClearTexImage; + if (CHECKS) { + check(__functionAddress); + } + callPV(texture, level, format, type, data, __functionAddress); + } + + /** + * Array version of: {@link #glClearTexImage ClearTexImage} + * + * @see Reference Page + */ + public static void glClearTexImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") float[] data) { + long __functionAddress = GL.getICD().glClearTexImage; + if (CHECKS) { + check(__functionAddress); + } + callPV(texture, level, format, type, data, __functionAddress); + } + + /** + * Array version of: {@link #glClearTexImage ClearTexImage} + * + * @see Reference Page + */ + public static void glClearTexImage(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLenum") int format, @NativeType("GLenum") int type, @Nullable @NativeType("void const *") double[] data) { + long __functionAddress = GL.getICD().glClearTexImage; + if (CHECKS) { + check(__functionAddress); + } + callPV(texture, level, format, type, data, __functionAddress); + } + + /** + * Array version of: {@link #glBindBuffersBase BindBuffersBase} + * + * @see Reference Page + */ + public static void glBindBuffersBase(@NativeType("GLenum") int target, @NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] buffers) { + long __functionAddress = GL.getICD().glBindBuffersBase; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, first, lengthSafe(buffers), buffers, __functionAddress); + } + + /** + * Array version of: {@link #glBindBuffersRange BindBuffersRange} + * + * @see Reference Page + */ + public static void glBindBuffersRange(@NativeType("GLenum") int target, @NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] buffers, @Nullable @NativeType("GLintptr const *") PointerBuffer offsets, @Nullable @NativeType("GLsizeiptr const *") PointerBuffer sizes) { + long __functionAddress = GL.getICD().glBindBuffersRange; + if (CHECKS) { + check(__functionAddress); + checkSafe(offsets, lengthSafe(buffers)); + checkSafe(sizes, lengthSafe(buffers)); + } + callPPPV(target, first, lengthSafe(buffers), buffers, memAddressSafe(offsets), memAddressSafe(sizes), __functionAddress); + } + + /** + * Array version of: {@link #glBindTextures BindTextures} + * + * @see Reference Page + */ + public static void glBindTextures(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] textures) { + long __functionAddress = GL.getICD().glBindTextures; + if (CHECKS) { + check(__functionAddress); + } + callPV(first, lengthSafe(textures), textures, __functionAddress); + } + + /** + * Array version of: {@link #glBindSamplers BindSamplers} + * + * @see Reference Page + */ + public static void glBindSamplers(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] samplers) { + long __functionAddress = GL.getICD().glBindSamplers; + if (CHECKS) { + check(__functionAddress); + } + callPV(first, lengthSafe(samplers), samplers, __functionAddress); + } + + /** + * Array version of: {@link #glBindImageTextures BindImageTextures} + * + * @see Reference Page + */ + public static void glBindImageTextures(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] textures) { + long __functionAddress = GL.getICD().glBindImageTextures; + if (CHECKS) { + check(__functionAddress); + } + callPV(first, lengthSafe(textures), textures, __functionAddress); + } + + /** + * Array version of: {@link #glBindVertexBuffers BindVertexBuffers} + * + * @see Reference Page + */ + public static void glBindVertexBuffers(@NativeType("GLuint") int first, @Nullable @NativeType("GLuint const *") int[] buffers, @Nullable @NativeType("GLintptr const *") PointerBuffer offsets, @Nullable @NativeType("GLsizei const *") int[] strides) { + long __functionAddress = GL.getICD().glBindVertexBuffers; + if (CHECKS) { + check(__functionAddress); + checkSafe(offsets, lengthSafe(buffers)); + checkSafe(strides, lengthSafe(buffers)); + } + callPPPV(first, lengthSafe(buffers), buffers, memAddressSafe(offsets), strides, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL45.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL45.java new file mode 100644 index 00000000..4113f33a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL45.java @@ -0,0 +1,5712 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * The OpenGL functionality up to version 4.5. Includes the deprecated symbols of the Compatibility Profile. + * + *OpenGL 4.5 implementations support revision 4.50 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *These parameters update the clip control origin and depth mode respectively. The initial value of the clip control origin is {@link GL20#GL_LOWER_LEFT LOWER_LEFT} and the + * initial value of the depth mode is {@link GL45C#GL_NEGATIVE_ONE_TO_ONE NEGATIVE_ONE_TO_ONE}.
+ * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if ClipControl is executed between the execution of {@link GL11#glBegin Begin} and the corresponding + * execution of {@link GL11#glEnd End}.
+ * + * @param origin the clip origin. One of:| {@link GL20#GL_LOWER_LEFT LOWER_LEFT} | {@link GL20#GL_UPPER_LEFT UPPER_LEFT} |
| {@link GL45C#GL_NEGATIVE_ONE_TO_ONE NEGATIVE_ONE_TO_ONE} | {@link GL45C#GL_ZERO_TO_ONE ZERO_TO_ONE} |
| {@link GL42#GL_TRANSFORM_FEEDBACK_PAUSED TRANSFORM_FEEDBACK_PAUSED} | {@link GL42#GL_TRANSFORM_FEEDBACK_ACTIVE TRANSFORM_FEEDBACK_ACTIVE} |
| {@link GL42#GL_TRANSFORM_FEEDBACK_PAUSED TRANSFORM_FEEDBACK_PAUSED} | {@link GL42#GL_TRANSFORM_FEEDBACK_ACTIVE TRANSFORM_FEEDBACK_ACTIVE} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_BINDING TRANSFORM_FEEDBACK_BUFFER_BINDING} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_BINDING TRANSFORM_FEEDBACK_BUFFER_BINDING} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_START TRANSFORM_FEEDBACK_BUFFER_START} | {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_SIZE TRANSFORM_FEEDBACK_BUFFER_SIZE} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_START TRANSFORM_FEEDBACK_BUFFER_START} | {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_SIZE TRANSFORM_FEEDBACK_BUFFER_SIZE} |
If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("GLsizeiptr") long size, @NativeType("GLbitfield") int flags) { + GL45C.glNamedBufferStorage(buffer, size, flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") ByteBuffer data, @NativeType("GLbitfield") int flags) { + GL45C.glNamedBufferStorage(buffer, data, flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") ShortBuffer data, @NativeType("GLbitfield") int flags) { + GL45C.glNamedBufferStorage(buffer, data, flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") IntBuffer data, @NativeType("GLbitfield") int flags) { + GL45C.glNamedBufferStorage(buffer, data, flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") FloatBuffer data, @NativeType("GLbitfield") int flags) { + GL45C.glNamedBufferStorage(buffer, data, flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") DoubleBuffer data, @NativeType("GLbitfield") int flags) { + GL45C.glNamedBufferStorage(buffer, data, flags); + } + + // --- [ glNamedBufferData ] --- + + /** + * Unsafe version of: {@link #glNamedBufferData NamedBufferData} + * + * @param size the size in bytes of the buffer object's new data store + */ + public static void nglNamedBufferData(int buffer, long size, long data, int usage) { + GL45C.nglNamedBufferData(buffer, size, data, usage); + } + + /** + * DSA version of {@link GL15C#glBufferData BufferData}. + * + * @param size the size in bytes of the buffer object's new data store + * @param usage the expected usage pattern of the data store. One of:| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_READ_ONLY READ_ONLY} | {@link GL15#GL_WRITE_ONLY WRITE_ONLY} | {@link GL15#GL_READ_WRITE READ_WRITE} |
| {@link GL15#GL_READ_ONLY READ_ONLY} | {@link GL15#GL_WRITE_ONLY WRITE_ONLY} | {@link GL15#GL_READ_WRITE READ_WRITE} |
| {@link GL15#GL_READ_ONLY READ_ONLY} | {@link GL15#GL_WRITE_ONLY WRITE_ONLY} | {@link GL15#GL_READ_WRITE READ_WRITE} |
| {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} | {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT} | {@link GL30#GL_MAP_INVALIDATE_RANGE_BIT MAP_INVALIDATE_RANGE_BIT} | {@link GL30#GL_MAP_INVALIDATE_BUFFER_BIT MAP_INVALIDATE_BUFFER_BIT} |
| {@link GL30#GL_MAP_FLUSH_EXPLICIT_BIT MAP_FLUSH_EXPLICIT_BIT} | {@link GL30#GL_MAP_UNSYNCHRONIZED_BIT MAP_UNSYNCHRONIZED_BIT} |
| {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} | {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT} | {@link GL30#GL_MAP_INVALIDATE_RANGE_BIT MAP_INVALIDATE_RANGE_BIT} | {@link GL30#GL_MAP_INVALIDATE_BUFFER_BIT MAP_INVALIDATE_BUFFER_BIT} |
| {@link GL30#GL_MAP_FLUSH_EXPLICIT_BIT MAP_FLUSH_EXPLICIT_BIT} | {@link GL30#GL_MAP_UNSYNCHRONIZED_BIT MAP_UNSYNCHRONIZED_BIT} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_BUFFER_MAP_POINTER BUFFER_MAP_POINTER} |
| {@link GL15#GL_BUFFER_MAP_POINTER BUFFER_MAP_POINTER} |
| {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL11#GL_NONE NONE} | {@link GL11#GL_FRONT_LEFT FRONT_LEFT} | {@link GL11#GL_FRONT_RIGHT FRONT_RIGHT} | {@link GL11#GL_BACK_LEFT BACK_LEFT} | {@link GL11#GL_BACK_RIGHT BACK_RIGHT} | {@link GL11#GL_FRONT FRONT} | {@link GL11#GL_BACK BACK} | {@link GL11#GL_LEFT LEFT} |
| {@link GL11#GL_RIGHT RIGHT} | {@link GL11#GL_FRONT_AND_BACK FRONT_AND_BACK} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link GL11#GL_NONE NONE} | {@link GL11#GL_FRONT_LEFT FRONT_LEFT} | {@link GL11#GL_FRONT_RIGHT FRONT_RIGHT} | {@link GL11#GL_BACK_LEFT BACK_LEFT} | {@link GL11#GL_BACK_RIGHT BACK_RIGHT} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} |
| GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link GL11#GL_NONE NONE} | {@link GL11#GL_FRONT_LEFT FRONT_LEFT} | {@link GL11#GL_FRONT_RIGHT FRONT_RIGHT} | {@link GL11#GL_BACK_LEFT BACK_LEFT} | {@link GL11#GL_BACK_RIGHT BACK_RIGHT} | {@link GL11#GL_FRONT FRONT} | {@link GL11#GL_BACK BACK} | {@link GL11#GL_LEFT LEFT} |
| {@link GL11#GL_RIGHT RIGHT} | {@link GL11#GL_FRONT_AND_BACK FRONT_AND_BACK} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link GL11#GL_COLOR COLOR} | {@link GL11#GL_STENCIL STENCIL} |
| {@link GL11#GL_COLOR COLOR} |
| {@link GL11#GL_COLOR COLOR} | {@link GL11#GL_DEPTH DEPTH} |
| {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_COLOR_BUFFER_BIT COLOR_BUFFER_BIT} | {@link GL11#GL_DEPTH_BUFFER_BIT DEPTH_BUFFER_BIT} | {@link GL11#GL_STENCIL_BUFFER_BIT STENCIL_BUFFER_BIT} |
| {@link GL11#GL_NEAREST NEAREST} | {@link GL11#GL_LINEAR LINEAR} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME FRAMEBUFFER_ATTACHMENT_OBJECT_NAME} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE FRAMEBUFFER_ATTACHMENT_RED_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE FRAMEBUFFER_ATTACHMENT_GREEN_SIZE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE FRAMEBUFFER_ATTACHMENT_BLUE_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE} |
| {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME FRAMEBUFFER_ATTACHMENT_OBJECT_NAME} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE FRAMEBUFFER_ATTACHMENT_RED_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE FRAMEBUFFER_ATTACHMENT_GREEN_SIZE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE FRAMEBUFFER_ATTACHMENT_BLUE_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE} |
| {@link GL30#GL_RENDERBUFFER_WIDTH RENDERBUFFER_WIDTH} | {@link GL30#GL_RENDERBUFFER_HEIGHT RENDERBUFFER_HEIGHT} | {@link GL30#GL_RENDERBUFFER_INTERNAL_FORMAT RENDERBUFFER_INTERNAL_FORMAT} |
| {@link GL30#GL_RENDERBUFFER_RED_SIZE RENDERBUFFER_RED_SIZE} | {@link GL30#GL_RENDERBUFFER_GREEN_SIZE RENDERBUFFER_GREEN_SIZE} | {@link GL30#GL_RENDERBUFFER_BLUE_SIZE RENDERBUFFER_BLUE_SIZE} |
| {@link GL30#GL_RENDERBUFFER_ALPHA_SIZE RENDERBUFFER_ALPHA_SIZE} | {@link GL30#GL_RENDERBUFFER_DEPTH_SIZE RENDERBUFFER_DEPTH_SIZE} | {@link GL30#GL_RENDERBUFFER_STENCIL_SIZE RENDERBUFFER_STENCIL_SIZE} |
| {@link GL30#GL_RENDERBUFFER_SAMPLES RENDERBUFFER_SAMPLES} |
| {@link GL30#GL_RENDERBUFFER_WIDTH RENDERBUFFER_WIDTH} | {@link GL30#GL_RENDERBUFFER_HEIGHT RENDERBUFFER_HEIGHT} | {@link GL30#GL_RENDERBUFFER_INTERNAL_FORMAT RENDERBUFFER_INTERNAL_FORMAT} |
| {@link GL30#GL_RENDERBUFFER_RED_SIZE RENDERBUFFER_RED_SIZE} | {@link GL30#GL_RENDERBUFFER_GREEN_SIZE RENDERBUFFER_GREEN_SIZE} | {@link GL30#GL_RENDERBUFFER_BLUE_SIZE RENDERBUFFER_BLUE_SIZE} |
| {@link GL30#GL_RENDERBUFFER_ALPHA_SIZE RENDERBUFFER_ALPHA_SIZE} | {@link GL30#GL_RENDERBUFFER_DEPTH_SIZE RENDERBUFFER_DEPTH_SIZE} | {@link GL30#GL_RENDERBUFFER_STENCIL_SIZE RENDERBUFFER_STENCIL_SIZE} |
| {@link GL30#GL_RENDERBUFFER_SAMPLES RENDERBUFFER_SAMPLES} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
{@code texture} must be zero or the name of an existing texture object. When {@code texture} is the name of an existing texture object, that object is + * bound to the target, in the corresponding texture unit, that was specified when the object was created. When {@code texture} is zero, each of the targets + * enumerated at the beginning of this section is reset to its default texture for the corresponding texture image unit.
+ * + * @param unit the texture unit number + * @param texture the texture name + * + * @see Reference Page + */ + public static void glBindTextureUnit(@NativeType("GLuint") int unit, @NativeType("GLuint") int texture) { + GL45C.glBindTextureUnit(unit, texture); + } + + // --- [ glGetTextureImage ] --- + + /** + * Unsafe version of: {@link #glGetTextureImage GetTextureImage} + * + * @param bufSize the size of the buffer to receive the retrieved pixel data + */ + public static void nglGetTextureImage(int texture, int level, int format, int type, int bufSize, long pixels) { + GL45C.nglGetTextureImage(texture, level, format, type, bufSize, pixels); + } + + /** + * DSA version of {@link GL11C#glGetTexImage GetTexImage}. + * + * @param texture the texture name + * @param level the level-of-detail number + * @param format the pixel format. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_WIDTH TEXTURE_WIDTH} | {@link GL11#GL_TEXTURE_HEIGHT TEXTURE_HEIGHT} | {@link GL12#GL_TEXTURE_DEPTH TEXTURE_DEPTH} | {@link GL32#GL_TEXTURE_SAMPLES TEXTURE_SAMPLES} |
| {@link GL32#GL_TEXTURE_FIXED_SAMPLE_LOCATIONS TEXTURE_FIXED_SAMPLE_LOCATIONS} | {@link GL11#GL_TEXTURE_INTERNAL_FORMAT TEXTURE_INTERNAL_FORMAT} | {@link GL11#GL_TEXTURE_RED_SIZE TEXTURE_RED_SIZE} | {@link GL11#GL_TEXTURE_GREEN_SIZE TEXTURE_GREEN_SIZE} |
| {@link GL11#GL_TEXTURE_BLUE_SIZE TEXTURE_BLUE_SIZE} | {@link GL11#GL_TEXTURE_ALPHA_SIZE TEXTURE_ALPHA_SIZE} | {@link GL14#GL_TEXTURE_DEPTH_SIZE TEXTURE_DEPTH_SIZE} | {@link GL30#GL_TEXTURE_STENCIL_SIZE TEXTURE_STENCIL_SIZE} |
| {@link GL30#GL_TEXTURE_SHARED_SIZE TEXTURE_SHARED_SIZE} | {@link GL30#GL_TEXTURE_ALPHA_TYPE TEXTURE_ALPHA_TYPE} | {@link GL30#GL_TEXTURE_DEPTH_TYPE TEXTURE_DEPTH_TYPE} | {@link GL13#GL_TEXTURE_COMPRESSED TEXTURE_COMPRESSED} |
| {@link GL13#GL_TEXTURE_COMPRESSED_IMAGE_SIZE TEXTURE_COMPRESSED_IMAGE_SIZE} | {@link GL31#GL_TEXTURE_BUFFER_DATA_STORE_BINDING TEXTURE_BUFFER_DATA_STORE_BINDING} | {@link GL43#GL_TEXTURE_BUFFER_OFFSET TEXTURE_BUFFER_OFFSET} | {@link GL43#GL_TEXTURE_BUFFER_SIZE TEXTURE_BUFFER_SIZE} |
| {@link GL11#GL_TEXTURE_WIDTH TEXTURE_WIDTH} | {@link GL11#GL_TEXTURE_HEIGHT TEXTURE_HEIGHT} | {@link GL12#GL_TEXTURE_DEPTH TEXTURE_DEPTH} | {@link GL32#GL_TEXTURE_SAMPLES TEXTURE_SAMPLES} |
| {@link GL32#GL_TEXTURE_FIXED_SAMPLE_LOCATIONS TEXTURE_FIXED_SAMPLE_LOCATIONS} | {@link GL11#GL_TEXTURE_INTERNAL_FORMAT TEXTURE_INTERNAL_FORMAT} | {@link GL11#GL_TEXTURE_RED_SIZE TEXTURE_RED_SIZE} | {@link GL11#GL_TEXTURE_GREEN_SIZE TEXTURE_GREEN_SIZE} |
| {@link GL11#GL_TEXTURE_BLUE_SIZE TEXTURE_BLUE_SIZE} | {@link GL11#GL_TEXTURE_ALPHA_SIZE TEXTURE_ALPHA_SIZE} | {@link GL14#GL_TEXTURE_DEPTH_SIZE TEXTURE_DEPTH_SIZE} | {@link GL30#GL_TEXTURE_STENCIL_SIZE TEXTURE_STENCIL_SIZE} |
| {@link GL30#GL_TEXTURE_SHARED_SIZE TEXTURE_SHARED_SIZE} | {@link GL30#GL_TEXTURE_ALPHA_TYPE TEXTURE_ALPHA_TYPE} | {@link GL30#GL_TEXTURE_DEPTH_TYPE TEXTURE_DEPTH_TYPE} | {@link GL13#GL_TEXTURE_COMPRESSED TEXTURE_COMPRESSED} |
| {@link GL13#GL_TEXTURE_COMPRESSED_IMAGE_SIZE TEXTURE_COMPRESSED_IMAGE_SIZE} | {@link GL31#GL_TEXTURE_BUFFER_DATA_STORE_BINDING TEXTURE_BUFFER_DATA_STORE_BINDING} | {@link GL43#GL_TEXTURE_BUFFER_OFFSET TEXTURE_BUFFER_OFFSET} | {@link GL43#GL_TEXTURE_BUFFER_SIZE TEXTURE_BUFFER_SIZE} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
| {@link GL42#GL_IMAGE_FORMAT_COMPATIBILITY_TYPE IMAGE_FORMAT_COMPATIBILITY_TYPE} | {@link GL42#GL_TEXTURE_IMMUTABLE_FORMAT TEXTURE_IMMUTABLE_FORMAT} | {@link GL43#GL_TEXTURE_IMMUTABLE_LEVELS TEXTURE_IMMUTABLE_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LEVEL TEXTURE_VIEW_MIN_LEVEL} |
| {@link GL43#GL_TEXTURE_VIEW_NUM_LEVELS TEXTURE_VIEW_NUM_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LAYER TEXTURE_VIEW_MIN_LAYER} | {@link GL43#GL_TEXTURE_VIEW_NUM_LAYERS TEXTURE_VIEW_NUM_LAYERS} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
| {@link GL42#GL_IMAGE_FORMAT_COMPATIBILITY_TYPE IMAGE_FORMAT_COMPATIBILITY_TYPE} | {@link GL42#GL_TEXTURE_IMMUTABLE_FORMAT TEXTURE_IMMUTABLE_FORMAT} | {@link GL43#GL_TEXTURE_IMMUTABLE_LEVELS TEXTURE_IMMUTABLE_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LEVEL TEXTURE_VIEW_MIN_LEVEL} |
| {@link GL43#GL_TEXTURE_VIEW_NUM_LEVELS TEXTURE_VIEW_NUM_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LAYER TEXTURE_VIEW_MIN_LAYER} | {@link GL43#GL_TEXTURE_VIEW_NUM_LAYERS TEXTURE_VIEW_NUM_LAYERS} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL15#GL_ELEMENT_ARRAY_BUFFER_BINDING ELEMENT_ARRAY_BUFFER_BINDING} |
| {@link GL15#GL_ELEMENT_ARRAY_BUFFER_BINDING ELEMENT_ARRAY_BUFFER_BINDING} |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_ENABLED VERTEX_ATTRIB_ARRAY_ENABLED} | {@link GL20#GL_VERTEX_ATTRIB_ARRAY_SIZE VERTEX_ATTRIB_ARRAY_SIZE}, |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_STRIDE VERTEX_ATTRIB_ARRAY_STRIDE} | {@link GL20#GL_VERTEX_ATTRIB_ARRAY_TYPE VERTEX_ATTRIB_ARRAY_TYPE} |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_NORMALIZED VERTEX_ATTRIB_ARRAY_NORMALIZED} | {@link GL30#GL_VERTEX_ATTRIB_ARRAY_INTEGER VERTEX_ATTRIB_ARRAY_INTEGER} |
| {@link GL33#GL_VERTEX_ATTRIB_ARRAY_DIVISOR VERTEX_ATTRIB_ARRAY_DIVISOR} | {@link GL43#GL_VERTEX_ATTRIB_ARRAY_LONG VERTEX_ATTRIB_ARRAY_LONG} |
| {@link GL43#GL_VERTEX_ATTRIB_RELATIVE_OFFSET VERTEX_ATTRIB_RELATIVE_OFFSET} |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_ENABLED VERTEX_ATTRIB_ARRAY_ENABLED} | {@link GL20#GL_VERTEX_ATTRIB_ARRAY_SIZE VERTEX_ATTRIB_ARRAY_SIZE}, |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_STRIDE VERTEX_ATTRIB_ARRAY_STRIDE} | {@link GL20#GL_VERTEX_ATTRIB_ARRAY_TYPE VERTEX_ATTRIB_ARRAY_TYPE} |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_NORMALIZED VERTEX_ATTRIB_ARRAY_NORMALIZED} | {@link GL30#GL_VERTEX_ATTRIB_ARRAY_INTEGER VERTEX_ATTRIB_ARRAY_INTEGER} |
| {@link GL33#GL_VERTEX_ATTRIB_ARRAY_DIVISOR VERTEX_ATTRIB_ARRAY_DIVISOR} | {@link GL43#GL_VERTEX_ATTRIB_ARRAY_LONG VERTEX_ATTRIB_ARRAY_LONG} |
| {@link GL43#GL_VERTEX_ATTRIB_RELATIVE_OFFSET VERTEX_ATTRIB_RELATIVE_OFFSET} |
| {@link GL43#GL_VERTEX_BINDING_OFFSET VERTEX_BINDING_OFFSET} |
| {@link GL43#GL_VERTEX_BINDING_OFFSET VERTEX_BINDING_OFFSET} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
First, it narrows the region under consideration so that only reads/writes of prior fragment shaders that are invoked for a smaller region of the + * framebuffer will be completed/reflected prior to subsequent reads/write of following fragment shaders. The size of the region is implementation + * dependent and may be as small as one framebuffer pixel.
+ * + *Second, it only applies to memory transactions that may be read by or written by a fragment shader.
+ * + *When barriers is {@link GL42#GL_ALL_BARRIER_BITS ALL_BARRIER_BITS}, shader memory accesses will be synchronized relative to all these barrier bits, but not to other + * barrier bits specific to {@link GL42C#glMemoryBarrier MemoryBarrier}. This implies that reads/writes for scatter/gather-like algorithms may or may not be + * completed/reflected after a MemoryBarrierByRegion command. However, for uses such as deferred shading, where a linked list of visible + * surfaces with the head at a framebuffer address may be constructed, and the entirety of the list is only dependent on previous executions at that + * framebuffer address, MemoryBarrierByRegion may be significantly more efficient than {@link GL42C#glMemoryBarrier MemoryBarrier}.
+ * + * @param barriers the barriers to insert. One or more of:| {@link GL42#GL_ATOMIC_COUNTER_BARRIER_BIT ATOMIC_COUNTER_BARRIER_BIT} | {@link GL42#GL_FRAMEBUFFER_BARRIER_BIT FRAMEBUFFER_BARRIER_BIT} | {@link GL42#GL_SHADER_IMAGE_ACCESS_BARRIER_BIT SHADER_IMAGE_ACCESS_BARRIER_BIT} |
| {@link GL43#GL_SHADER_STORAGE_BARRIER_BIT SHADER_STORAGE_BARRIER_BIT} | {@link GL42#GL_TEXTURE_FETCH_BARRIER_BIT TEXTURE_FETCH_BARRIER_BIT} | {@link GL42#GL_UNIFORM_BARRIER_BIT UNIFORM_BARRIER_BIT} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
If a reset status other than NO_ERROR is returned and subsequent calls return NO_ERROR, the context reset was encountered and completed. If a reset + * status is repeatedly returned, the context may be in the process of resetting.
+ * + *Reset notification behavior is determined at context creation time, and may be queried by calling GetIntegerv with the symbolic constant + * {@link GL45C#GL_RESET_NOTIFICATION_STRATEGY RESET_NOTIFICATION_STRATEGY}.
+ * + *If the reset notification behavior is {@link GL45C#GL_NO_RESET_NOTIFICATION NO_RESET_NOTIFICATION}, then the implementation will never deliver notification of reset events, and + * GetGraphicsResetStatus will always return NO_ERROR.
+ * + *If the behavior is {@link GL45C#GL_LOSE_CONTEXT_ON_RESET LOSE_CONTEXT_ON_RESET}, a graphics reset will result in a lost context and require creating a new context as described + * above. In this case GetGraphicsResetStatus will return an appropriate value from those described above.
+ * + *If a graphics reset notification occurs in a context, a notification must also occur in all other contexts which share objects with that context.
+ * + *After a graphics reset has occurred on a context, subsequent GL commands on that context (or any context which shares with that context) will generate a + * {@link GL45C#GL_CONTEXT_LOST CONTEXT_LOST} error. Such commands will not have side effects (in particular, they will not modify memory passed by pointer for query results, + * and may not block indefinitely or cause termination of the application. Exceptions to this behavior include:
+ * + *| {@link GL11#GL_MAP1_VERTEX_3 MAP1_VERTEX_3} | {@link GL11#GL_MAP1_VERTEX_4 MAP1_VERTEX_4} | {@link GL11#GL_MAP1_COLOR_4 MAP1_COLOR_4} | {@link GL11#GL_MAP1_NORMAL MAP1_NORMAL} | {@link GL11#GL_MAP1_TEXTURE_COORD_1 MAP1_TEXTURE_COORD_1} |
| {@link GL11#GL_MAP1_TEXTURE_COORD_2 MAP1_TEXTURE_COORD_2} | {@link GL11#GL_MAP1_TEXTURE_COORD_3 MAP1_TEXTURE_COORD_3} | {@link GL11#GL_MAP1_TEXTURE_COORD_4 MAP1_TEXTURE_COORD_4} | {@link GL11#GL_MAP2_VERTEX_3 MAP2_VERTEX_3} | {@link GL11#GL_MAP2_VERTEX_4 MAP2_VERTEX_4} |
| {@link GL11#GL_MAP2_COLOR_4 MAP2_COLOR_4} | {@link GL11#GL_MAP2_NORMAL MAP2_NORMAL} | {@link GL11#GL_MAP2_TEXTURE_COORD_1 MAP2_TEXTURE_COORD_1} | {@link GL11#GL_MAP2_TEXTURE_COORD_2 MAP2_TEXTURE_COORD_2} | {@link GL11#GL_MAP2_TEXTURE_COORD_3 MAP2_TEXTURE_COORD_3} |
| {@link GL11#GL_MAP2_TEXTURE_COORD_4 MAP2_TEXTURE_COORD_4} |
| {@link GL11#GL_ORDER ORDER} | {@link GL11#GL_COEFF COEFF} | {@link GL11#GL_DOMAIN DOMAIN} |
| {@link GL11#GL_MAP1_VERTEX_3 MAP1_VERTEX_3} | {@link GL11#GL_MAP1_VERTEX_4 MAP1_VERTEX_4} | {@link GL11#GL_MAP1_COLOR_4 MAP1_COLOR_4} | {@link GL11#GL_MAP1_NORMAL MAP1_NORMAL} | {@link GL11#GL_MAP1_TEXTURE_COORD_1 MAP1_TEXTURE_COORD_1} |
| {@link GL11#GL_MAP1_TEXTURE_COORD_2 MAP1_TEXTURE_COORD_2} | {@link GL11#GL_MAP1_TEXTURE_COORD_3 MAP1_TEXTURE_COORD_3} | {@link GL11#GL_MAP1_TEXTURE_COORD_4 MAP1_TEXTURE_COORD_4} | {@link GL11#GL_MAP2_VERTEX_3 MAP2_VERTEX_3} | {@link GL11#GL_MAP2_VERTEX_4 MAP2_VERTEX_4} |
| {@link GL11#GL_MAP2_COLOR_4 MAP2_COLOR_4} | {@link GL11#GL_MAP2_NORMAL MAP2_NORMAL} | {@link GL11#GL_MAP2_TEXTURE_COORD_1 MAP2_TEXTURE_COORD_1} | {@link GL11#GL_MAP2_TEXTURE_COORD_2 MAP2_TEXTURE_COORD_2} | {@link GL11#GL_MAP2_TEXTURE_COORD_3 MAP2_TEXTURE_COORD_3} |
| {@link GL11#GL_MAP2_TEXTURE_COORD_4 MAP2_TEXTURE_COORD_4} |
| {@link GL11#GL_ORDER ORDER} | {@link GL11#GL_COEFF COEFF} | {@link GL11#GL_DOMAIN DOMAIN} |
| {@link GL11#GL_PIXEL_MAP_I_TO_I PIXEL_MAP_I_TO_I} | {@link GL11#GL_PIXEL_MAP_S_TO_S PIXEL_MAP_S_TO_S} | {@link GL11#GL_PIXEL_MAP_I_TO_R PIXEL_MAP_I_TO_R} | {@link GL11#GL_PIXEL_MAP_I_TO_G PIXEL_MAP_I_TO_G} | {@link GL11#GL_PIXEL_MAP_I_TO_B PIXEL_MAP_I_TO_B} |
| {@link GL11#GL_PIXEL_MAP_I_TO_A PIXEL_MAP_I_TO_A} | {@link GL11#GL_PIXEL_MAP_R_TO_R PIXEL_MAP_R_TO_R} | {@link GL11#GL_PIXEL_MAP_G_TO_G PIXEL_MAP_G_TO_G} | {@link GL11#GL_PIXEL_MAP_B_TO_B PIXEL_MAP_B_TO_B} | {@link GL11#GL_PIXEL_MAP_A_TO_A PIXEL_MAP_A_TO_A} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link ARBImaging#GL_COLOR_TABLE COLOR_TABLE} | {@link ARBImaging#GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link ARBImaging#GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_COLOR_TABLE COLOR_TABLE} | {@link ARBImaging#GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link ARBImaging#GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_COLOR_TABLE COLOR_TABLE} | {@link ARBImaging#GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link ARBImaging#GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_COLOR_TABLE COLOR_TABLE} | {@link ARBImaging#GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link ARBImaging#GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_COLOR_TABLE COLOR_TABLE} | {@link ARBImaging#GL_POST_CONVOLUTION_COLOR_TABLE POST_CONVOLUTION_COLOR_TABLE} | {@link ARBImaging#GL_POST_COLOR_MATRIX_COLOR_TABLE POST_COLOR_MATRIX_COLOR_TABLE} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_CONVOLUTION_1D CONVOLUTION_1D} | {@link ARBImaging#GL_CONVOLUTION_2D CONVOLUTION_2D} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_CONVOLUTION_1D CONVOLUTION_1D} | {@link ARBImaging#GL_CONVOLUTION_2D CONVOLUTION_2D} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_SEPARABLE_2D SEPARABLE_2D} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_SEPARABLE_2D SEPARABLE_2D} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_HISTOGRAM HISTOGRAM} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_HISTOGRAM HISTOGRAM} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_MINMAX MINMAX} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link ARBImaging#GL_MINMAX MINMAX} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL11#GL_RGB RGB} | {@link GL11#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} | {@link GL12#GL_BGRA BGRA} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} |
| {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
OpenGL 4.5 implementations support revision 4.50 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *These parameters update the clip control origin and depth mode respectively. The initial value of the clip control origin is {@link GL20#GL_LOWER_LEFT LOWER_LEFT} and the + * initial value of the depth mode is {@link #GL_NEGATIVE_ONE_TO_ONE NEGATIVE_ONE_TO_ONE}.
+ * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if ClipControl is executed between the execution of {@link GL11#glBegin Begin} and the corresponding + * execution of {@link GL11#glEnd End}.
+ * + * @param origin the clip origin. One of:| {@link GL20#GL_LOWER_LEFT LOWER_LEFT} | {@link GL20#GL_UPPER_LEFT UPPER_LEFT} |
| {@link #GL_NEGATIVE_ONE_TO_ONE NEGATIVE_ONE_TO_ONE} | {@link #GL_ZERO_TO_ONE ZERO_TO_ONE} |
| {@link GL42#GL_TRANSFORM_FEEDBACK_PAUSED TRANSFORM_FEEDBACK_PAUSED} | {@link GL42#GL_TRANSFORM_FEEDBACK_ACTIVE TRANSFORM_FEEDBACK_ACTIVE} |
| {@link GL42#GL_TRANSFORM_FEEDBACK_PAUSED TRANSFORM_FEEDBACK_PAUSED} | {@link GL42#GL_TRANSFORM_FEEDBACK_ACTIVE TRANSFORM_FEEDBACK_ACTIVE} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_BINDING TRANSFORM_FEEDBACK_BUFFER_BINDING} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_BINDING TRANSFORM_FEEDBACK_BUFFER_BINDING} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_START TRANSFORM_FEEDBACK_BUFFER_START} | {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_SIZE TRANSFORM_FEEDBACK_BUFFER_SIZE} |
| {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_START TRANSFORM_FEEDBACK_BUFFER_START} | {@link GL30#GL_TRANSFORM_FEEDBACK_BUFFER_SIZE TRANSFORM_FEEDBACK_BUFFER_SIZE} |
If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("GLsizeiptr") long size, @NativeType("GLbitfield") int flags) { + nglNamedBufferStorage(buffer, size, NULL, flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") ByteBuffer data, @NativeType("GLbitfield") int flags) { + nglNamedBufferStorage(buffer, data.remaining(), memAddress(data), flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") ShortBuffer data, @NativeType("GLbitfield") int flags) { + nglNamedBufferStorage(buffer, Integer.toUnsignedLong(data.remaining()) << 1, memAddress(data), flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") IntBuffer data, @NativeType("GLbitfield") int flags) { + nglNamedBufferStorage(buffer, Integer.toUnsignedLong(data.remaining()) << 2, memAddress(data), flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") FloatBuffer data, @NativeType("GLbitfield") int flags) { + nglNamedBufferStorage(buffer, Integer.toUnsignedLong(data.remaining()) << 2, memAddress(data), flags); + } + + /** + * DSA version of {@link GL44C#glBufferStorage BufferStorage}. + * + * @param buffer the buffer object name + * @param data the address in client memory of the data that should be used to initialize the buffer's data store. If {@code data} is {@code NULL}, the data store of the + * buffer is created, but contains undefined data. Otherwise, {@code data} should point to an array of at least {@code size} basic machine units. + * @param flags the bitwise {@code OR} of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings + * are as follows: + * + *If {@code flags} contains {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}, it must also contain at least one of {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} or {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT}.
+ * + *It is an error to specify {@link GL44#GL_MAP_COHERENT_BIT MAP_COHERENT_BIT} without also specifying {@link GL44#GL_MAP_PERSISTENT_BIT MAP_PERSISTENT_BIT}.
+ * + * @see Reference Page + */ + public static void glNamedBufferStorage(@NativeType("GLuint") int buffer, @NativeType("void const *") DoubleBuffer data, @NativeType("GLbitfield") int flags) { + nglNamedBufferStorage(buffer, Integer.toUnsignedLong(data.remaining()) << 3, memAddress(data), flags); + } + + // --- [ glNamedBufferData ] --- + + /** + * Unsafe version of: {@link #glNamedBufferData NamedBufferData} + * + * @param size the size in bytes of the buffer object's new data store + */ + public static native void nglNamedBufferData(int buffer, long size, long data, int usage); + + /** + * DSA version of {@link GL15C#glBufferData BufferData}. + * + * @param size the size in bytes of the buffer object's new data store + * @param usage the expected usage pattern of the data store. One of:| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL15#GL_STREAM_DRAW STREAM_DRAW} | {@link GL15#GL_STREAM_READ STREAM_READ} | {@link GL15#GL_STREAM_COPY STREAM_COPY} | {@link GL15#GL_STATIC_DRAW STATIC_DRAW} | {@link GL15#GL_STATIC_READ STATIC_READ} | {@link GL15#GL_STATIC_COPY STATIC_COPY} | {@link GL15#GL_DYNAMIC_DRAW DYNAMIC_DRAW} |
| {@link GL15#GL_DYNAMIC_READ DYNAMIC_READ} | {@link GL15#GL_DYNAMIC_COPY DYNAMIC_COPY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL15#GL_READ_ONLY READ_ONLY} | {@link GL15#GL_WRITE_ONLY WRITE_ONLY} | {@link GL15#GL_READ_WRITE READ_WRITE} |
| {@link GL15#GL_READ_ONLY READ_ONLY} | {@link GL15#GL_WRITE_ONLY WRITE_ONLY} | {@link GL15#GL_READ_WRITE READ_WRITE} |
| {@link GL15#GL_READ_ONLY READ_ONLY} | {@link GL15#GL_WRITE_ONLY WRITE_ONLY} | {@link GL15#GL_READ_WRITE READ_WRITE} |
| {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} | {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT} | {@link GL30#GL_MAP_INVALIDATE_RANGE_BIT MAP_INVALIDATE_RANGE_BIT} | {@link GL30#GL_MAP_INVALIDATE_BUFFER_BIT MAP_INVALIDATE_BUFFER_BIT} |
| {@link GL30#GL_MAP_FLUSH_EXPLICIT_BIT MAP_FLUSH_EXPLICIT_BIT} | {@link GL30#GL_MAP_UNSYNCHRONIZED_BIT MAP_UNSYNCHRONIZED_BIT} |
| {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} | {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT} | {@link GL30#GL_MAP_INVALIDATE_RANGE_BIT MAP_INVALIDATE_RANGE_BIT} | {@link GL30#GL_MAP_INVALIDATE_BUFFER_BIT MAP_INVALIDATE_BUFFER_BIT} |
| {@link GL30#GL_MAP_FLUSH_EXPLICIT_BIT MAP_FLUSH_EXPLICIT_BIT} | {@link GL30#GL_MAP_UNSYNCHRONIZED_BIT MAP_UNSYNCHRONIZED_BIT} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_BUFFER_SIZE BUFFER_SIZE} | {@link GL15#GL_BUFFER_USAGE BUFFER_USAGE} | {@link GL15#GL_BUFFER_ACCESS BUFFER_ACCESS} | {@link GL15#GL_BUFFER_MAPPED BUFFER_MAPPED} |
| {@link GL30#GL_BUFFER_ACCESS_FLAGS BUFFER_ACCESS_FLAGS} | {@link GL30#GL_BUFFER_MAP_LENGTH BUFFER_MAP_LENGTH} | {@link GL30#GL_BUFFER_MAP_OFFSET BUFFER_MAP_OFFSET} | {@link GL44#GL_BUFFER_IMMUTABLE_STORAGE BUFFER_IMMUTABLE_STORAGE} |
| {@link GL44#GL_BUFFER_STORAGE_FLAGS BUFFER_STORAGE_FLAGS} |
| {@link GL15#GL_BUFFER_MAP_POINTER BUFFER_MAP_POINTER} |
| {@link GL15#GL_BUFFER_MAP_POINTER BUFFER_MAP_POINTER} |
| {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL11#GL_NONE NONE} | {@link GL11#GL_FRONT_LEFT FRONT_LEFT} | {@link GL11#GL_FRONT_RIGHT FRONT_RIGHT} | {@link GL11#GL_BACK_LEFT BACK_LEFT} | {@link GL11#GL_BACK_RIGHT BACK_RIGHT} | {@link GL11#GL_FRONT FRONT} | {@link GL11#GL_BACK BACK} | {@link GL11#GL_LEFT LEFT} |
| {@link GL11#GL_RIGHT RIGHT} | {@link GL11#GL_FRONT_AND_BACK FRONT_AND_BACK} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link GL11#GL_NONE NONE} | {@link GL11#GL_FRONT_LEFT FRONT_LEFT} | {@link GL11#GL_FRONT_RIGHT FRONT_RIGHT} | {@link GL11#GL_BACK_LEFT BACK_LEFT} | {@link GL11#GL_BACK_RIGHT BACK_RIGHT} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} |
| GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link GL11#GL_NONE NONE} | {@link GL11#GL_FRONT_LEFT FRONT_LEFT} | {@link GL11#GL_FRONT_RIGHT FRONT_RIGHT} | {@link GL11#GL_BACK_LEFT BACK_LEFT} | {@link GL11#GL_BACK_RIGHT BACK_RIGHT} | {@link GL11#GL_FRONT FRONT} | {@link GL11#GL_BACK BACK} | {@link GL11#GL_LEFT LEFT} |
| {@link GL11#GL_RIGHT RIGHT} | {@link GL11#GL_FRONT_AND_BACK FRONT_AND_BACK} | {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | GL30.GL_COLOR_ATTACHMENT[1-15] |
| {@link GL11#GL_COLOR COLOR} | {@link GL11#GL_STENCIL STENCIL} |
| {@link GL11#GL_COLOR COLOR} |
| {@link GL11#GL_COLOR COLOR} | {@link GL11#GL_DEPTH DEPTH} |
| {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_COLOR_BUFFER_BIT COLOR_BUFFER_BIT} | {@link GL11#GL_DEPTH_BUFFER_BIT DEPTH_BUFFER_BIT} | {@link GL11#GL_STENCIL_BUFFER_BIT STENCIL_BUFFER_BIT} |
| {@link GL11#GL_NEAREST NEAREST} | {@link GL11#GL_LINEAR LINEAR} |
| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_WIDTH FRAMEBUFFER_DEFAULT_WIDTH} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_HEIGHT FRAMEBUFFER_DEFAULT_HEIGHT} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_LAYERS FRAMEBUFFER_DEFAULT_LAYERS} | {@link GL43#GL_FRAMEBUFFER_DEFAULT_SAMPLES FRAMEBUFFER_DEFAULT_SAMPLES} |
| {@link GL43#GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS} |
| {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME FRAMEBUFFER_ATTACHMENT_OBJECT_NAME} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE FRAMEBUFFER_ATTACHMENT_RED_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE FRAMEBUFFER_ATTACHMENT_GREEN_SIZE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE FRAMEBUFFER_ATTACHMENT_BLUE_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE} |
| {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME FRAMEBUFFER_ATTACHMENT_OBJECT_NAME} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE FRAMEBUFFER_ATTACHMENT_RED_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE FRAMEBUFFER_ATTACHMENT_GREEN_SIZE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE FRAMEBUFFER_ATTACHMENT_BLUE_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE} | {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE} |
| {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE} |
| {@link GL30#GL_RENDERBUFFER_WIDTH RENDERBUFFER_WIDTH} | {@link GL30#GL_RENDERBUFFER_HEIGHT RENDERBUFFER_HEIGHT} | {@link GL30#GL_RENDERBUFFER_INTERNAL_FORMAT RENDERBUFFER_INTERNAL_FORMAT} |
| {@link GL30#GL_RENDERBUFFER_RED_SIZE RENDERBUFFER_RED_SIZE} | {@link GL30#GL_RENDERBUFFER_GREEN_SIZE RENDERBUFFER_GREEN_SIZE} | {@link GL30#GL_RENDERBUFFER_BLUE_SIZE RENDERBUFFER_BLUE_SIZE} |
| {@link GL30#GL_RENDERBUFFER_ALPHA_SIZE RENDERBUFFER_ALPHA_SIZE} | {@link GL30#GL_RENDERBUFFER_DEPTH_SIZE RENDERBUFFER_DEPTH_SIZE} | {@link GL30#GL_RENDERBUFFER_STENCIL_SIZE RENDERBUFFER_STENCIL_SIZE} |
| {@link GL30#GL_RENDERBUFFER_SAMPLES RENDERBUFFER_SAMPLES} |
| {@link GL30#GL_RENDERBUFFER_WIDTH RENDERBUFFER_WIDTH} | {@link GL30#GL_RENDERBUFFER_HEIGHT RENDERBUFFER_HEIGHT} | {@link GL30#GL_RENDERBUFFER_INTERNAL_FORMAT RENDERBUFFER_INTERNAL_FORMAT} |
| {@link GL30#GL_RENDERBUFFER_RED_SIZE RENDERBUFFER_RED_SIZE} | {@link GL30#GL_RENDERBUFFER_GREEN_SIZE RENDERBUFFER_GREEN_SIZE} | {@link GL30#GL_RENDERBUFFER_BLUE_SIZE RENDERBUFFER_BLUE_SIZE} |
| {@link GL30#GL_RENDERBUFFER_ALPHA_SIZE RENDERBUFFER_ALPHA_SIZE} | {@link GL30#GL_RENDERBUFFER_DEPTH_SIZE RENDERBUFFER_DEPTH_SIZE} | {@link GL30#GL_RENDERBUFFER_STENCIL_SIZE RENDERBUFFER_STENCIL_SIZE} |
| {@link GL30#GL_RENDERBUFFER_SAMPLES RENDERBUFFER_SAMPLES} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP TEXTURE_CUBE_MAP} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} | {@link GL31#GL_TEXTURE_BUFFER TEXTURE_BUFFER} | {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE} |
| {@link GL32#GL_TEXTURE_2D_MULTISAMPLE_ARRAY TEXTURE_2D_MULTISAMPLE_ARRAY} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL30#GL_COMPRESSED_RED_RGTC1 COMPRESSED_RED_RGTC1} | {@link GL30#GL_COMPRESSED_SIGNED_RED_RGTC1 COMPRESSED_SIGNED_RED_RGTC1} |
| {@link GL30#GL_COMPRESSED_RG_RGTC2 COMPRESSED_RG_RGTC2} | {@link GL30#GL_COMPRESSED_SIGNED_RG_RGTC2 COMPRESSED_SIGNED_RG_RGTC2} |
| {@link GL42#GL_COMPRESSED_RGBA_BPTC_UNORM COMPRESSED_RGBA_BPTC_UNORM} | {@link GL42#GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM COMPRESSED_SRGB_ALPHA_BPTC_UNORM} |
| {@link GL42#GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT COMPRESSED_RGB_BPTC_SIGNED_FLOAT} | {@link GL42#GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT} |
| {@link GL43#GL_COMPRESSED_RGB8_ETC2 COMPRESSED_RGB8_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_ETC2 COMPRESSED_SRGB8_ETC2} |
| {@link GL43#GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2} | {@link GL43#GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2} |
| {@link GL43#GL_COMPRESSED_RGBA8_ETC2_EAC COMPRESSED_RGBA8_ETC2_EAC} | {@link GL43#GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC COMPRESSED_SRGB8_ALPHA8_ETC2_EAC} |
| {@link GL43#GL_COMPRESSED_R11_EAC COMPRESSED_R11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_R11_EAC COMPRESSED_SIGNED_R11_EAC} |
| {@link GL43#GL_COMPRESSED_RG11_EAC COMPRESSED_RG11_EAC} | {@link GL43#GL_COMPRESSED_SIGNED_RG11_EAC COMPRESSED_SIGNED_RG11_EAC} |
| see {@link EXTTextureCompressionS3TC} | see {@link EXTTextureCompressionLATC} |
| see {@link ATITextureCompression3DC} | see {@link KHRTextureCompressionASTCLDR} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
{@code texture} must be zero or the name of an existing texture object. When {@code texture} is the name of an existing texture object, that object is + * bound to the target, in the corresponding texture unit, that was specified when the object was created. When {@code texture} is zero, each of the targets + * enumerated at the beginning of this section is reset to its default texture for the corresponding texture image unit.
+ * + * @param unit the texture unit number + * @param texture the texture name + * + * @see Reference Page + */ + public static native void glBindTextureUnit(@NativeType("GLuint") int unit, @NativeType("GLuint") int texture); + + // --- [ glGetTextureImage ] --- + + /** + * Unsafe version of: {@link #glGetTextureImage GetTextureImage} + * + * @param bufSize the size of the buffer to receive the retrieved pixel data + */ + public static native void nglGetTextureImage(int texture, int level, int format, int type, int bufSize, long pixels); + + /** + * DSA version of {@link GL11C#glGetTexImage GetTexImage}. + * + * @param texture the texture name + * @param level the level-of-detail number + * @param format the pixel format. One of:| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_WIDTH TEXTURE_WIDTH} | {@link GL11#GL_TEXTURE_HEIGHT TEXTURE_HEIGHT} | {@link GL12#GL_TEXTURE_DEPTH TEXTURE_DEPTH} | {@link GL32#GL_TEXTURE_SAMPLES TEXTURE_SAMPLES} |
| {@link GL32#GL_TEXTURE_FIXED_SAMPLE_LOCATIONS TEXTURE_FIXED_SAMPLE_LOCATIONS} | {@link GL11#GL_TEXTURE_INTERNAL_FORMAT TEXTURE_INTERNAL_FORMAT} | {@link GL11#GL_TEXTURE_RED_SIZE TEXTURE_RED_SIZE} | {@link GL11#GL_TEXTURE_GREEN_SIZE TEXTURE_GREEN_SIZE} |
| {@link GL11#GL_TEXTURE_BLUE_SIZE TEXTURE_BLUE_SIZE} | {@link GL11#GL_TEXTURE_ALPHA_SIZE TEXTURE_ALPHA_SIZE} | {@link GL14#GL_TEXTURE_DEPTH_SIZE TEXTURE_DEPTH_SIZE} | {@link GL30#GL_TEXTURE_STENCIL_SIZE TEXTURE_STENCIL_SIZE} |
| {@link GL30#GL_TEXTURE_SHARED_SIZE TEXTURE_SHARED_SIZE} | {@link GL30#GL_TEXTURE_ALPHA_TYPE TEXTURE_ALPHA_TYPE} | {@link GL30#GL_TEXTURE_DEPTH_TYPE TEXTURE_DEPTH_TYPE} | {@link GL13#GL_TEXTURE_COMPRESSED TEXTURE_COMPRESSED} |
| {@link GL13#GL_TEXTURE_COMPRESSED_IMAGE_SIZE TEXTURE_COMPRESSED_IMAGE_SIZE} | {@link GL31#GL_TEXTURE_BUFFER_DATA_STORE_BINDING TEXTURE_BUFFER_DATA_STORE_BINDING} | {@link GL43#GL_TEXTURE_BUFFER_OFFSET TEXTURE_BUFFER_OFFSET} | {@link GL43#GL_TEXTURE_BUFFER_SIZE TEXTURE_BUFFER_SIZE} |
| {@link GL11#GL_TEXTURE_WIDTH TEXTURE_WIDTH} | {@link GL11#GL_TEXTURE_HEIGHT TEXTURE_HEIGHT} | {@link GL12#GL_TEXTURE_DEPTH TEXTURE_DEPTH} | {@link GL32#GL_TEXTURE_SAMPLES TEXTURE_SAMPLES} |
| {@link GL32#GL_TEXTURE_FIXED_SAMPLE_LOCATIONS TEXTURE_FIXED_SAMPLE_LOCATIONS} | {@link GL11#GL_TEXTURE_INTERNAL_FORMAT TEXTURE_INTERNAL_FORMAT} | {@link GL11#GL_TEXTURE_RED_SIZE TEXTURE_RED_SIZE} | {@link GL11#GL_TEXTURE_GREEN_SIZE TEXTURE_GREEN_SIZE} |
| {@link GL11#GL_TEXTURE_BLUE_SIZE TEXTURE_BLUE_SIZE} | {@link GL11#GL_TEXTURE_ALPHA_SIZE TEXTURE_ALPHA_SIZE} | {@link GL14#GL_TEXTURE_DEPTH_SIZE TEXTURE_DEPTH_SIZE} | {@link GL30#GL_TEXTURE_STENCIL_SIZE TEXTURE_STENCIL_SIZE} |
| {@link GL30#GL_TEXTURE_SHARED_SIZE TEXTURE_SHARED_SIZE} | {@link GL30#GL_TEXTURE_ALPHA_TYPE TEXTURE_ALPHA_TYPE} | {@link GL30#GL_TEXTURE_DEPTH_TYPE TEXTURE_DEPTH_TYPE} | {@link GL13#GL_TEXTURE_COMPRESSED TEXTURE_COMPRESSED} |
| {@link GL13#GL_TEXTURE_COMPRESSED_IMAGE_SIZE TEXTURE_COMPRESSED_IMAGE_SIZE} | {@link GL31#GL_TEXTURE_BUFFER_DATA_STORE_BINDING TEXTURE_BUFFER_DATA_STORE_BINDING} | {@link GL43#GL_TEXTURE_BUFFER_OFFSET TEXTURE_BUFFER_OFFSET} | {@link GL43#GL_TEXTURE_BUFFER_SIZE TEXTURE_BUFFER_SIZE} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
| {@link GL42#GL_IMAGE_FORMAT_COMPATIBILITY_TYPE IMAGE_FORMAT_COMPATIBILITY_TYPE} | {@link GL42#GL_TEXTURE_IMMUTABLE_FORMAT TEXTURE_IMMUTABLE_FORMAT} | {@link GL43#GL_TEXTURE_IMMUTABLE_LEVELS TEXTURE_IMMUTABLE_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LEVEL TEXTURE_VIEW_MIN_LEVEL} |
| {@link GL43#GL_TEXTURE_VIEW_NUM_LEVELS TEXTURE_VIEW_NUM_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LAYER TEXTURE_VIEW_MIN_LAYER} | {@link GL43#GL_TEXTURE_VIEW_NUM_LAYERS TEXTURE_VIEW_NUM_LAYERS} |
| {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} | {@link GL11#GL_TEXTURE_BORDER_COLOR TEXTURE_BORDER_COLOR} | {@link GL14#GL_TEXTURE_COMPARE_MODE TEXTURE_COMPARE_MODE} | {@link GL14#GL_TEXTURE_COMPARE_FUNC TEXTURE_COMPARE_FUNC} |
| {@link GL14#GL_TEXTURE_LOD_BIAS TEXTURE_LOD_BIAS} | {@link GL11#GL_TEXTURE_MAG_FILTER TEXTURE_MAG_FILTER} | {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} | {@link GL12#GL_TEXTURE_MAX_LOD TEXTURE_MAX_LOD} |
| {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} | {@link GL12#GL_TEXTURE_MIN_LOD TEXTURE_MIN_LOD} | {@link GL33#GL_TEXTURE_SWIZZLE_R TEXTURE_SWIZZLE_R} | {@link GL33#GL_TEXTURE_SWIZZLE_G TEXTURE_SWIZZLE_G} |
| {@link GL33#GL_TEXTURE_SWIZZLE_B TEXTURE_SWIZZLE_B} | {@link GL33#GL_TEXTURE_SWIZZLE_A TEXTURE_SWIZZLE_A} | {@link GL33#GL_TEXTURE_SWIZZLE_RGBA TEXTURE_SWIZZLE_RGBA} | {@link GL11#GL_TEXTURE_WRAP_S TEXTURE_WRAP_S} |
| {@link GL11#GL_TEXTURE_WRAP_T TEXTURE_WRAP_T} | {@link GL12#GL_TEXTURE_WRAP_R TEXTURE_WRAP_R} | {@link GL14#GL_DEPTH_TEXTURE_MODE DEPTH_TEXTURE_MODE} | {@link GL14#GL_GENERATE_MIPMAP GENERATE_MIPMAP} |
| {@link GL42#GL_IMAGE_FORMAT_COMPATIBILITY_TYPE IMAGE_FORMAT_COMPATIBILITY_TYPE} | {@link GL42#GL_TEXTURE_IMMUTABLE_FORMAT TEXTURE_IMMUTABLE_FORMAT} | {@link GL43#GL_TEXTURE_IMMUTABLE_LEVELS TEXTURE_IMMUTABLE_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LEVEL TEXTURE_VIEW_MIN_LEVEL} |
| {@link GL43#GL_TEXTURE_VIEW_NUM_LEVELS TEXTURE_VIEW_NUM_LEVELS} | {@link GL43#GL_TEXTURE_VIEW_MIN_LAYER TEXTURE_VIEW_MIN_LAYER} | {@link GL43#GL_TEXTURE_VIEW_NUM_LAYERS TEXTURE_VIEW_NUM_LAYERS} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| 1 | 2 | 3 | 4 | {@link GL12#GL_BGRA BGRA} |
| {@link GL15#GL_ELEMENT_ARRAY_BUFFER_BINDING ELEMENT_ARRAY_BUFFER_BINDING} |
| {@link GL15#GL_ELEMENT_ARRAY_BUFFER_BINDING ELEMENT_ARRAY_BUFFER_BINDING} |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_ENABLED VERTEX_ATTRIB_ARRAY_ENABLED} | {@link GL20#GL_VERTEX_ATTRIB_ARRAY_SIZE VERTEX_ATTRIB_ARRAY_SIZE}, |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_STRIDE VERTEX_ATTRIB_ARRAY_STRIDE} | {@link GL20#GL_VERTEX_ATTRIB_ARRAY_TYPE VERTEX_ATTRIB_ARRAY_TYPE} |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_NORMALIZED VERTEX_ATTRIB_ARRAY_NORMALIZED} | {@link GL30#GL_VERTEX_ATTRIB_ARRAY_INTEGER VERTEX_ATTRIB_ARRAY_INTEGER} |
| {@link GL33#GL_VERTEX_ATTRIB_ARRAY_DIVISOR VERTEX_ATTRIB_ARRAY_DIVISOR} | {@link GL43#GL_VERTEX_ATTRIB_ARRAY_LONG VERTEX_ATTRIB_ARRAY_LONG} |
| {@link GL43#GL_VERTEX_ATTRIB_RELATIVE_OFFSET VERTEX_ATTRIB_RELATIVE_OFFSET} |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_ENABLED VERTEX_ATTRIB_ARRAY_ENABLED} | {@link GL20#GL_VERTEX_ATTRIB_ARRAY_SIZE VERTEX_ATTRIB_ARRAY_SIZE}, |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_STRIDE VERTEX_ATTRIB_ARRAY_STRIDE} | {@link GL20#GL_VERTEX_ATTRIB_ARRAY_TYPE VERTEX_ATTRIB_ARRAY_TYPE} |
| {@link GL20#GL_VERTEX_ATTRIB_ARRAY_NORMALIZED VERTEX_ATTRIB_ARRAY_NORMALIZED} | {@link GL30#GL_VERTEX_ATTRIB_ARRAY_INTEGER VERTEX_ATTRIB_ARRAY_INTEGER} |
| {@link GL33#GL_VERTEX_ATTRIB_ARRAY_DIVISOR VERTEX_ATTRIB_ARRAY_DIVISOR} | {@link GL43#GL_VERTEX_ATTRIB_ARRAY_LONG VERTEX_ATTRIB_ARRAY_LONG} |
| {@link GL43#GL_VERTEX_ATTRIB_RELATIVE_OFFSET VERTEX_ATTRIB_RELATIVE_OFFSET} |
| {@link GL43#GL_VERTEX_BINDING_OFFSET VERTEX_BINDING_OFFSET} |
| {@link GL43#GL_VERTEX_BINDING_OFFSET VERTEX_BINDING_OFFSET} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
| {@link GL15#GL_SAMPLES_PASSED SAMPLES_PASSED} | {@link GL30#GL_PRIMITIVES_GENERATED PRIMITIVES_GENERATED} | {@link GL30#GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN} | {@link GL33#GL_TIME_ELAPSED TIME_ELAPSED} |
| {@link GL33#GL_TIMESTAMP TIMESTAMP} | {@link GL33#GL_ANY_SAMPLES_PASSED ANY_SAMPLES_PASSED} | {@link GL43#GL_ANY_SAMPLES_PASSED_CONSERVATIVE ANY_SAMPLES_PASSED_CONSERVATIVE} |
First, it narrows the region under consideration so that only reads/writes of prior fragment shaders that are invoked for a smaller region of the + * framebuffer will be completed/reflected prior to subsequent reads/write of following fragment shaders. The size of the region is implementation + * dependent and may be as small as one framebuffer pixel.
+ * + *Second, it only applies to memory transactions that may be read by or written by a fragment shader.
+ * + *When barriers is {@link GL42#GL_ALL_BARRIER_BITS ALL_BARRIER_BITS}, shader memory accesses will be synchronized relative to all these barrier bits, but not to other + * barrier bits specific to {@link GL42C#glMemoryBarrier MemoryBarrier}. This implies that reads/writes for scatter/gather-like algorithms may or may not be + * completed/reflected after a MemoryBarrierByRegion command. However, for uses such as deferred shading, where a linked list of visible + * surfaces with the head at a framebuffer address may be constructed, and the entirety of the list is only dependent on previous executions at that + * framebuffer address, MemoryBarrierByRegion may be significantly more efficient than {@link GL42C#glMemoryBarrier MemoryBarrier}.
+ * + * @param barriers the barriers to insert. One or more of:| {@link GL42#GL_ATOMIC_COUNTER_BARRIER_BIT ATOMIC_COUNTER_BARRIER_BIT} | {@link GL42#GL_FRAMEBUFFER_BARRIER_BIT FRAMEBUFFER_BARRIER_BIT} | {@link GL42#GL_SHADER_IMAGE_ACCESS_BARRIER_BIT SHADER_IMAGE_ACCESS_BARRIER_BIT} |
| {@link GL43#GL_SHADER_STORAGE_BARRIER_BIT SHADER_STORAGE_BARRIER_BIT} | {@link GL42#GL_TEXTURE_FETCH_BARRIER_BIT TEXTURE_FETCH_BARRIER_BIT} | {@link GL42#GL_UNIFORM_BARRIER_BIT UNIFORM_BARRIER_BIT} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
If a reset status other than NO_ERROR is returned and subsequent calls return NO_ERROR, the context reset was encountered and completed. If a reset + * status is repeatedly returned, the context may be in the process of resetting.
+ * + *Reset notification behavior is determined at context creation time, and may be queried by calling GetIntegerv with the symbolic constant + * {@link #GL_RESET_NOTIFICATION_STRATEGY RESET_NOTIFICATION_STRATEGY}.
+ * + *If the reset notification behavior is {@link #GL_NO_RESET_NOTIFICATION NO_RESET_NOTIFICATION}, then the implementation will never deliver notification of reset events, and + * GetGraphicsResetStatus will always return NO_ERROR.
+ * + *If the behavior is {@link #GL_LOSE_CONTEXT_ON_RESET LOSE_CONTEXT_ON_RESET}, a graphics reset will result in a lost context and require creating a new context as described + * above. In this case GetGraphicsResetStatus will return an appropriate value from those described above.
+ * + *If a graphics reset notification occurs in a context, a notification must also occur in all other contexts which share objects with that context.
+ * + *After a graphics reset has occurred on a context, subsequent GL commands on that context (or any context which shares with that context) will generate a + * {@link #GL_CONTEXT_LOST CONTEXT_LOST} error. Such commands will not have side effects (in particular, they will not modify memory passed by pointer for query results, + * and may not block indefinitely or cause termination of the application. Exceptions to this behavior include:
+ * + *| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
| {@link GL11#GL_TEXTURE_1D TEXTURE_1D} | {@link GL11#GL_TEXTURE_2D TEXTURE_2D} | {@link GL30#GL_TEXTURE_1D_ARRAY TEXTURE_1D_ARRAY} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_X TEXTURE_CUBE_MAP_POSITIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_X TEXTURE_CUBE_MAP_NEGATIVE_X} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Y TEXTURE_CUBE_MAP_POSITIVE_Y} |
| {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Y TEXTURE_CUBE_MAP_NEGATIVE_Y} | {@link GL13#GL_TEXTURE_CUBE_MAP_POSITIVE_Z TEXTURE_CUBE_MAP_POSITIVE_Z} | {@link GL13#GL_TEXTURE_CUBE_MAP_NEGATIVE_Z TEXTURE_CUBE_MAP_NEGATIVE_Z} |
| {@link GL12#GL_TEXTURE_3D TEXTURE_3D} | {@link GL30#GL_TEXTURE_2D_ARRAY TEXTURE_2D_ARRAY} | {@link GL40#GL_TEXTURE_CUBE_MAP_ARRAY TEXTURE_CUBE_MAP_ARRAY} |
OpenGL 4.6 implementations support revision 4.60 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
{@code factor} scales the maximum depth slope of the polygon, and {@code units} scales an implementation-dependent constant that relates to the usable + * resolution of the depth buffer. The resulting values are summed to produce the polygon offset value, which may then be clamped to a minimum or maximum + * value specified by {@code clamp}.
+ * + *The values {@code factor}, {@code units}, and {@code clamp} may each be positive, negative, or zero. Calling the command {@link GL11C#glPolygonOffset PolygonOffset} is equivalent + * to calling the command {@code PolygonOffsetClamp} with clamp equal to zero.
+ * + * @param factor scales the maximum depth slope of the polygon + * @param units scales an implementation-dependent constant that relates to the usable resolution of the depth buffer + * @param clamp the minimum or maximum polygon offset value + * + * @see Reference Page + */ + public static void glPolygonOffsetClamp(@NativeType("GLfloat") float factor, @NativeType("GLfloat") float units, @NativeType("GLfloat") float clamp) { + GL46C.glPolygonOffsetClamp(factor, units, clamp); + } + + // --- [ glSpecializeShader ] --- + + /** + * Unsafe version of: {@link #glSpecializeShader SpecializeShader} + * + * @param numSpecializationConstants the number of specialization constants whose values to set in this call + */ + public static void nglSpecializeShader(int shader, long pEntryPoint, int numSpecializationConstants, long pConstantIndex, long pConstantValue) { + GL46C.nglSpecializeShader(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue); + } + + /** + * Specializes a shader created from a SPIR-V module. + * + *Shaders associated with SPIR-V modules must be specialized before they can be linked into a program object. It is not necessary to specialize the + * shader before it is attached to a program object. Once specialized, a shader may not be specialized again without first re-associating the original + * SPIR-V module with it, through {@link GL41C#glShaderBinary ShaderBinary}.
+ * + *Specialization does two things:
+ * + *On successful shader specialization, the compile status for shader is set to {@link GL11#GL_TRUE TRUE}. On failure, the compile status for shader is set to {@link GL11#GL_FALSE FALSE} and + * additional information about the cause of the failure may be available in the shader compilation log.
+ * + * @param shader the name of a shader object containing unspecialized SPIR-V as created from a successful call to {@link GL41C#glShaderBinary ShaderBinary} to which a SPIR-V module was + * passed + * @param pEntryPoint a pointer to a null-terminated UTF-8 string specifying the name of the entry point in the SPIR-V module to use for this shader + * @param pConstantIndex is a pointer to an array of {@code numSpecializationConstants} unsigned integers, each holding the index of a specialization constant in the SPIR-V + * module whose value to set. + * + *Specialization constants not referenced by {@code pConstantIndex} retain their default values as specified in the SPIR-V module.
+ * @param pConstantValue an entry in {@code pConstantValue} is used to set the value of the specialization constant indexed by the corresponding entry in + * {@code pConstantIndex}. + * + *Although this array is of unsigned integer, each entry is bitcast to the appropriate type for the module, and therefore, floating-point constants + * may be set by including their IEEE-754 bit representation in the {@code pConstantValue} array.
+ * + * @see Reference Page + */ + public static void glSpecializeShader(@NativeType("GLuint") int shader, @NativeType("GLchar const *") ByteBuffer pEntryPoint, @NativeType("GLuint const *") IntBuffer pConstantIndex, @NativeType("GLuint const *") IntBuffer pConstantValue) { + GL46C.glSpecializeShader(shader, pEntryPoint, pConstantIndex, pConstantValue); + } + + /** + * Specializes a shader created from a SPIR-V module. + * + *Shaders associated with SPIR-V modules must be specialized before they can be linked into a program object. It is not necessary to specialize the + * shader before it is attached to a program object. Once specialized, a shader may not be specialized again without first re-associating the original + * SPIR-V module with it, through {@link GL41C#glShaderBinary ShaderBinary}.
+ * + *Specialization does two things:
+ * + *On successful shader specialization, the compile status for shader is set to {@link GL11#GL_TRUE TRUE}. On failure, the compile status for shader is set to {@link GL11#GL_FALSE FALSE} and + * additional information about the cause of the failure may be available in the shader compilation log.
+ * + * @param shader the name of a shader object containing unspecialized SPIR-V as created from a successful call to {@link GL41C#glShaderBinary ShaderBinary} to which a SPIR-V module was + * passed + * @param pEntryPoint a pointer to a null-terminated UTF-8 string specifying the name of the entry point in the SPIR-V module to use for this shader + * @param pConstantIndex is a pointer to an array of {@code numSpecializationConstants} unsigned integers, each holding the index of a specialization constant in the SPIR-V + * module whose value to set. + * + *Specialization constants not referenced by {@code pConstantIndex} retain their default values as specified in the SPIR-V module.
+ * @param pConstantValue an entry in {@code pConstantValue} is used to set the value of the specialization constant indexed by the corresponding entry in + * {@code pConstantIndex}. + * + *Although this array is of unsigned integer, each entry is bitcast to the appropriate type for the module, and therefore, floating-point constants + * may be set by including their IEEE-754 bit representation in the {@code pConstantValue} array.
+ * + * @see Reference Page + */ + public static void glSpecializeShader(@NativeType("GLuint") int shader, @NativeType("GLchar const *") CharSequence pEntryPoint, @NativeType("GLuint const *") IntBuffer pConstantIndex, @NativeType("GLuint const *") IntBuffer pConstantValue) { + GL46C.glSpecializeShader(shader, pEntryPoint, pConstantIndex, pConstantValue); + } + + /** + * Array version of: {@link #glMultiDrawArraysIndirectCount MultiDrawArraysIndirectCount} + * + * @see Reference Page + */ + public static void glMultiDrawArraysIndirectCount(@NativeType("GLenum") int mode, @NativeType("void const *") int[] indirect, @NativeType("GLintptr") long drawcount, @NativeType("GLsizei") int maxdrawcount, @NativeType("GLsizei") int stride) { + GL46C.glMultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride); + } + + /** + * Array version of: {@link #glMultiDrawElementsIndirectCount MultiDrawElementsIndirectCount} + * + * @see Reference Page + */ + public static void glMultiDrawElementsIndirectCount(@NativeType("GLenum") int mode, @NativeType("GLenum") int type, @NativeType("void const *") int[] indirect, @NativeType("GLintptr") long drawcount, @NativeType("GLsizei") int maxdrawcount, @NativeType("GLsizei") int stride) { + GL46C.glMultiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount, stride); + } + + /** + * Array version of: {@link #glSpecializeShader SpecializeShader} + * + * @see Reference Page + */ + public static void glSpecializeShader(@NativeType("GLuint") int shader, @NativeType("GLchar const *") ByteBuffer pEntryPoint, @NativeType("GLuint const *") int[] pConstantIndex, @NativeType("GLuint const *") int[] pConstantValue) { + GL46C.glSpecializeShader(shader, pEntryPoint, pConstantIndex, pConstantValue); + } + + /** + * Array version of: {@link #glSpecializeShader SpecializeShader} + * + * @see Reference Page + */ + public static void glSpecializeShader(@NativeType("GLuint") int shader, @NativeType("GLchar const *") CharSequence pEntryPoint, @NativeType("GLuint const *") int[] pConstantIndex, @NativeType("GLuint const *") int[] pConstantValue) { + GL46C.glSpecializeShader(shader, pEntryPoint, pConstantIndex, pConstantValue); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL46C.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL46C.java new file mode 100644 index 00000000..72aadc47 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GL46C.java @@ -0,0 +1,422 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * The OpenGL functionality up to version 4.6. Includes only Core Profile symbols. + * + *OpenGL 4.6 implementations support revision 4.60 of the OpenGL Shading Language.
+ * + *Extensions promoted to core in this release:
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
{@code factor} scales the maximum depth slope of the polygon, and {@code units} scales an implementation-dependent constant that relates to the usable + * resolution of the depth buffer. The resulting values are summed to produce the polygon offset value, which may then be clamped to a minimum or maximum + * value specified by {@code clamp}.
+ * + *The values {@code factor}, {@code units}, and {@code clamp} may each be positive, negative, or zero. Calling the command {@link GL11C#glPolygonOffset PolygonOffset} is equivalent + * to calling the command {@code PolygonOffsetClamp} with clamp equal to zero.
+ * + * @param factor scales the maximum depth slope of the polygon + * @param units scales an implementation-dependent constant that relates to the usable resolution of the depth buffer + * @param clamp the minimum or maximum polygon offset value + * + * @see Reference Page + */ + public static native void glPolygonOffsetClamp(@NativeType("GLfloat") float factor, @NativeType("GLfloat") float units, @NativeType("GLfloat") float clamp); + + // --- [ glSpecializeShader ] --- + + /** + * Unsafe version of: {@link #glSpecializeShader SpecializeShader} + * + * @param numSpecializationConstants the number of specialization constants whose values to set in this call + */ + public static native void nglSpecializeShader(int shader, long pEntryPoint, int numSpecializationConstants, long pConstantIndex, long pConstantValue); + + /** + * Specializes a shader created from a SPIR-V module. + * + *Shaders associated with SPIR-V modules must be specialized before they can be linked into a program object. It is not necessary to specialize the + * shader before it is attached to a program object. Once specialized, a shader may not be specialized again without first re-associating the original + * SPIR-V module with it, through {@link GL41C#glShaderBinary ShaderBinary}.
+ * + *Specialization does two things:
+ * + *On successful shader specialization, the compile status for shader is set to {@link GL11#GL_TRUE TRUE}. On failure, the compile status for shader is set to {@link GL11#GL_FALSE FALSE} and + * additional information about the cause of the failure may be available in the shader compilation log.
+ * + * @param shader the name of a shader object containing unspecialized SPIR-V as created from a successful call to {@link GL41C#glShaderBinary ShaderBinary} to which a SPIR-V module was + * passed + * @param pEntryPoint a pointer to a null-terminated UTF-8 string specifying the name of the entry point in the SPIR-V module to use for this shader + * @param pConstantIndex is a pointer to an array of {@code numSpecializationConstants} unsigned integers, each holding the index of a specialization constant in the SPIR-V + * module whose value to set. + * + *Specialization constants not referenced by {@code pConstantIndex} retain their default values as specified in the SPIR-V module.
+ * @param pConstantValue an entry in {@code pConstantValue} is used to set the value of the specialization constant indexed by the corresponding entry in + * {@code pConstantIndex}. + * + *Although this array is of unsigned integer, each entry is bitcast to the appropriate type for the module, and therefore, floating-point constants + * may be set by including their IEEE-754 bit representation in the {@code pConstantValue} array.
+ * + * @see Reference Page + */ + public static void glSpecializeShader(@NativeType("GLuint") int shader, @NativeType("GLchar const *") ByteBuffer pEntryPoint, @NativeType("GLuint const *") IntBuffer pConstantIndex, @NativeType("GLuint const *") IntBuffer pConstantValue) { + if (CHECKS) { + checkNT1(pEntryPoint); + check(pConstantValue, pConstantIndex.remaining()); + } + nglSpecializeShader(shader, memAddress(pEntryPoint), pConstantIndex.remaining(), memAddress(pConstantIndex), memAddress(pConstantValue)); + } + + /** + * Specializes a shader created from a SPIR-V module. + * + *Shaders associated with SPIR-V modules must be specialized before they can be linked into a program object. It is not necessary to specialize the + * shader before it is attached to a program object. Once specialized, a shader may not be specialized again without first re-associating the original + * SPIR-V module with it, through {@link GL41C#glShaderBinary ShaderBinary}.
+ * + *Specialization does two things:
+ * + *On successful shader specialization, the compile status for shader is set to {@link GL11#GL_TRUE TRUE}. On failure, the compile status for shader is set to {@link GL11#GL_FALSE FALSE} and + * additional information about the cause of the failure may be available in the shader compilation log.
+ * + * @param shader the name of a shader object containing unspecialized SPIR-V as created from a successful call to {@link GL41C#glShaderBinary ShaderBinary} to which a SPIR-V module was + * passed + * @param pEntryPoint a pointer to a null-terminated UTF-8 string specifying the name of the entry point in the SPIR-V module to use for this shader + * @param pConstantIndex is a pointer to an array of {@code numSpecializationConstants} unsigned integers, each holding the index of a specialization constant in the SPIR-V + * module whose value to set. + * + *Specialization constants not referenced by {@code pConstantIndex} retain their default values as specified in the SPIR-V module.
+ * @param pConstantValue an entry in {@code pConstantValue} is used to set the value of the specialization constant indexed by the corresponding entry in + * {@code pConstantIndex}. + * + *Although this array is of unsigned integer, each entry is bitcast to the appropriate type for the module, and therefore, floating-point constants + * may be set by including their IEEE-754 bit representation in the {@code pConstantValue} array.
+ * + * @see Reference Page + */ + public static void glSpecializeShader(@NativeType("GLuint") int shader, @NativeType("GLchar const *") CharSequence pEntryPoint, @NativeType("GLuint const *") IntBuffer pConstantIndex, @NativeType("GLuint const *") IntBuffer pConstantValue) { + if (CHECKS) { + check(pConstantValue, pConstantIndex.remaining()); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8(pEntryPoint, true); + long pEntryPointEncoded = stack.getPointerAddress(); + nglSpecializeShader(shader, pEntryPointEncoded, pConstantIndex.remaining(), memAddress(pConstantIndex), memAddress(pConstantValue)); + } finally { + stack.setPointer(stackPointer); + } + } + + /** + * Array version of: {@link #glMultiDrawArraysIndirectCount MultiDrawArraysIndirectCount} + * + * @see Reference Page + */ + public static void glMultiDrawArraysIndirectCount(@NativeType("GLenum") int mode, @NativeType("void const *") int[] indirect, @NativeType("GLintptr") long drawcount, @NativeType("GLsizei") int maxdrawcount, @NativeType("GLsizei") int stride) { + long __functionAddress = GL.getICD().glMultiDrawArraysIndirectCount; + if (CHECKS) { + check(__functionAddress); + check(indirect, (maxdrawcount * (stride == 0 ? (4 * 4) : stride)) >> 2); + } + callPPV(mode, indirect, drawcount, maxdrawcount, stride, __functionAddress); + } + + /** + * Array version of: {@link #glMultiDrawElementsIndirectCount MultiDrawElementsIndirectCount} + * + * @see Reference Page + */ + public static void glMultiDrawElementsIndirectCount(@NativeType("GLenum") int mode, @NativeType("GLenum") int type, @NativeType("void const *") int[] indirect, @NativeType("GLintptr") long drawcount, @NativeType("GLsizei") int maxdrawcount, @NativeType("GLsizei") int stride) { + long __functionAddress = GL.getICD().glMultiDrawElementsIndirectCount; + if (CHECKS) { + check(__functionAddress); + check(indirect, (maxdrawcount * (stride == 0 ? (5 * 4) : stride)) >> 2); + } + callPPV(mode, type, indirect, drawcount, maxdrawcount, stride, __functionAddress); + } + + /** + * Array version of: {@link #glSpecializeShader SpecializeShader} + * + * @see Reference Page + */ + public static void glSpecializeShader(@NativeType("GLuint") int shader, @NativeType("GLchar const *") ByteBuffer pEntryPoint, @NativeType("GLuint const *") int[] pConstantIndex, @NativeType("GLuint const *") int[] pConstantValue) { + long __functionAddress = GL.getICD().glSpecializeShader; + if (CHECKS) { + check(__functionAddress); + checkNT1(pEntryPoint); + check(pConstantValue, pConstantIndex.length); + } + callPPPV(shader, memAddress(pEntryPoint), pConstantIndex.length, pConstantIndex, pConstantValue, __functionAddress); + } + + /** + * Array version of: {@link #glSpecializeShader SpecializeShader} + * + * @see Reference Page + */ + public static void glSpecializeShader(@NativeType("GLuint") int shader, @NativeType("GLchar const *") CharSequence pEntryPoint, @NativeType("GLuint const *") int[] pConstantIndex, @NativeType("GLuint const *") int[] pConstantValue) { + long __functionAddress = GL.getICD().glSpecializeShader; + if (CHECKS) { + check(__functionAddress); + check(pConstantValue, pConstantIndex.length); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8(pEntryPoint, true); + long pEntryPointEncoded = stack.getPointerAddress(); + callPPPV(shader, pEntryPointEncoded, pConstantIndex.length, pConstantIndex, pConstantValue, __functionAddress); + } finally { + stack.setPointer(stackPointer); + } + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLCapabilities.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLCapabilities.java new file mode 100644 index 00000000..e671da9f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLCapabilities.java @@ -0,0 +1,6844 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; +import java.util.Set; +import org.lwjgl.*; + +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** Defines the capabilities of an OpenGL context. */ +public final class GLCapabilities { + + public final long + glAccum, + glAlphaFunc, + glAreTexturesResident, + glArrayElement, + glBegin, + glBitmap, + glCallList, + glCallLists, + glClearAccum, + glClearIndex, + glClipPlane, + glColor3b, + glColor3s, + glColor3i, + glColor3f, + glColor3d, + glColor3ub, + glColor3us, + glColor3ui, + glColor3bv, + glColor3sv, + glColor3iv, + glColor3fv, + glColor3dv, + glColor3ubv, + glColor3usv, + glColor3uiv, + glColor4b, + glColor4s, + glColor4i, + glColor4f, + glColor4d, + glColor4ub, + glColor4us, + glColor4ui, + glColor4bv, + glColor4sv, + glColor4iv, + glColor4fv, + glColor4dv, + glColor4ubv, + glColor4usv, + glColor4uiv, + glColorMaterial, + glColorPointer, + glCopyPixels, + glDeleteLists, + glDisableClientState, + glDrawPixels, + glEdgeFlag, + glEdgeFlagv, + glEdgeFlagPointer, + glEnableClientState, + glEnd, + glEvalCoord1f, + glEvalCoord1fv, + glEvalCoord1d, + glEvalCoord1dv, + glEvalCoord2f, + glEvalCoord2fv, + glEvalCoord2d, + glEvalCoord2dv, + glEvalMesh1, + glEvalMesh2, + glEvalPoint1, + glEvalPoint2, + glFeedbackBuffer, + glFogi, + glFogiv, + glFogf, + glFogfv, + glGenLists, + glGetClipPlane, + glGetLightiv, + glGetLightfv, + glGetMapiv, + glGetMapfv, + glGetMapdv, + glGetMaterialiv, + glGetMaterialfv, + glGetPixelMapfv, + glGetPixelMapusv, + glGetPixelMapuiv, + glGetPolygonStipple, + glGetTexEnviv, + glGetTexEnvfv, + glGetTexGeniv, + glGetTexGenfv, + glGetTexGendv, + glIndexi, + glIndexub, + glIndexs, + glIndexf, + glIndexd, + glIndexiv, + glIndexubv, + glIndexsv, + glIndexfv, + glIndexdv, + glIndexMask, + glIndexPointer, + glInitNames, + glInterleavedArrays, + glIsList, + glLightModeli, + glLightModelf, + glLightModeliv, + glLightModelfv, + glLighti, + glLightf, + glLightiv, + glLightfv, + glLineStipple, + glListBase, + glLoadMatrixf, + glLoadMatrixd, + glLoadIdentity, + glLoadName, + glMap1f, + glMap1d, + glMap2f, + glMap2d, + glMapGrid1f, + glMapGrid1d, + glMapGrid2f, + glMapGrid2d, + glMateriali, + glMaterialf, + glMaterialiv, + glMaterialfv, + glMatrixMode, + glMultMatrixf, + glMultMatrixd, + glFrustum, + glNewList, + glEndList, + glNormal3f, + glNormal3b, + glNormal3s, + glNormal3i, + glNormal3d, + glNormal3fv, + glNormal3bv, + glNormal3sv, + glNormal3iv, + glNormal3dv, + glNormalPointer, + glOrtho, + glPassThrough, + glPixelMapfv, + glPixelMapusv, + glPixelMapuiv, + glPixelTransferi, + glPixelTransferf, + glPixelZoom, + glPolygonStipple, + glPushAttrib, + glPushClientAttrib, + glPopAttrib, + glPopClientAttrib, + glPopMatrix, + glPopName, + glPrioritizeTextures, + glPushMatrix, + glPushName, + glRasterPos2i, + glRasterPos2s, + glRasterPos2f, + glRasterPos2d, + glRasterPos2iv, + glRasterPos2sv, + glRasterPos2fv, + glRasterPos2dv, + glRasterPos3i, + glRasterPos3s, + glRasterPos3f, + glRasterPos3d, + glRasterPos3iv, + glRasterPos3sv, + glRasterPos3fv, + glRasterPos3dv, + glRasterPos4i, + glRasterPos4s, + glRasterPos4f, + glRasterPos4d, + glRasterPos4iv, + glRasterPos4sv, + glRasterPos4fv, + glRasterPos4dv, + glRecti, + glRects, + glRectf, + glRectd, + glRectiv, + glRectsv, + glRectfv, + glRectdv, + glRenderMode, + glRotatef, + glRotated, + glScalef, + glScaled, + glSelectBuffer, + glShadeModel, + glTexCoord1f, + glTexCoord1s, + glTexCoord1i, + glTexCoord1d, + glTexCoord1fv, + glTexCoord1sv, + glTexCoord1iv, + glTexCoord1dv, + glTexCoord2f, + glTexCoord2s, + glTexCoord2i, + glTexCoord2d, + glTexCoord2fv, + glTexCoord2sv, + glTexCoord2iv, + glTexCoord2dv, + glTexCoord3f, + glTexCoord3s, + glTexCoord3i, + glTexCoord3d, + glTexCoord3fv, + glTexCoord3sv, + glTexCoord3iv, + glTexCoord3dv, + glTexCoord4f, + glTexCoord4s, + glTexCoord4i, + glTexCoord4d, + glTexCoord4fv, + glTexCoord4sv, + glTexCoord4iv, + glTexCoord4dv, + glTexCoordPointer, + glTexEnvi, + glTexEnviv, + glTexEnvf, + glTexEnvfv, + glTexGeni, + glTexGeniv, + glTexGenf, + glTexGenfv, + glTexGend, + glTexGendv, + glTranslatef, + glTranslated, + glVertex2f, + glVertex2s, + glVertex2i, + glVertex2d, + glVertex2fv, + glVertex2sv, + glVertex2iv, + glVertex2dv, + glVertex3f, + glVertex3s, + glVertex3i, + glVertex3d, + glVertex3fv, + glVertex3sv, + glVertex3iv, + glVertex3dv, + glVertex4f, + glVertex4s, + glVertex4i, + glVertex4d, + glVertex4fv, + glVertex4sv, + glVertex4iv, + glVertex4dv, + glVertexPointer, + glEnable, + glDisable, + glBindTexture, + glBlendFunc, + glClear, + glClearColor, + glClearDepth, + glClearStencil, + glColorMask, + glCullFace, + glDepthFunc, + glDepthMask, + glDepthRange, + glDrawArrays, + glDrawBuffer, + glDrawElements, + glFinish, + glFlush, + glFrontFace, + glGenTextures, + glDeleteTextures, + glGetBooleanv, + glGetFloatv, + glGetIntegerv, + glGetDoublev, + glGetError, + glGetPointerv, + glGetString, + glGetTexImage, + glGetTexLevelParameteriv, + glGetTexLevelParameterfv, + glGetTexParameteriv, + glGetTexParameterfv, + glHint, + glIsEnabled, + glIsTexture, + glLineWidth, + glLogicOp, + glPixelStorei, + glPixelStoref, + glPointSize, + glPolygonMode, + glPolygonOffset, + glReadBuffer, + glReadPixels, + glScissor, + glStencilFunc, + glStencilMask, + glStencilOp, + glTexImage1D, + glTexImage2D, + glCopyTexImage1D, + glCopyTexImage2D, + glCopyTexSubImage1D, + glCopyTexSubImage2D, + glTexParameteri, + glTexParameteriv, + glTexParameterf, + glTexParameterfv, + glTexSubImage1D, + glTexSubImage2D, + glViewport, + glTexImage3D, + glTexSubImage3D, + glCopyTexSubImage3D, + glDrawRangeElements, + glClientActiveTexture, + glMultiTexCoord1f, + glMultiTexCoord1s, + glMultiTexCoord1i, + glMultiTexCoord1d, + glMultiTexCoord1fv, + glMultiTexCoord1sv, + glMultiTexCoord1iv, + glMultiTexCoord1dv, + glMultiTexCoord2f, + glMultiTexCoord2s, + glMultiTexCoord2i, + glMultiTexCoord2d, + glMultiTexCoord2fv, + glMultiTexCoord2sv, + glMultiTexCoord2iv, + glMultiTexCoord2dv, + glMultiTexCoord3f, + glMultiTexCoord3s, + glMultiTexCoord3i, + glMultiTexCoord3d, + glMultiTexCoord3fv, + glMultiTexCoord3sv, + glMultiTexCoord3iv, + glMultiTexCoord3dv, + glMultiTexCoord4f, + glMultiTexCoord4s, + glMultiTexCoord4i, + glMultiTexCoord4d, + glMultiTexCoord4fv, + glMultiTexCoord4sv, + glMultiTexCoord4iv, + glMultiTexCoord4dv, + glLoadTransposeMatrixf, + glLoadTransposeMatrixd, + glMultTransposeMatrixf, + glMultTransposeMatrixd, + glCompressedTexImage3D, + glCompressedTexImage2D, + glCompressedTexImage1D, + glCompressedTexSubImage3D, + glCompressedTexSubImage2D, + glCompressedTexSubImage1D, + glGetCompressedTexImage, + glSampleCoverage, + glActiveTexture, + glFogCoordf, + glFogCoordd, + glFogCoordfv, + glFogCoorddv, + glFogCoordPointer, + glSecondaryColor3b, + glSecondaryColor3s, + glSecondaryColor3i, + glSecondaryColor3f, + glSecondaryColor3d, + glSecondaryColor3ub, + glSecondaryColor3us, + glSecondaryColor3ui, + glSecondaryColor3bv, + glSecondaryColor3sv, + glSecondaryColor3iv, + glSecondaryColor3fv, + glSecondaryColor3dv, + glSecondaryColor3ubv, + glSecondaryColor3usv, + glSecondaryColor3uiv, + glSecondaryColorPointer, + glWindowPos2i, + glWindowPos2s, + glWindowPos2f, + glWindowPos2d, + glWindowPos2iv, + glWindowPos2sv, + glWindowPos2fv, + glWindowPos2dv, + glWindowPos3i, + glWindowPos3s, + glWindowPos3f, + glWindowPos3d, + glWindowPos3iv, + glWindowPos3sv, + glWindowPos3fv, + glWindowPos3dv, + glBlendColor, + glBlendEquation, + glMultiDrawArrays, + glMultiDrawElements, + glPointParameterf, + glPointParameteri, + glPointParameterfv, + glPointParameteriv, + glBlendFuncSeparate, + glBindBuffer, + glDeleteBuffers, + glGenBuffers, + glIsBuffer, + glBufferData, + glBufferSubData, + glGetBufferSubData, + glMapBuffer, + glUnmapBuffer, + glGetBufferParameteriv, + glGetBufferPointerv, + glGenQueries, + glDeleteQueries, + glIsQuery, + glBeginQuery, + glEndQuery, + glGetQueryiv, + glGetQueryObjectiv, + glGetQueryObjectuiv, + glCreateProgram, + glDeleteProgram, + glIsProgram, + glCreateShader, + glDeleteShader, + glIsShader, + glAttachShader, + glDetachShader, + glShaderSource, + glCompileShader, + glLinkProgram, + glUseProgram, + glValidateProgram, + glUniform1f, + glUniform2f, + glUniform3f, + glUniform4f, + glUniform1i, + glUniform2i, + glUniform3i, + glUniform4i, + glUniform1fv, + glUniform2fv, + glUniform3fv, + glUniform4fv, + glUniform1iv, + glUniform2iv, + glUniform3iv, + glUniform4iv, + glUniformMatrix2fv, + glUniformMatrix3fv, + glUniformMatrix4fv, + glGetShaderiv, + glGetProgramiv, + glGetShaderInfoLog, + glGetProgramInfoLog, + glGetAttachedShaders, + glGetUniformLocation, + glGetActiveUniform, + glGetUniformfv, + glGetUniformiv, + glGetShaderSource, + glVertexAttrib1f, + glVertexAttrib1s, + glVertexAttrib1d, + glVertexAttrib2f, + glVertexAttrib2s, + glVertexAttrib2d, + glVertexAttrib3f, + glVertexAttrib3s, + glVertexAttrib3d, + glVertexAttrib4f, + glVertexAttrib4s, + glVertexAttrib4d, + glVertexAttrib4Nub, + glVertexAttrib1fv, + glVertexAttrib1sv, + glVertexAttrib1dv, + glVertexAttrib2fv, + glVertexAttrib2sv, + glVertexAttrib2dv, + glVertexAttrib3fv, + glVertexAttrib3sv, + glVertexAttrib3dv, + glVertexAttrib4fv, + glVertexAttrib4sv, + glVertexAttrib4dv, + glVertexAttrib4iv, + glVertexAttrib4bv, + glVertexAttrib4ubv, + glVertexAttrib4usv, + glVertexAttrib4uiv, + glVertexAttrib4Nbv, + glVertexAttrib4Nsv, + glVertexAttrib4Niv, + glVertexAttrib4Nubv, + glVertexAttrib4Nusv, + glVertexAttrib4Nuiv, + glVertexAttribPointer, + glEnableVertexAttribArray, + glDisableVertexAttribArray, + glBindAttribLocation, + glGetActiveAttrib, + glGetAttribLocation, + glGetVertexAttribiv, + glGetVertexAttribfv, + glGetVertexAttribdv, + glGetVertexAttribPointerv, + glDrawBuffers, + glBlendEquationSeparate, + glStencilOpSeparate, + glStencilFuncSeparate, + glStencilMaskSeparate, + glUniformMatrix2x3fv, + glUniformMatrix3x2fv, + glUniformMatrix2x4fv, + glUniformMatrix4x2fv, + glUniformMatrix3x4fv, + glUniformMatrix4x3fv, + glGetStringi, + glClearBufferiv, + glClearBufferuiv, + glClearBufferfv, + glClearBufferfi, + glVertexAttribI1i, + glVertexAttribI2i, + glVertexAttribI3i, + glVertexAttribI4i, + glVertexAttribI1ui, + glVertexAttribI2ui, + glVertexAttribI3ui, + glVertexAttribI4ui, + glVertexAttribI1iv, + glVertexAttribI2iv, + glVertexAttribI3iv, + glVertexAttribI4iv, + glVertexAttribI1uiv, + glVertexAttribI2uiv, + glVertexAttribI3uiv, + glVertexAttribI4uiv, + glVertexAttribI4bv, + glVertexAttribI4sv, + glVertexAttribI4ubv, + glVertexAttribI4usv, + glVertexAttribIPointer, + glGetVertexAttribIiv, + glGetVertexAttribIuiv, + glUniform1ui, + glUniform2ui, + glUniform3ui, + glUniform4ui, + glUniform1uiv, + glUniform2uiv, + glUniform3uiv, + glUniform4uiv, + glGetUniformuiv, + glBindFragDataLocation, + glGetFragDataLocation, + glBeginConditionalRender, + glEndConditionalRender, + glMapBufferRange, + glFlushMappedBufferRange, + glClampColor, + glIsRenderbuffer, + glBindRenderbuffer, + glDeleteRenderbuffers, + glGenRenderbuffers, + glRenderbufferStorage, + glRenderbufferStorageMultisample, + glGetRenderbufferParameteriv, + glIsFramebuffer, + glBindFramebuffer, + glDeleteFramebuffers, + glGenFramebuffers, + glCheckFramebufferStatus, + glFramebufferTexture1D, + glFramebufferTexture2D, + glFramebufferTexture3D, + glFramebufferTextureLayer, + glFramebufferRenderbuffer, + glGetFramebufferAttachmentParameteriv, + glBlitFramebuffer, + glGenerateMipmap, + glTexParameterIiv, + glTexParameterIuiv, + glGetTexParameterIiv, + glGetTexParameterIuiv, + glColorMaski, + glGetBooleani_v, + glGetIntegeri_v, + glEnablei, + glDisablei, + glIsEnabledi, + glBindBufferRange, + glBindBufferBase, + glBeginTransformFeedback, + glEndTransformFeedback, + glTransformFeedbackVaryings, + glGetTransformFeedbackVarying, + glBindVertexArray, + glDeleteVertexArrays, + glGenVertexArrays, + glIsVertexArray, + glDrawArraysInstanced, + glDrawElementsInstanced, + glCopyBufferSubData, + glPrimitiveRestartIndex, + glTexBuffer, + glGetUniformIndices, + glGetActiveUniformsiv, + glGetActiveUniformName, + glGetUniformBlockIndex, + glGetActiveUniformBlockiv, + glGetActiveUniformBlockName, + glUniformBlockBinding, + glGetBufferParameteri64v, + glDrawElementsBaseVertex, + glDrawRangeElementsBaseVertex, + glDrawElementsInstancedBaseVertex, + glMultiDrawElementsBaseVertex, + glProvokingVertex, + glTexImage2DMultisample, + glTexImage3DMultisample, + glGetMultisamplefv, + glSampleMaski, + glFramebufferTexture, + glFenceSync, + glIsSync, + glDeleteSync, + glClientWaitSync, + glWaitSync, + glGetInteger64v, + glGetInteger64i_v, + glGetSynciv, + glVertexP2ui, + glVertexP3ui, + glVertexP4ui, + glVertexP2uiv, + glVertexP3uiv, + glVertexP4uiv, + glTexCoordP1ui, + glTexCoordP2ui, + glTexCoordP3ui, + glTexCoordP4ui, + glTexCoordP1uiv, + glTexCoordP2uiv, + glTexCoordP3uiv, + glTexCoordP4uiv, + glMultiTexCoordP1ui, + glMultiTexCoordP2ui, + glMultiTexCoordP3ui, + glMultiTexCoordP4ui, + glMultiTexCoordP1uiv, + glMultiTexCoordP2uiv, + glMultiTexCoordP3uiv, + glMultiTexCoordP4uiv, + glNormalP3ui, + glNormalP3uiv, + glColorP3ui, + glColorP4ui, + glColorP3uiv, + glColorP4uiv, + glSecondaryColorP3ui, + glSecondaryColorP3uiv, + glBindFragDataLocationIndexed, + glGetFragDataIndex, + glGenSamplers, + glDeleteSamplers, + glIsSampler, + glBindSampler, + glSamplerParameteri, + glSamplerParameterf, + glSamplerParameteriv, + glSamplerParameterfv, + glSamplerParameterIiv, + glSamplerParameterIuiv, + glGetSamplerParameteriv, + glGetSamplerParameterfv, + glGetSamplerParameterIiv, + glGetSamplerParameterIuiv, + glQueryCounter, + glGetQueryObjecti64v, + glGetQueryObjectui64v, + glVertexAttribDivisor, + glVertexAttribP1ui, + glVertexAttribP2ui, + glVertexAttribP3ui, + glVertexAttribP4ui, + glVertexAttribP1uiv, + glVertexAttribP2uiv, + glVertexAttribP3uiv, + glVertexAttribP4uiv, + glBlendEquationi, + glBlendEquationSeparatei, + glBlendFunci, + glBlendFuncSeparatei, + glDrawArraysIndirect, + glDrawElementsIndirect, + glUniform1d, + glUniform2d, + glUniform3d, + glUniform4d, + glUniform1dv, + glUniform2dv, + glUniform3dv, + glUniform4dv, + glUniformMatrix2dv, + glUniformMatrix3dv, + glUniformMatrix4dv, + glUniformMatrix2x3dv, + glUniformMatrix2x4dv, + glUniformMatrix3x2dv, + glUniformMatrix3x4dv, + glUniformMatrix4x2dv, + glUniformMatrix4x3dv, + glGetUniformdv, + glMinSampleShading, + glGetSubroutineUniformLocation, + glGetSubroutineIndex, + glGetActiveSubroutineUniformiv, + glGetActiveSubroutineUniformName, + glGetActiveSubroutineName, + glUniformSubroutinesuiv, + glGetUniformSubroutineuiv, + glGetProgramStageiv, + glPatchParameteri, + glPatchParameterfv, + glBindTransformFeedback, + glDeleteTransformFeedbacks, + glGenTransformFeedbacks, + glIsTransformFeedback, + glPauseTransformFeedback, + glResumeTransformFeedback, + glDrawTransformFeedback, + glDrawTransformFeedbackStream, + glBeginQueryIndexed, + glEndQueryIndexed, + glGetQueryIndexediv, + glReleaseShaderCompiler, + glShaderBinary, + glGetShaderPrecisionFormat, + glDepthRangef, + glClearDepthf, + glGetProgramBinary, + glProgramBinary, + glProgramParameteri, + glUseProgramStages, + glActiveShaderProgram, + glCreateShaderProgramv, + glBindProgramPipeline, + glDeleteProgramPipelines, + glGenProgramPipelines, + glIsProgramPipeline, + glGetProgramPipelineiv, + glProgramUniform1i, + glProgramUniform2i, + glProgramUniform3i, + glProgramUniform4i, + glProgramUniform1ui, + glProgramUniform2ui, + glProgramUniform3ui, + glProgramUniform4ui, + glProgramUniform1f, + glProgramUniform2f, + glProgramUniform3f, + glProgramUniform4f, + glProgramUniform1d, + glProgramUniform2d, + glProgramUniform3d, + glProgramUniform4d, + glProgramUniform1iv, + glProgramUniform2iv, + glProgramUniform3iv, + glProgramUniform4iv, + glProgramUniform1uiv, + glProgramUniform2uiv, + glProgramUniform3uiv, + glProgramUniform4uiv, + glProgramUniform1fv, + glProgramUniform2fv, + glProgramUniform3fv, + glProgramUniform4fv, + glProgramUniform1dv, + glProgramUniform2dv, + glProgramUniform3dv, + glProgramUniform4dv, + glProgramUniformMatrix2fv, + glProgramUniformMatrix3fv, + glProgramUniformMatrix4fv, + glProgramUniformMatrix2dv, + glProgramUniformMatrix3dv, + glProgramUniformMatrix4dv, + glProgramUniformMatrix2x3fv, + glProgramUniformMatrix3x2fv, + glProgramUniformMatrix2x4fv, + glProgramUniformMatrix4x2fv, + glProgramUniformMatrix3x4fv, + glProgramUniformMatrix4x3fv, + glProgramUniformMatrix2x3dv, + glProgramUniformMatrix3x2dv, + glProgramUniformMatrix2x4dv, + glProgramUniformMatrix4x2dv, + glProgramUniformMatrix3x4dv, + glProgramUniformMatrix4x3dv, + glValidateProgramPipeline, + glGetProgramPipelineInfoLog, + glVertexAttribL1d, + glVertexAttribL2d, + glVertexAttribL3d, + glVertexAttribL4d, + glVertexAttribL1dv, + glVertexAttribL2dv, + glVertexAttribL3dv, + glVertexAttribL4dv, + glVertexAttribLPointer, + glGetVertexAttribLdv, + glViewportArrayv, + glViewportIndexedf, + glViewportIndexedfv, + glScissorArrayv, + glScissorIndexed, + glScissorIndexedv, + glDepthRangeArrayv, + glDepthRangeIndexed, + glGetFloati_v, + glGetDoublei_v, + glGetActiveAtomicCounterBufferiv, + glTexStorage1D, + glTexStorage2D, + glTexStorage3D, + glDrawTransformFeedbackInstanced, + glDrawTransformFeedbackStreamInstanced, + glDrawArraysInstancedBaseInstance, + glDrawElementsInstancedBaseInstance, + glDrawElementsInstancedBaseVertexBaseInstance, + glBindImageTexture, + glMemoryBarrier, + glGetInternalformativ, + glClearBufferData, + glClearBufferSubData, + glDispatchCompute, + glDispatchComputeIndirect, + glCopyImageSubData, + glDebugMessageControl, + glDebugMessageInsert, + glDebugMessageCallback, + glGetDebugMessageLog, + glPushDebugGroup, + glPopDebugGroup, + glObjectLabel, + glGetObjectLabel, + glObjectPtrLabel, + glGetObjectPtrLabel, + glFramebufferParameteri, + glGetFramebufferParameteriv, + glGetInternalformati64v, + glInvalidateTexSubImage, + glInvalidateTexImage, + glInvalidateBufferSubData, + glInvalidateBufferData, + glInvalidateFramebuffer, + glInvalidateSubFramebuffer, + glMultiDrawArraysIndirect, + glMultiDrawElementsIndirect, + glGetProgramInterfaceiv, + glGetProgramResourceIndex, + glGetProgramResourceName, + glGetProgramResourceiv, + glGetProgramResourceLocation, + glGetProgramResourceLocationIndex, + glShaderStorageBlockBinding, + glTexBufferRange, + glTexStorage2DMultisample, + glTexStorage3DMultisample, + glTextureView, + glBindVertexBuffer, + glVertexAttribFormat, + glVertexAttribIFormat, + glVertexAttribLFormat, + glVertexAttribBinding, + glVertexBindingDivisor, + glBufferStorage, + glClearTexSubImage, + glClearTexImage, + glBindBuffersBase, + glBindBuffersRange, + glBindTextures, + glBindSamplers, + glBindImageTextures, + glBindVertexBuffers, + glGetnMapdv, + glGetnMapfv, + glGetnMapiv, + glGetnPixelMapfv, + glGetnPixelMapuiv, + glGetnPixelMapusv, + glGetnPolygonStipple, + glGetnColorTable, + glGetnConvolutionFilter, + glGetnSeparableFilter, + glGetnHistogram, + glGetnMinmax, + glClipControl, + glCreateTransformFeedbacks, + glTransformFeedbackBufferBase, + glTransformFeedbackBufferRange, + glGetTransformFeedbackiv, + glGetTransformFeedbacki_v, + glGetTransformFeedbacki64_v, + glCreateBuffers, + glNamedBufferStorage, + glNamedBufferData, + glNamedBufferSubData, + glCopyNamedBufferSubData, + glClearNamedBufferData, + glClearNamedBufferSubData, + glMapNamedBuffer, + glMapNamedBufferRange, + glUnmapNamedBuffer, + glFlushMappedNamedBufferRange, + glGetNamedBufferParameteriv, + glGetNamedBufferParameteri64v, + glGetNamedBufferPointerv, + glGetNamedBufferSubData, + glCreateFramebuffers, + glNamedFramebufferRenderbuffer, + glNamedFramebufferParameteri, + glNamedFramebufferTexture, + glNamedFramebufferTextureLayer, + glNamedFramebufferDrawBuffer, + glNamedFramebufferDrawBuffers, + glNamedFramebufferReadBuffer, + glInvalidateNamedFramebufferData, + glInvalidateNamedFramebufferSubData, + glClearNamedFramebufferiv, + glClearNamedFramebufferuiv, + glClearNamedFramebufferfv, + glClearNamedFramebufferfi, + glBlitNamedFramebuffer, + glCheckNamedFramebufferStatus, + glGetNamedFramebufferParameteriv, + glGetNamedFramebufferAttachmentParameteriv, + glCreateRenderbuffers, + glNamedRenderbufferStorage, + glNamedRenderbufferStorageMultisample, + glGetNamedRenderbufferParameteriv, + glCreateTextures, + glTextureBuffer, + glTextureBufferRange, + glTextureStorage1D, + glTextureStorage2D, + glTextureStorage3D, + glTextureStorage2DMultisample, + glTextureStorage3DMultisample, + glTextureSubImage1D, + glTextureSubImage2D, + glTextureSubImage3D, + glCompressedTextureSubImage1D, + glCompressedTextureSubImage2D, + glCompressedTextureSubImage3D, + glCopyTextureSubImage1D, + glCopyTextureSubImage2D, + glCopyTextureSubImage3D, + glTextureParameterf, + glTextureParameterfv, + glTextureParameteri, + glTextureParameterIiv, + glTextureParameterIuiv, + glTextureParameteriv, + glGenerateTextureMipmap, + glBindTextureUnit, + glGetTextureImage, + glGetCompressedTextureImage, + glGetTextureLevelParameterfv, + glGetTextureLevelParameteriv, + glGetTextureParameterfv, + glGetTextureParameterIiv, + glGetTextureParameterIuiv, + glGetTextureParameteriv, + glCreateVertexArrays, + glDisableVertexArrayAttrib, + glEnableVertexArrayAttrib, + glVertexArrayElementBuffer, + glVertexArrayVertexBuffer, + glVertexArrayVertexBuffers, + glVertexArrayAttribFormat, + glVertexArrayAttribIFormat, + glVertexArrayAttribLFormat, + glVertexArrayAttribBinding, + glVertexArrayBindingDivisor, + glGetVertexArrayiv, + glGetVertexArrayIndexediv, + glGetVertexArrayIndexed64iv, + glCreateSamplers, + glCreateProgramPipelines, + glCreateQueries, + glGetQueryBufferObjectiv, + glGetQueryBufferObjectuiv, + glGetQueryBufferObjecti64v, + glGetQueryBufferObjectui64v, + glMemoryBarrierByRegion, + glGetTextureSubImage, + glGetCompressedTextureSubImage, + glTextureBarrier, + glGetGraphicsResetStatus, + glGetnTexImage, + glReadnPixels, + glGetnCompressedTexImage, + glGetnUniformfv, + glGetnUniformdv, + glGetnUniformiv, + glGetnUniformuiv, + glMultiDrawArraysIndirectCount, + glMultiDrawElementsIndirectCount, + glPolygonOffsetClamp, + glSpecializeShader, + glDebugMessageEnableAMD, + glDebugMessageInsertAMD, + glDebugMessageCallbackAMD, + glGetDebugMessageLogAMD, + glBlendFuncIndexedAMD, + glBlendFuncSeparateIndexedAMD, + glBlendEquationIndexedAMD, + glBlendEquationSeparateIndexedAMD, + glRenderbufferStorageMultisampleAdvancedAMD, + glNamedRenderbufferStorageMultisampleAdvancedAMD, + glVertexAttribParameteriAMD, + glQueryObjectParameteruiAMD, + glGetPerfMonitorGroupsAMD, + glGetPerfMonitorCountersAMD, + glGetPerfMonitorGroupStringAMD, + glGetPerfMonitorCounterStringAMD, + glGetPerfMonitorCounterInfoAMD, + glGenPerfMonitorsAMD, + glDeletePerfMonitorsAMD, + glSelectPerfMonitorCountersAMD, + glBeginPerfMonitorAMD, + glEndPerfMonitorAMD, + glGetPerfMonitorCounterDataAMD, + glSetMultisamplefvAMD, + glTexStorageSparseAMD, + glTextureStorageSparseAMD, + glStencilOpValueAMD, + glTessellationFactorAMD, + glTessellationModeAMD, + glGetTextureHandleARB, + glGetTextureSamplerHandleARB, + glMakeTextureHandleResidentARB, + glMakeTextureHandleNonResidentARB, + glGetImageHandleARB, + glMakeImageHandleResidentARB, + glMakeImageHandleNonResidentARB, + glUniformHandleui64ARB, + glUniformHandleui64vARB, + glProgramUniformHandleui64ARB, + glProgramUniformHandleui64vARB, + glIsTextureHandleResidentARB, + glIsImageHandleResidentARB, + glVertexAttribL1ui64ARB, + glVertexAttribL1ui64vARB, + glGetVertexAttribLui64vARB, + glNamedBufferStorageEXT, + glClearNamedBufferDataEXT, + glClearNamedBufferSubDataEXT, + glClampColorARB, + glDispatchComputeGroupSizeARB, + glDebugMessageControlARB, + glDebugMessageInsertARB, + glDebugMessageCallbackARB, + glGetDebugMessageLogARB, + glDrawBuffersARB, + glBlendEquationiARB, + glBlendEquationSeparateiARB, + glBlendFunciARB, + glBlendFuncSeparateiARB, + glDrawArraysInstancedARB, + glDrawElementsInstancedARB, + glPrimitiveBoundingBoxARB, + glNamedFramebufferParameteriEXT, + glGetNamedFramebufferParameterivEXT, + glProgramParameteriARB, + glFramebufferTextureARB, + glFramebufferTextureLayerARB, + glFramebufferTextureFaceARB, + glSpecializeShaderARB, + glProgramUniform1dEXT, + glProgramUniform2dEXT, + glProgramUniform3dEXT, + glProgramUniform4dEXT, + glProgramUniform1dvEXT, + glProgramUniform2dvEXT, + glProgramUniform3dvEXT, + glProgramUniform4dvEXT, + glProgramUniformMatrix2dvEXT, + glProgramUniformMatrix3dvEXT, + glProgramUniformMatrix4dvEXT, + glProgramUniformMatrix2x3dvEXT, + glProgramUniformMatrix2x4dvEXT, + glProgramUniformMatrix3x2dvEXT, + glProgramUniformMatrix3x4dvEXT, + glProgramUniformMatrix4x2dvEXT, + glProgramUniformMatrix4x3dvEXT, + glUniform1i64ARB, + glUniform1i64vARB, + glProgramUniform1i64ARB, + glProgramUniform1i64vARB, + glUniform2i64ARB, + glUniform2i64vARB, + glProgramUniform2i64ARB, + glProgramUniform2i64vARB, + glUniform3i64ARB, + glUniform3i64vARB, + glProgramUniform3i64ARB, + glProgramUniform3i64vARB, + glUniform4i64ARB, + glUniform4i64vARB, + glProgramUniform4i64ARB, + glProgramUniform4i64vARB, + glUniform1ui64ARB, + glUniform1ui64vARB, + glProgramUniform1ui64ARB, + glProgramUniform1ui64vARB, + glUniform2ui64ARB, + glUniform2ui64vARB, + glProgramUniform2ui64ARB, + glProgramUniform2ui64vARB, + glUniform3ui64ARB, + glUniform3ui64vARB, + glProgramUniform3ui64ARB, + glProgramUniform3ui64vARB, + glUniform4ui64ARB, + glUniform4ui64vARB, + glProgramUniform4ui64ARB, + glProgramUniform4ui64vARB, + glGetUniformi64vARB, + glGetUniformui64vARB, + glGetnUniformi64vARB, + glGetnUniformui64vARB, + glColorTable, + glCopyColorTable, + glColorTableParameteriv, + glColorTableParameterfv, + glGetColorTable, + glGetColorTableParameteriv, + glGetColorTableParameterfv, + glColorSubTable, + glCopyColorSubTable, + glConvolutionFilter1D, + glConvolutionFilter2D, + glCopyConvolutionFilter1D, + glCopyConvolutionFilter2D, + glGetConvolutionFilter, + glSeparableFilter2D, + glGetSeparableFilter, + glConvolutionParameteri, + glConvolutionParameteriv, + glConvolutionParameterf, + glConvolutionParameterfv, + glGetConvolutionParameteriv, + glGetConvolutionParameterfv, + glHistogram, + glResetHistogram, + glGetHistogram, + glGetHistogramParameteriv, + glGetHistogramParameterfv, + glMinmax, + glResetMinmax, + glGetMinmax, + glGetMinmaxParameteriv, + glGetMinmaxParameterfv, + glMultiDrawArraysIndirectCountARB, + glMultiDrawElementsIndirectCountARB, + glVertexAttribDivisorARB, + glVertexArrayVertexAttribDivisorEXT, + glCurrentPaletteMatrixARB, + glMatrixIndexuivARB, + glMatrixIndexubvARB, + glMatrixIndexusvARB, + glMatrixIndexPointerARB, + glSampleCoverageARB, + glActiveTextureARB, + glClientActiveTextureARB, + glMultiTexCoord1fARB, + glMultiTexCoord1sARB, + glMultiTexCoord1iARB, + glMultiTexCoord1dARB, + glMultiTexCoord1fvARB, + glMultiTexCoord1svARB, + glMultiTexCoord1ivARB, + glMultiTexCoord1dvARB, + glMultiTexCoord2fARB, + glMultiTexCoord2sARB, + glMultiTexCoord2iARB, + glMultiTexCoord2dARB, + glMultiTexCoord2fvARB, + glMultiTexCoord2svARB, + glMultiTexCoord2ivARB, + glMultiTexCoord2dvARB, + glMultiTexCoord3fARB, + glMultiTexCoord3sARB, + glMultiTexCoord3iARB, + glMultiTexCoord3dARB, + glMultiTexCoord3fvARB, + glMultiTexCoord3svARB, + glMultiTexCoord3ivARB, + glMultiTexCoord3dvARB, + glMultiTexCoord4fARB, + glMultiTexCoord4sARB, + glMultiTexCoord4iARB, + glMultiTexCoord4dARB, + glMultiTexCoord4fvARB, + glMultiTexCoord4svARB, + glMultiTexCoord4ivARB, + glMultiTexCoord4dvARB, + glGenQueriesARB, + glDeleteQueriesARB, + glIsQueryARB, + glBeginQueryARB, + glEndQueryARB, + glGetQueryivARB, + glGetQueryObjectivARB, + glGetQueryObjectuivARB, + glMaxShaderCompilerThreadsARB, + glPointParameterfARB, + glPointParameterfvARB, + glGetGraphicsResetStatusARB, + glGetnMapdvARB, + glGetnMapfvARB, + glGetnMapivARB, + glGetnPixelMapfvARB, + glGetnPixelMapuivARB, + glGetnPixelMapusvARB, + glGetnPolygonStippleARB, + glGetnTexImageARB, + glReadnPixelsARB, + glGetnColorTableARB, + glGetnConvolutionFilterARB, + glGetnSeparableFilterARB, + glGetnHistogramARB, + glGetnMinmaxARB, + glGetnCompressedTexImageARB, + glGetnUniformfvARB, + glGetnUniformivARB, + glGetnUniformuivARB, + glGetnUniformdvARB, + glFramebufferSampleLocationsfvARB, + glNamedFramebufferSampleLocationsfvARB, + glEvaluateDepthValuesARB, + glMinSampleShadingARB, + glDeleteObjectARB, + glGetHandleARB, + glDetachObjectARB, + glCreateShaderObjectARB, + glShaderSourceARB, + glCompileShaderARB, + glCreateProgramObjectARB, + glAttachObjectARB, + glLinkProgramARB, + glUseProgramObjectARB, + glValidateProgramARB, + glUniform1fARB, + glUniform2fARB, + glUniform3fARB, + glUniform4fARB, + glUniform1iARB, + glUniform2iARB, + glUniform3iARB, + glUniform4iARB, + glUniform1fvARB, + glUniform2fvARB, + glUniform3fvARB, + glUniform4fvARB, + glUniform1ivARB, + glUniform2ivARB, + glUniform3ivARB, + glUniform4ivARB, + glUniformMatrix2fvARB, + glUniformMatrix3fvARB, + glUniformMatrix4fvARB, + glGetObjectParameterfvARB, + glGetObjectParameterivARB, + glGetInfoLogARB, + glGetAttachedObjectsARB, + glGetUniformLocationARB, + glGetActiveUniformARB, + glGetUniformfvARB, + glGetUniformivARB, + glGetShaderSourceARB, + glNamedStringARB, + glDeleteNamedStringARB, + glCompileShaderIncludeARB, + glIsNamedStringARB, + glGetNamedStringARB, + glGetNamedStringivARB, + glBufferPageCommitmentARB, + glNamedBufferPageCommitmentEXT, + glNamedBufferPageCommitmentARB, + glTexPageCommitmentARB, + glTexturePageCommitmentEXT, + glTexBufferARB, + glTextureBufferRangeEXT, + glCompressedTexImage3DARB, + glCompressedTexImage2DARB, + glCompressedTexImage1DARB, + glCompressedTexSubImage3DARB, + glCompressedTexSubImage2DARB, + glCompressedTexSubImage1DARB, + glGetCompressedTexImageARB, + glTextureStorage1DEXT, + glTextureStorage2DEXT, + glTextureStorage3DEXT, + glTextureStorage2DMultisampleEXT, + glTextureStorage3DMultisampleEXT, + glLoadTransposeMatrixfARB, + glLoadTransposeMatrixdARB, + glMultTransposeMatrixfARB, + glMultTransposeMatrixdARB, + glVertexArrayVertexAttribLOffsetEXT, + glVertexArrayBindVertexBufferEXT, + glVertexArrayVertexAttribFormatEXT, + glVertexArrayVertexAttribIFormatEXT, + glVertexArrayVertexAttribLFormatEXT, + glVertexArrayVertexAttribBindingEXT, + glVertexArrayVertexBindingDivisorEXT, + glWeightfvARB, + glWeightbvARB, + glWeightubvARB, + glWeightsvARB, + glWeightusvARB, + glWeightivARB, + glWeightuivARB, + glWeightdvARB, + glWeightPointerARB, + glVertexBlendARB, + glBindBufferARB, + glDeleteBuffersARB, + glGenBuffersARB, + glIsBufferARB, + glBufferDataARB, + glBufferSubDataARB, + glGetBufferSubDataARB, + glMapBufferARB, + glUnmapBufferARB, + glGetBufferParameterivARB, + glGetBufferPointervARB, + glProgramStringARB, + glBindProgramARB, + glDeleteProgramsARB, + glGenProgramsARB, + glProgramEnvParameter4dARB, + glProgramEnvParameter4dvARB, + glProgramEnvParameter4fARB, + glProgramEnvParameter4fvARB, + glProgramLocalParameter4dARB, + glProgramLocalParameter4dvARB, + glProgramLocalParameter4fARB, + glProgramLocalParameter4fvARB, + glGetProgramEnvParameterfvARB, + glGetProgramEnvParameterdvARB, + glGetProgramLocalParameterfvARB, + glGetProgramLocalParameterdvARB, + glGetProgramivARB, + glGetProgramStringARB, + glIsProgramARB, + glVertexAttrib1fARB, + glVertexAttrib1sARB, + glVertexAttrib1dARB, + glVertexAttrib2fARB, + glVertexAttrib2sARB, + glVertexAttrib2dARB, + glVertexAttrib3fARB, + glVertexAttrib3sARB, + glVertexAttrib3dARB, + glVertexAttrib4fARB, + glVertexAttrib4sARB, + glVertexAttrib4dARB, + glVertexAttrib4NubARB, + glVertexAttrib1fvARB, + glVertexAttrib1svARB, + glVertexAttrib1dvARB, + glVertexAttrib2fvARB, + glVertexAttrib2svARB, + glVertexAttrib2dvARB, + glVertexAttrib3fvARB, + glVertexAttrib3svARB, + glVertexAttrib3dvARB, + glVertexAttrib4fvARB, + glVertexAttrib4svARB, + glVertexAttrib4dvARB, + glVertexAttrib4ivARB, + glVertexAttrib4bvARB, + glVertexAttrib4ubvARB, + glVertexAttrib4usvARB, + glVertexAttrib4uivARB, + glVertexAttrib4NbvARB, + glVertexAttrib4NsvARB, + glVertexAttrib4NivARB, + glVertexAttrib4NubvARB, + glVertexAttrib4NusvARB, + glVertexAttrib4NuivARB, + glVertexAttribPointerARB, + glEnableVertexAttribArrayARB, + glDisableVertexAttribArrayARB, + glBindAttribLocationARB, + glGetActiveAttribARB, + glGetAttribLocationARB, + glGetVertexAttribivARB, + glGetVertexAttribfvARB, + glGetVertexAttribdvARB, + glGetVertexAttribPointervARB, + glWindowPos2iARB, + glWindowPos2sARB, + glWindowPos2fARB, + glWindowPos2dARB, + glWindowPos2ivARB, + glWindowPos2svARB, + glWindowPos2fvARB, + glWindowPos2dvARB, + glWindowPos3iARB, + glWindowPos3sARB, + glWindowPos3fARB, + glWindowPos3dARB, + glWindowPos3ivARB, + glWindowPos3svARB, + glWindowPos3fvARB, + glWindowPos3dvARB, + glUniformBufferEXT, + glGetUniformBufferSizeEXT, + glGetUniformOffsetEXT, + glBlendColorEXT, + glBlendEquationSeparateEXT, + glBlendFuncSeparateEXT, + glBlendEquationEXT, + glLockArraysEXT, + glUnlockArraysEXT, + glLabelObjectEXT, + glGetObjectLabelEXT, + glInsertEventMarkerEXT, + glPushGroupMarkerEXT, + glPopGroupMarkerEXT, + glDepthBoundsEXT, + glClientAttribDefaultEXT, + glPushClientAttribDefaultEXT, + glMatrixLoadfEXT, + glMatrixLoaddEXT, + glMatrixMultfEXT, + glMatrixMultdEXT, + glMatrixLoadIdentityEXT, + glMatrixRotatefEXT, + glMatrixRotatedEXT, + glMatrixScalefEXT, + glMatrixScaledEXT, + glMatrixTranslatefEXT, + glMatrixTranslatedEXT, + glMatrixOrthoEXT, + glMatrixFrustumEXT, + glMatrixPushEXT, + glMatrixPopEXT, + glTextureParameteriEXT, + glTextureParameterivEXT, + glTextureParameterfEXT, + glTextureParameterfvEXT, + glTextureImage1DEXT, + glTextureImage2DEXT, + glTextureSubImage1DEXT, + glTextureSubImage2DEXT, + glCopyTextureImage1DEXT, + glCopyTextureImage2DEXT, + glCopyTextureSubImage1DEXT, + glCopyTextureSubImage2DEXT, + glGetTextureImageEXT, + glGetTextureParameterfvEXT, + glGetTextureParameterivEXT, + glGetTextureLevelParameterfvEXT, + glGetTextureLevelParameterivEXT, + glTextureImage3DEXT, + glTextureSubImage3DEXT, + glCopyTextureSubImage3DEXT, + glBindMultiTextureEXT, + glMultiTexCoordPointerEXT, + glMultiTexEnvfEXT, + glMultiTexEnvfvEXT, + glMultiTexEnviEXT, + glMultiTexEnvivEXT, + glMultiTexGendEXT, + glMultiTexGendvEXT, + glMultiTexGenfEXT, + glMultiTexGenfvEXT, + glMultiTexGeniEXT, + glMultiTexGenivEXT, + glGetMultiTexEnvfvEXT, + glGetMultiTexEnvivEXT, + glGetMultiTexGendvEXT, + glGetMultiTexGenfvEXT, + glGetMultiTexGenivEXT, + glMultiTexParameteriEXT, + glMultiTexParameterivEXT, + glMultiTexParameterfEXT, + glMultiTexParameterfvEXT, + glMultiTexImage1DEXT, + glMultiTexImage2DEXT, + glMultiTexSubImage1DEXT, + glMultiTexSubImage2DEXT, + glCopyMultiTexImage1DEXT, + glCopyMultiTexImage2DEXT, + glCopyMultiTexSubImage1DEXT, + glCopyMultiTexSubImage2DEXT, + glGetMultiTexImageEXT, + glGetMultiTexParameterfvEXT, + glGetMultiTexParameterivEXT, + glGetMultiTexLevelParameterfvEXT, + glGetMultiTexLevelParameterivEXT, + glMultiTexImage3DEXT, + glMultiTexSubImage3DEXT, + glCopyMultiTexSubImage3DEXT, + glEnableClientStateIndexedEXT, + glDisableClientStateIndexedEXT, + glEnableClientStateiEXT, + glDisableClientStateiEXT, + glGetFloatIndexedvEXT, + glGetDoubleIndexedvEXT, + glGetPointerIndexedvEXT, + glGetFloati_vEXT, + glGetDoublei_vEXT, + glGetPointeri_vEXT, + glNamedProgramStringEXT, + glNamedProgramLocalParameter4dEXT, + glNamedProgramLocalParameter4dvEXT, + glNamedProgramLocalParameter4fEXT, + glNamedProgramLocalParameter4fvEXT, + glGetNamedProgramLocalParameterdvEXT, + glGetNamedProgramLocalParameterfvEXT, + glGetNamedProgramivEXT, + glGetNamedProgramStringEXT, + glCompressedTextureImage3DEXT, + glCompressedTextureImage2DEXT, + glCompressedTextureImage1DEXT, + glCompressedTextureSubImage3DEXT, + glCompressedTextureSubImage2DEXT, + glCompressedTextureSubImage1DEXT, + glGetCompressedTextureImageEXT, + glCompressedMultiTexImage3DEXT, + glCompressedMultiTexImage2DEXT, + glCompressedMultiTexImage1DEXT, + glCompressedMultiTexSubImage3DEXT, + glCompressedMultiTexSubImage2DEXT, + glCompressedMultiTexSubImage1DEXT, + glGetCompressedMultiTexImageEXT, + glMatrixLoadTransposefEXT, + glMatrixLoadTransposedEXT, + glMatrixMultTransposefEXT, + glMatrixMultTransposedEXT, + glNamedBufferDataEXT, + glNamedBufferSubDataEXT, + glMapNamedBufferEXT, + glUnmapNamedBufferEXT, + glGetNamedBufferParameterivEXT, + glGetNamedBufferSubDataEXT, + glProgramUniform1fEXT, + glProgramUniform2fEXT, + glProgramUniform3fEXT, + glProgramUniform4fEXT, + glProgramUniform1iEXT, + glProgramUniform2iEXT, + glProgramUniform3iEXT, + glProgramUniform4iEXT, + glProgramUniform1fvEXT, + glProgramUniform2fvEXT, + glProgramUniform3fvEXT, + glProgramUniform4fvEXT, + glProgramUniform1ivEXT, + glProgramUniform2ivEXT, + glProgramUniform3ivEXT, + glProgramUniform4ivEXT, + glProgramUniformMatrix2fvEXT, + glProgramUniformMatrix3fvEXT, + glProgramUniformMatrix4fvEXT, + glProgramUniformMatrix2x3fvEXT, + glProgramUniformMatrix3x2fvEXT, + glProgramUniformMatrix2x4fvEXT, + glProgramUniformMatrix4x2fvEXT, + glProgramUniformMatrix3x4fvEXT, + glProgramUniformMatrix4x3fvEXT, + glTextureBufferEXT, + glMultiTexBufferEXT, + glTextureParameterIivEXT, + glTextureParameterIuivEXT, + glGetTextureParameterIivEXT, + glGetTextureParameterIuivEXT, + glMultiTexParameterIivEXT, + glMultiTexParameterIuivEXT, + glGetMultiTexParameterIivEXT, + glGetMultiTexParameterIuivEXT, + glProgramUniform1uiEXT, + glProgramUniform2uiEXT, + glProgramUniform3uiEXT, + glProgramUniform4uiEXT, + glProgramUniform1uivEXT, + glProgramUniform2uivEXT, + glProgramUniform3uivEXT, + glProgramUniform4uivEXT, + glNamedProgramLocalParameters4fvEXT, + glNamedProgramLocalParameterI4iEXT, + glNamedProgramLocalParameterI4ivEXT, + glNamedProgramLocalParametersI4ivEXT, + glNamedProgramLocalParameterI4uiEXT, + glNamedProgramLocalParameterI4uivEXT, + glNamedProgramLocalParametersI4uivEXT, + glGetNamedProgramLocalParameterIivEXT, + glGetNamedProgramLocalParameterIuivEXT, + glNamedRenderbufferStorageEXT, + glGetNamedRenderbufferParameterivEXT, + glNamedRenderbufferStorageMultisampleEXT, + glNamedRenderbufferStorageMultisampleCoverageEXT, + glCheckNamedFramebufferStatusEXT, + glNamedFramebufferTexture1DEXT, + glNamedFramebufferTexture2DEXT, + glNamedFramebufferTexture3DEXT, + glNamedFramebufferRenderbufferEXT, + glGetNamedFramebufferAttachmentParameterivEXT, + glGenerateTextureMipmapEXT, + glGenerateMultiTexMipmapEXT, + glFramebufferDrawBufferEXT, + glFramebufferDrawBuffersEXT, + glFramebufferReadBufferEXT, + glGetFramebufferParameterivEXT, + glNamedCopyBufferSubDataEXT, + glNamedFramebufferTextureEXT, + glNamedFramebufferTextureLayerEXT, + glNamedFramebufferTextureFaceEXT, + glTextureRenderbufferEXT, + glMultiTexRenderbufferEXT, + glVertexArrayVertexOffsetEXT, + glVertexArrayColorOffsetEXT, + glVertexArrayEdgeFlagOffsetEXT, + glVertexArrayIndexOffsetEXT, + glVertexArrayNormalOffsetEXT, + glVertexArrayTexCoordOffsetEXT, + glVertexArrayMultiTexCoordOffsetEXT, + glVertexArrayFogCoordOffsetEXT, + glVertexArraySecondaryColorOffsetEXT, + glVertexArrayVertexAttribOffsetEXT, + glVertexArrayVertexAttribIOffsetEXT, + glEnableVertexArrayEXT, + glDisableVertexArrayEXT, + glEnableVertexArrayAttribEXT, + glDisableVertexArrayAttribEXT, + glGetVertexArrayIntegervEXT, + glGetVertexArrayPointervEXT, + glGetVertexArrayIntegeri_vEXT, + glGetVertexArrayPointeri_vEXT, + glMapNamedBufferRangeEXT, + glFlushMappedNamedBufferRangeEXT, + glColorMaskIndexedEXT, + glGetBooleanIndexedvEXT, + glGetIntegerIndexedvEXT, + glEnableIndexedEXT, + glDisableIndexedEXT, + glIsEnabledIndexedEXT, + glDrawArraysInstancedEXT, + glDrawElementsInstancedEXT, + glEGLImageTargetTexStorageEXT, + glEGLImageTargetTextureStorageEXT, + glBufferStorageExternalEXT, + glNamedBufferStorageExternalEXT, + glBlitFramebufferEXT, + glRenderbufferStorageMultisampleEXT, + glIsRenderbufferEXT, + glBindRenderbufferEXT, + glDeleteRenderbuffersEXT, + glGenRenderbuffersEXT, + glRenderbufferStorageEXT, + glGetRenderbufferParameterivEXT, + glIsFramebufferEXT, + glBindFramebufferEXT, + glDeleteFramebuffersEXT, + glGenFramebuffersEXT, + glCheckFramebufferStatusEXT, + glFramebufferTexture1DEXT, + glFramebufferTexture2DEXT, + glFramebufferTexture3DEXT, + glFramebufferRenderbufferEXT, + glGetFramebufferAttachmentParameterivEXT, + glGenerateMipmapEXT, + glProgramParameteriEXT, + glFramebufferTextureEXT, + glFramebufferTextureFaceEXT, + glProgramEnvParameters4fvEXT, + glProgramLocalParameters4fvEXT, + glVertexAttribI1iEXT, + glVertexAttribI2iEXT, + glVertexAttribI3iEXT, + glVertexAttribI4iEXT, + glVertexAttribI1uiEXT, + glVertexAttribI2uiEXT, + glVertexAttribI3uiEXT, + glVertexAttribI4uiEXT, + glVertexAttribI1ivEXT, + glVertexAttribI2ivEXT, + glVertexAttribI3ivEXT, + glVertexAttribI4ivEXT, + glVertexAttribI1uivEXT, + glVertexAttribI2uivEXT, + glVertexAttribI3uivEXT, + glVertexAttribI4uivEXT, + glVertexAttribI4bvEXT, + glVertexAttribI4svEXT, + glVertexAttribI4ubvEXT, + glVertexAttribI4usvEXT, + glVertexAttribIPointerEXT, + glGetVertexAttribIivEXT, + glGetVertexAttribIuivEXT, + glGetUniformuivEXT, + glBindFragDataLocationEXT, + glGetFragDataLocationEXT, + glUniform1uiEXT, + glUniform2uiEXT, + glUniform3uiEXT, + glUniform4uiEXT, + glUniform1uivEXT, + glUniform2uivEXT, + glUniform3uivEXT, + glUniform4uivEXT, + glGetUnsignedBytevEXT, + glGetUnsignedBytei_vEXT, + glDeleteMemoryObjectsEXT, + glIsMemoryObjectEXT, + glCreateMemoryObjectsEXT, + glMemoryObjectParameterivEXT, + glGetMemoryObjectParameterivEXT, + glTexStorageMem2DEXT, + glTexStorageMem2DMultisampleEXT, + glTexStorageMem3DEXT, + glTexStorageMem3DMultisampleEXT, + glBufferStorageMemEXT, + glTextureStorageMem2DEXT, + glTextureStorageMem2DMultisampleEXT, + glTextureStorageMem3DEXT, + glTextureStorageMem3DMultisampleEXT, + glNamedBufferStorageMemEXT, + glTexStorageMem1DEXT, + glTextureStorageMem1DEXT, + glImportMemoryFdEXT, + glImportMemoryWin32HandleEXT, + glImportMemoryWin32NameEXT, + glPointParameterfEXT, + glPointParameterfvEXT, + glPolygonOffsetClampEXT, + glProvokingVertexEXT, + glRasterSamplesEXT, + glSecondaryColor3bEXT, + glSecondaryColor3sEXT, + glSecondaryColor3iEXT, + glSecondaryColor3fEXT, + glSecondaryColor3dEXT, + glSecondaryColor3ubEXT, + glSecondaryColor3usEXT, + glSecondaryColor3uiEXT, + glSecondaryColor3bvEXT, + glSecondaryColor3svEXT, + glSecondaryColor3ivEXT, + glSecondaryColor3fvEXT, + glSecondaryColor3dvEXT, + glSecondaryColor3ubvEXT, + glSecondaryColor3usvEXT, + glSecondaryColor3uivEXT, + glSecondaryColorPointerEXT, + glGenSemaphoresEXT, + glDeleteSemaphoresEXT, + glIsSemaphoreEXT, + glSemaphoreParameterui64vEXT, + glGetSemaphoreParameterui64vEXT, + glWaitSemaphoreEXT, + glSignalSemaphoreEXT, + glImportSemaphoreFdEXT, + glImportSemaphoreWin32HandleEXT, + glImportSemaphoreWin32NameEXT, + glUseShaderProgramEXT, + glActiveProgramEXT, + glCreateShaderProgramEXT, + glFramebufferFetchBarrierEXT, + glBindImageTextureEXT, + glMemoryBarrierEXT, + glStencilClearTagEXT, + glActiveStencilFaceEXT, + glFramebufferTextureLayerEXT, + glTexBufferEXT, + glClearColorIiEXT, + glClearColorIuiEXT, + glTexParameterIivEXT, + glTexParameterIuivEXT, + glGetTexParameterIivEXT, + glGetTexParameterIuivEXT, + glGetQueryObjecti64vEXT, + glGetQueryObjectui64vEXT, + glBindBufferRangeEXT, + glBindBufferOffsetEXT, + glBindBufferBaseEXT, + glBeginTransformFeedbackEXT, + glEndTransformFeedbackEXT, + glTransformFeedbackVaryingsEXT, + glGetTransformFeedbackVaryingEXT, + glVertexAttribL1dEXT, + glVertexAttribL2dEXT, + glVertexAttribL3dEXT, + glVertexAttribL4dEXT, + glVertexAttribL1dvEXT, + glVertexAttribL2dvEXT, + glVertexAttribL3dvEXT, + glVertexAttribL4dvEXT, + glVertexAttribLPointerEXT, + glGetVertexAttribLdvEXT, + glAcquireKeyedMutexWin32EXT, + glReleaseKeyedMutexWin32EXT, + glWindowRectanglesEXT, + glImportSyncEXT, + glFrameTerminatorGREMEDY, + glStringMarkerGREMEDY, + glApplyFramebufferAttachmentCMAAINTEL, + glSyncTextureINTEL, + glUnmapTexture2DINTEL, + glMapTexture2DINTEL, + glBeginPerfQueryINTEL, + glCreatePerfQueryINTEL, + glDeletePerfQueryINTEL, + glEndPerfQueryINTEL, + glGetFirstPerfQueryIdINTEL, + glGetNextPerfQueryIdINTEL, + glGetPerfCounterInfoINTEL, + glGetPerfQueryDataINTEL, + glGetPerfQueryIdByNameINTEL, + glGetPerfQueryInfoINTEL, + glBlendBarrierKHR, + glMaxShaderCompilerThreadsKHR, + glAlphaToCoverageDitherControlNV, + glMultiDrawArraysIndirectBindlessNV, + glMultiDrawElementsIndirectBindlessNV, + glMultiDrawArraysIndirectBindlessCountNV, + glMultiDrawElementsIndirectBindlessCountNV, + glGetTextureHandleNV, + glGetTextureSamplerHandleNV, + glMakeTextureHandleResidentNV, + glMakeTextureHandleNonResidentNV, + glGetImageHandleNV, + glMakeImageHandleResidentNV, + glMakeImageHandleNonResidentNV, + glUniformHandleui64NV, + glUniformHandleui64vNV, + glProgramUniformHandleui64NV, + glProgramUniformHandleui64vNV, + glIsTextureHandleResidentNV, + glIsImageHandleResidentNV, + glBlendParameteriNV, + glBlendBarrierNV, + glViewportPositionWScaleNV, + glCreateStatesNV, + glDeleteStatesNV, + glIsStateNV, + glStateCaptureNV, + glGetCommandHeaderNV, + glGetStageIndexNV, + glDrawCommandsNV, + glDrawCommandsAddressNV, + glDrawCommandsStatesNV, + glDrawCommandsStatesAddressNV, + glCreateCommandListsNV, + glDeleteCommandListsNV, + glIsCommandListNV, + glListDrawCommandsStatesClientNV, + glCommandListSegmentsNV, + glCompileCommandListNV, + glCallCommandListNV, + glBeginConditionalRenderNV, + glEndConditionalRenderNV, + glSubpixelPrecisionBiasNV, + glConservativeRasterParameterfNV, + glConservativeRasterParameteriNV, + glCopyImageSubDataNV, + glDepthRangedNV, + glClearDepthdNV, + glDepthBoundsdNV, + glDrawTextureNV, + glDrawVkImageNV, + glGetVkProcAddrNV, + glWaitVkSemaphoreNV, + glSignalVkSemaphoreNV, + glSignalVkFenceNV, + glGetMultisamplefvNV, + glSampleMaskIndexedNV, + glTexRenderbufferNV, + glDeleteFencesNV, + glGenFencesNV, + glIsFenceNV, + glTestFenceNV, + glGetFenceivNV, + glFinishFenceNV, + glSetFenceNV, + glFragmentCoverageColorNV, + glCoverageModulationTableNV, + glGetCoverageModulationTableNV, + glCoverageModulationNV, + glRenderbufferStorageMultisampleCoverageNV, + glRenderGpuMaskNV, + glMulticastBufferSubDataNV, + glMulticastCopyBufferSubDataNV, + glMulticastCopyImageSubDataNV, + glMulticastBlitFramebufferNV, + glMulticastFramebufferSampleLocationsfvNV, + glMulticastBarrierNV, + glMulticastWaitSyncNV, + glMulticastGetQueryObjectivNV, + glMulticastGetQueryObjectuivNV, + glMulticastGetQueryObjecti64vNV, + glMulticastGetQueryObjectui64vNV, + glUniform1i64NV, + glUniform2i64NV, + glUniform3i64NV, + glUniform4i64NV, + glUniform1i64vNV, + glUniform2i64vNV, + glUniform3i64vNV, + glUniform4i64vNV, + glUniform1ui64NV, + glUniform2ui64NV, + glUniform3ui64NV, + glUniform4ui64NV, + glUniform1ui64vNV, + glUniform2ui64vNV, + glUniform3ui64vNV, + glUniform4ui64vNV, + glGetUniformi64vNV, + glProgramUniform1i64NV, + glProgramUniform2i64NV, + glProgramUniform3i64NV, + glProgramUniform4i64NV, + glProgramUniform1i64vNV, + glProgramUniform2i64vNV, + glProgramUniform3i64vNV, + glProgramUniform4i64vNV, + glProgramUniform1ui64NV, + glProgramUniform2ui64NV, + glProgramUniform3ui64NV, + glProgramUniform4ui64NV, + glProgramUniform1ui64vNV, + glProgramUniform2ui64vNV, + glProgramUniform3ui64vNV, + glProgramUniform4ui64vNV, + glVertex2hNV, + glVertex2hvNV, + glVertex3hNV, + glVertex3hvNV, + glVertex4hNV, + glVertex4hvNV, + glNormal3hNV, + glNormal3hvNV, + glColor3hNV, + glColor3hvNV, + glColor4hNV, + glColor4hvNV, + glTexCoord1hNV, + glTexCoord1hvNV, + glTexCoord2hNV, + glTexCoord2hvNV, + glTexCoord3hNV, + glTexCoord3hvNV, + glTexCoord4hNV, + glTexCoord4hvNV, + glMultiTexCoord1hNV, + glMultiTexCoord1hvNV, + glMultiTexCoord2hNV, + glMultiTexCoord2hvNV, + glMultiTexCoord3hNV, + glMultiTexCoord3hvNV, + glMultiTexCoord4hNV, + glMultiTexCoord4hvNV, + glFogCoordhNV, + glFogCoordhvNV, + glSecondaryColor3hNV, + glSecondaryColor3hvNV, + glVertexWeighthNV, + glVertexWeighthvNV, + glVertexAttrib1hNV, + glVertexAttrib1hvNV, + glVertexAttrib2hNV, + glVertexAttrib2hvNV, + glVertexAttrib3hNV, + glVertexAttrib3hvNV, + glVertexAttrib4hNV, + glVertexAttrib4hvNV, + glVertexAttribs1hvNV, + glVertexAttribs2hvNV, + glVertexAttribs3hvNV, + glVertexAttribs4hvNV, + glGetInternalformatSampleivNV, + glGetMemoryObjectDetachedResourcesuivNV, + glResetMemoryObjectParameterNV, + glTexAttachMemoryNV, + glBufferAttachMemoryNV, + glTextureAttachMemoryNV, + glNamedBufferAttachMemoryNV, + glDrawMeshTasksNV, + glDrawMeshTasksIndirectNV, + glMultiDrawMeshTasksIndirectNV, + glMultiDrawMeshTasksIndirectCountNV, + glPathCommandsNV, + glPathCoordsNV, + glPathSubCommandsNV, + glPathSubCoordsNV, + glPathStringNV, + glPathGlyphsNV, + glPathGlyphRangeNV, + glPathGlyphIndexArrayNV, + glPathMemoryGlyphIndexArrayNV, + glCopyPathNV, + glWeightPathsNV, + glInterpolatePathsNV, + glTransformPathNV, + glPathParameterivNV, + glPathParameteriNV, + glPathParameterfvNV, + glPathParameterfNV, + glPathDashArrayNV, + glGenPathsNV, + glDeletePathsNV, + glIsPathNV, + glPathStencilFuncNV, + glPathStencilDepthOffsetNV, + glStencilFillPathNV, + glStencilStrokePathNV, + glStencilFillPathInstancedNV, + glStencilStrokePathInstancedNV, + glPathCoverDepthFuncNV, + glPathColorGenNV, + glPathTexGenNV, + glPathFogGenNV, + glCoverFillPathNV, + glCoverStrokePathNV, + glCoverFillPathInstancedNV, + glCoverStrokePathInstancedNV, + glStencilThenCoverFillPathNV, + glStencilThenCoverStrokePathNV, + glStencilThenCoverFillPathInstancedNV, + glStencilThenCoverStrokePathInstancedNV, + glPathGlyphIndexRangeNV, + glProgramPathFragmentInputGenNV, + glGetPathParameterivNV, + glGetPathParameterfvNV, + glGetPathCommandsNV, + glGetPathCoordsNV, + glGetPathDashArrayNV, + glGetPathMetricsNV, + glGetPathMetricRangeNV, + glGetPathSpacingNV, + glGetPathColorGenivNV, + glGetPathColorGenfvNV, + glGetPathTexGenivNV, + glGetPathTexGenfvNV, + glIsPointInFillPathNV, + glIsPointInStrokePathNV, + glGetPathLengthNV, + glPointAlongPathNV, + glMatrixLoad3x2fNV, + glMatrixLoad3x3fNV, + glMatrixLoadTranspose3x3fNV, + glMatrixMult3x2fNV, + glMatrixMult3x3fNV, + glMatrixMultTranspose3x3fNV, + glGetProgramResourcefvNV, + glPixelDataRangeNV, + glFlushPixelDataRangeNV, + glPointParameteriNV, + glPointParameterivNV, + glPrimitiveRestartNV, + glPrimitiveRestartIndexNV, + glQueryResourceNV, + glGenQueryResourceTagNV, + glDeleteQueryResourceTagNV, + glQueryResourceTagNV, + glFramebufferSampleLocationsfvNV, + glNamedFramebufferSampleLocationsfvNV, + glResolveDepthValuesNV, + glScissorExclusiveArrayvNV, + glScissorExclusiveNV, + glMakeBufferResidentNV, + glMakeBufferNonResidentNV, + glIsBufferResidentNV, + glMakeNamedBufferResidentNV, + glMakeNamedBufferNonResidentNV, + glIsNamedBufferResidentNV, + glGetBufferParameterui64vNV, + glGetNamedBufferParameterui64vNV, + glGetIntegerui64vNV, + glUniformui64NV, + glUniformui64vNV, + glGetUniformui64vNV, + glProgramUniformui64NV, + glProgramUniformui64vNV, + glBindShadingRateImageNV, + glShadingRateImagePaletteNV, + glGetShadingRateImagePaletteNV, + glShadingRateImageBarrierNV, + glShadingRateSampleOrderNV, + glShadingRateSampleOrderCustomNV, + glGetShadingRateSampleLocationivNV, + glTextureBarrierNV, + glTexImage2DMultisampleCoverageNV, + glTexImage3DMultisampleCoverageNV, + glTextureImage2DMultisampleNV, + glTextureImage3DMultisampleNV, + glTextureImage2DMultisampleCoverageNV, + glTextureImage3DMultisampleCoverageNV, + glBeginTransformFeedbackNV, + glEndTransformFeedbackNV, + glTransformFeedbackAttribsNV, + glBindBufferRangeNV, + glBindBufferOffsetNV, + glBindBufferBaseNV, + glTransformFeedbackVaryingsNV, + glActiveVaryingNV, + glGetVaryingLocationNV, + glGetActiveVaryingNV, + glGetTransformFeedbackVaryingNV, + glTransformFeedbackStreamAttribsNV, + glBindTransformFeedbackNV, + glDeleteTransformFeedbacksNV, + glGenTransformFeedbacksNV, + glIsTransformFeedbackNV, + glPauseTransformFeedbackNV, + glResumeTransformFeedbackNV, + glDrawTransformFeedbackNV, + glVertexArrayRangeNV, + glFlushVertexArrayRangeNV, + glVertexAttribL1i64NV, + glVertexAttribL2i64NV, + glVertexAttribL3i64NV, + glVertexAttribL4i64NV, + glVertexAttribL1i64vNV, + glVertexAttribL2i64vNV, + glVertexAttribL3i64vNV, + glVertexAttribL4i64vNV, + glVertexAttribL1ui64NV, + glVertexAttribL2ui64NV, + glVertexAttribL3ui64NV, + glVertexAttribL4ui64NV, + glVertexAttribL1ui64vNV, + glVertexAttribL2ui64vNV, + glVertexAttribL3ui64vNV, + glVertexAttribL4ui64vNV, + glGetVertexAttribLi64vNV, + glGetVertexAttribLui64vNV, + glVertexAttribLFormatNV, + glBufferAddressRangeNV, + glVertexFormatNV, + glNormalFormatNV, + glColorFormatNV, + glIndexFormatNV, + glTexCoordFormatNV, + glEdgeFlagFormatNV, + glSecondaryColorFormatNV, + glFogCoordFormatNV, + glVertexAttribFormatNV, + glVertexAttribIFormatNV, + glGetIntegerui64i_vNV, + glViewportSwizzleNV, + glBeginConditionalRenderNVX, + glEndConditionalRenderNVX, + glAsyncCopyImageSubDataNVX, + glAsyncCopyBufferSubDataNVX, + glUploadGpuMaskNVX, + glMulticastViewportArrayvNVX, + glMulticastScissorArrayvNVX, + glMulticastViewportPositionWScaleNVX, + glCreateProgressFenceNVX, + glSignalSemaphoreui64NVX, + glWaitSemaphoreui64NVX, + glClientWaitSemaphoreui64NVX, + glFramebufferTextureMultiviewOVR, + glNamedFramebufferTextureMultiviewOVR; + + /** When true, {@link GL11} is supported. */ + public final boolean OpenGL11; + /** When true, {@link GL12} is supported. */ + public final boolean OpenGL12; + /** When true, {@link GL13} is supported. */ + public final boolean OpenGL13; + /** When true, {@link GL14} is supported. */ + public final boolean OpenGL14; + /** When true, {@link GL15} is supported. */ + public final boolean OpenGL15; + /** When true, {@link GL20} is supported. */ + public final boolean OpenGL20; + /** When true, {@link GL21} is supported. */ + public final boolean OpenGL21; + /** When true, {@link GL30} is supported. */ + public final boolean OpenGL30; + /** When true, {@link GL31} is supported. */ + public final boolean OpenGL31; + /** When true, {@link GL32} is supported. */ + public final boolean OpenGL32; + /** When true, {@link GL33} is supported. */ + public final boolean OpenGL33; + /** When true, {@link GL40} is supported. */ + public final boolean OpenGL40; + /** When true, {@link GL41} is supported. */ + public final boolean OpenGL41; + /** When true, {@link GL42} is supported. */ + public final boolean OpenGL42; + /** When true, {@link GL43} is supported. */ + public final boolean OpenGL43; + /** When true, {@link GL44} is supported. */ + public final boolean OpenGL44; + /** When true, {@link GL45} is supported. */ + public final boolean OpenGL45; + /** When true, {@link GL46} is supported. */ + public final boolean OpenGL46; + /** When true, {@link AMDBlendMinmaxFactor} is supported. */ + public final boolean GL_AMD_blend_minmax_factor; + /** + * When true, the AMD_conservative_depth extension is supported. + * + *There is a common optimization for hardware accelerated implementation of OpenGL which relies on an early depth test to be run before the fragment + * shader so that the shader evaluation can be skipped if the fragment ends up being discarded because it is occluded.
+ * + *This optimization does not affect the final rendering, and is typically possible when the fragment does not change the depth programmatically. (i.e.: it + * does not write to the built-in {@code gl_FragDepth} output). There are, however a class of operations on the depth in the shader which could still be + * performed while allowing the early depth test to operate.
+ * + *This extension allows the application to pass enough information to the GL implementation to activate such optimizations safely.
+ * + *Requires {@link GL30 OpenGL 3.0}. Promoted to core in {@link GL42 OpenGL 4.2}.
+ */ + public final boolean GL_AMD_conservative_depth; + /** When true, {@link AMDDebugOutput} is supported. */ + public final boolean GL_AMD_debug_output; + /** When true, {@link AMDDepthClampSeparate} is supported. */ + public final boolean GL_AMD_depth_clamp_separate; + /** When true, {@link AMDDrawBuffersBlend} is supported. */ + public final boolean GL_AMD_draw_buffers_blend; + /** When true, {@link AMDFramebufferMultisampleAdvanced} is supported. */ + public final boolean GL_AMD_framebuffer_multisample_advanced; + /** + * When true, the AMD_gcn_shader extension is supported. + * + *This extension exposes miscellaneous features of the AMD "Graphics Core Next" shader architecture that do not cleanly fit into other extensions + * and are not significant enough alone to warrant their own extensions. This includes cross-SIMD lane ballots, cube map query functions and a + * functionality to query the elapsed shader core time.
+ * + *Requires {@link #GL_AMD_gpu_shader_int64 AMD_gpu_shader_int64} or {@link #GL_NV_gpu_shader5 NV_gpu_shader5}.
+ */ + public final boolean GL_AMD_gcn_shader; + /** When true, {@link AMDGPUShaderHalfFloat} is supported. */ + public final boolean GL_AMD_gpu_shader_half_float; + /** When true, {@link AMDGPUShaderHalfFloatFetch} is supported. */ + public final boolean GL_AMD_gpu_shader_half_float_fetch; + /** + * When true, the AMD_gpu_shader_int16 extension is supported. + * + *This extension was developed to allow implementations supporting 16-bit integers to expose the feature in GLSL.
+ * + *The extension introduces the following features for all shader types:
+ * + *Requires GLSL 4.00.
+ */ + public final boolean GL_AMD_gpu_shader_int16; + /** When true, {@link AMDGPUShaderInt64} is supported. */ + public final boolean GL_AMD_gpu_shader_int64; + /** When true, {@link AMDInterleavedElements} is supported. */ + public final boolean GL_AMD_interleaved_elements; + /** When true, {@link AMDOcclusionQueryEvent} is supported. */ + public final boolean GL_AMD_occlusion_query_event; + /** When true, {@link AMDPerformanceMonitor} is supported. */ + public final boolean GL_AMD_performance_monitor; + /** When true, {@link AMDPinnedMemory} is supported. */ + public final boolean GL_AMD_pinned_memory; + /** When true, {@link AMDQueryBufferObject} is supported. */ + public final boolean GL_AMD_query_buffer_object; + /** When true, {@link AMDSamplePositions} is supported. */ + public final boolean GL_AMD_sample_positions; + /** When true, {@link AMDSeamlessCubemapPerTexture} is supported. */ + public final boolean GL_AMD_seamless_cubemap_per_texture; + /** + * When true, the AMD_shader_atomic_counter_ops extension is supported. + * + *This extension is written against the OpenGL 4.3 (core) specification and the GLSL 4.30.7 specification.
+ * + *Requires {@link GL42 OpenGL 4.2} or {@link #GL_ARB_shader_atomic_counters ARB_shader_atomic_counters}.
+ */ + public final boolean GL_AMD_shader_atomic_counter_ops; + /** + * When true, the AMD_shader_ballot extension is supported. + * + *The extensions {@code ARB_shader_group_vote} and {@code ARB_shader_ballot} introduced the concept of sub-groups and a set of operations that allow data + * exchange across shader invocations within a sub-group.
+ * + *This extension further extends the capabilities of these extensions with additional sub-group operations.
+ * + *Requires {@link #GL_ARB_shader_group_vote ARB_shader_group_vote}, {@link #GL_ARB_shader_ballot ARB_shader_ballot} and {@link ARBGPUShaderInt64 ARB_gpu_shader_int64} or {@link AMDGPUShaderInt64 AMD_gpu_shader_int64}.
+ */ + public final boolean GL_AMD_shader_ballot; + /** + * When true, the AMD_shader_explicit_vertex_parameter extension is supported. + * + *Unextended GLSL provides a set of fixed function interpolation modes and even those are limited to certain types of interpolants (for example, + * interpolation of integer and double isn't supported).
+ * + *This extension introduces new built-in functions allowing access to vertex parameters explicitly in the fragment shader. It also exposes barycentric + * coordinates as new built-in variables, which can be used to implement custom interpolation algorithms using shader code.
+ * + *Requires {@link GL20 OpenGL 2.0} or {@link ARBShaderObjects ARB_shader_objects}.
+ */ + public final boolean GL_AMD_shader_explicit_vertex_parameter; + /** + * When true, the AMD_shader_image_load_store_lod extension is supported. + * + *This extension was developed based on the {@link ARBShaderImageLoadStore ARB_shader_image_load_store} extension to allow implementations supporting loads and stores on mipmap + * texture images.
+ * + *Requires {@link GL40 OpenGL 4.0} and GLSL 4.00
+ */ + public final boolean GL_AMD_shader_image_load_store_lod; + /** + * When true, the AMD_shader_stencil_export extension is supported. + * + *In OpenGL, the stencil test is a powerful mechanism to selectively discard fragments based on the content of the stencil buffer. However, facilites to + * update the content of the stencil buffer are limited to operations such as incrementing the existing value, or overwriting with a fixed reference value.
+ * + *This extension provides a mechanism whereby a shader may generate the stencil reference value per invocation. When stencil testing is enabled, this + * allows the test to be performed against the value generated in the shader. When the stencil operation is set to {@link GL11#GL_REPLACE REPLACE}, this allows a value generated + * in the shader to be written to the stencil buffer directly.
+ * + *Requires {@link #GL_ARB_fragment_shader ARB_fragment_shader}.
+ */ + public final boolean GL_AMD_shader_stencil_export; + /** + * When true, the AMD_shader_trinary_minmax extension is supported. + * + *This extension introduces three new trinary built-in functions to the OpenGL Shading Languages. These functions allow the minimum, maximum or median of + * three inputs to be found with a single function call. These operations may be useful for sorting and filtering operations, for example. By explicitly + * performing a trinary operation with a single built-in function, shader compilers and optimizers may be able to generate better instruction sequences for + * perform sorting and other multi-input functions.
+ * + *Requires {@link GL20 OpenGL 2.0} or {@link #GL_ARB_shader_objects ARB_shader_objects}.
+ */ + public final boolean GL_AMD_shader_trinary_minmax; + /** When true, {@link AMDSparseTexture} is supported. */ + public final boolean GL_AMD_sparse_texture; + /** When true, {@link AMDStencilOperationExtended} is supported. */ + public final boolean GL_AMD_stencil_operation_extended; + /** + * When true, the AMD_texture_gather_bias_lod extension is supported. + * + *This extension was developed based on existing built-in texture gather functions to allow implementations supporting bias of implicit level of detail + * and explicit control of level of detail in texture gather operations.
+ */ + public final boolean GL_AMD_texture_gather_bias_lod; + /** + * When true, the AMD_texture_texture4 extension is supported. + * + *This extension adds new shading language built-in texture functions to the shading language.
+ * + *These texture functions may be used to access one component textures.
+ * + *The {@code texture4} built-in function returns a texture value derived from a 2x2 set of texels in the image array of level levelbase is selected. These + * texels are selected in the same way as when the value of {@link GL11#GL_TEXTURE_MIN_FILTER TEXTURE_MIN_FILTER} is {@link GL11#GL_LINEAR LINEAR}, but instead of these texels being filtered to generate the + * texture value, the R, G, B and A texture values are derived directly from these four texels.
+ */ + public final boolean GL_AMD_texture_texture4; + /** + * When true, the AMD_transform_feedback3_lines_triangles extension is supported. + * + *OpenGL 4.0 introduced the ability to record primitives into multiple output streams using transform feedback. However, the restriction that all streams + * must output {@link GL11#GL_POINT POINT} primitives when more than one output stream is active was also introduced. This extension simply removes that restriction, allowing + * the same set of primitives to be used with multiple transform feedback streams as with a single stream.
+ * + *Requires {@link GL40 OpenGL 4.0} or {@link ARBTransformFeedback3 ARB_transform_feedback3}.
+ */ + public final boolean GL_AMD_transform_feedback3_lines_triangles; + /** When true, {@link AMDTransformFeedback4} is supported. */ + public final boolean GL_AMD_transform_feedback4; + /** + * When true, the AMD_vertex_shader_layer extension is supported. + * + *The {@code gl_Layer} built-in shading language variable was introduced with the {@link #GL_ARB_geometry_shader4 ARB_geometry_shader4} extension and subsequently promoted to core + * OpenGL in version 3.2. This variable is an output from the geometry shader stage that allows rendering to be directed to a specific layer of an array + * texture, slice of a 3D texture or face of a cube map or cube map array attachment of the framebuffer. Thus, this extremely useful functionality is only + * available if a geometry shader is present - even if the geometry shader is not otherwise required by the application. This adds overhead to the graphics + * processing pipeline, and complexity to applications. It also precludes implementations that cannot support geometry shaders from supporting rendering to + * layered framebuffer attachments.
+ * + *This extension exposes the {@code gl_Layer} built-in variable in the vertex shader, allowing rendering to be directed to layered framebuffer attachments + * with only a vertex and fragment shader present. Combined with features such as instancing, or static vertex attributes and so on, this allows a wide + * variety of techniques to be implemented without the requirement for a geometry shader to be present.
+ * + *Requires {@link GL30 OpenGL 3.0} or {@link #GL_EXT_texture_array EXT_texture_array}.
+ */ + public final boolean GL_AMD_vertex_shader_layer; + /** When true, {@link AMDVertexShaderTessellator} is supported. */ + public final boolean GL_AMD_vertex_shader_tessellator; + /** + * When true, the AMD_vertex_shader_viewport_index extension is supported. + * + *The {@code gl_ViewportIndex} built-in variable was introduced by the {@link #GL_ARB_viewport_array ARB_viewport_array} extension and {@link GL41 OpenGL 4.1}. This variable is available + * in un-extended OpenGL only to the geometry shader. When written in the geometry shader, it causes geometry to be directed to one of an array of several + * independent viewport rectangles.
+ * + *In order to use any viewport other than zero, a geometry shader must be present. Geometry shaders introduce processing overhead and potential + * performance issues. This extension exposes the {@code gl_ViewportIndex} built-in variable to the vertex shader, allowing the functionality introduced by + * ARB_viewport_array to be accessed without requiring a geometry shader to be present.
+ * + *Requires {@link GL41 OpenGL 4.1} or {@link #GL_ARB_viewport_array ARB_viewport_array}.
+ */ + public final boolean GL_AMD_vertex_shader_viewport_index; + /** + * When true, the ARB_arrays_of_arrays extension is supported. + * + *This extension removes the restriction that arrays cannot be formed into arrays, allowing arrays of arrays to be declared.
+ * + *Requires GLSL 1.2. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ + public final boolean GL_ARB_arrays_of_arrays; + /** When true, {@link ARBBaseInstance} is supported. */ + public final boolean GL_ARB_base_instance; + /** When true, {@link ARBBindlessTexture} is supported. */ + public final boolean GL_ARB_bindless_texture; + /** When true, {@link ARBBlendFuncExtended} is supported. */ + public final boolean GL_ARB_blend_func_extended; + /** When true, {@link ARBBufferStorage} is supported. */ + public final boolean GL_ARB_buffer_storage; + /** When true, {@link ARBClearBufferObject} is supported. */ + public final boolean GL_ARB_clear_buffer_object; + /** When true, {@link ARBClearTexture} is supported. */ + public final boolean GL_ARB_clear_texture; + /** When true, {@link ARBClipControl} is supported. */ + public final boolean GL_ARB_clip_control; + /** When true, {@link ARBColorBufferFloat} is supported. */ + public final boolean GL_ARB_color_buffer_float; + /** + * When true, the ARB_compatibility extension is supported. + * + *This extension restores features deprecated by {@link GL30 OpenGL 3.0}.
+ */ + public final boolean GL_ARB_compatibility; + /** When true, {@link ARBCompressedTexturePixelStorage} is supported. */ + public final boolean GL_ARB_compressed_texture_pixel_storage; + /** When true, {@link ARBComputeShader} is supported. */ + public final boolean GL_ARB_compute_shader; + /** When true, {@link ARBComputeVariableGroupSize} is supported. */ + public final boolean GL_ARB_compute_variable_group_size; + /** When true, {@link ARBConditionalRenderInverted} is supported. */ + public final boolean GL_ARB_conditional_render_inverted; + /** + * When true, the ARB_conservative_depth extension is supported. + * + *There is a common optimization for hardware accelerated implementation of OpenGL which relies on an early depth test to be run before the fragment + * shader so that the shader evaluation can be skipped if the fragment ends up being discarded because it is occluded.
+ * + *This optimization does not affect the final rendering, and is typically possible when the fragment does not change the depth programmatically. (i.e.: it + * does not write to the built-in gl_FragDepth output). There are, however a class of operations on the depth in the shader which could still be performed + * while allowing the early depth test to operate.
+ * + *This extension allows the application to pass enough information to the GL implementation to activate such optimizations safely.
+ * + *Requires {@link GL30 OpenGL 3.0}. Promoted to core in {@link GL42 OpenGL 4.2}.
+ */ + public final boolean GL_ARB_conservative_depth; + /** When true, {@link ARBCopyBuffer} is supported. */ + public final boolean GL_ARB_copy_buffer; + /** When true, {@link ARBCopyImage} is supported. */ + public final boolean GL_ARB_copy_image; + /** When true, {@link ARBCullDistance} is supported. */ + public final boolean GL_ARB_cull_distance; + /** When true, {@link ARBDebugOutput} is supported. */ + public final boolean GL_ARB_debug_output; + /** When true, {@link ARBDepthBufferFloat} is supported. */ + public final boolean GL_ARB_depth_buffer_float; + /** When true, {@link ARBDepthClamp} is supported. */ + public final boolean GL_ARB_depth_clamp; + /** When true, {@link ARBDepthTexture} is supported. */ + public final boolean GL_ARB_depth_texture; + /** + * When true, the ARB_derivative_control extension is supported. + * + *This extension provides control over the spacial granularity at which the underlying implementation computes derivatives.
+ * + *For example, for the coarse-granularity derivative, a single x derivative could be computed for each 2x2 group of pixels, using that same derivative + * value for all 4 pixels. For the fine-granularity derivative, two derivatives could be computed for each 2x2 group of pixels; one for the top row and one + * for the bottom row. Implementations vary somewhat on how this is done.
+ * + *To select the coarse derivative, use:
+ * + *
+ * dFdxCoarse(p)
+ * dFdyCoarse(p)
+ * fwidthCoarse(p)To select the fine derivative, use:
+ * + *
+ * dFdxFine(p)
+ * dFdyFine(p)
+ * fwidthFine(p)To select which ever is "better" (based on performance, API hints, or other factors), use:
+ * + *
+ * dFdx(p)
+ * dFdy(p)
+ * fwidth(p)This last set is the set of previously existing built-ins for derivatives, and continues to work in a backward compatible way.
+ * + *Requires {@link GL40 OpenGL 4.0} and GLSL 4.00. Promoted to core in {@link GL45 OpenGL 4.5}.
+ */ + public final boolean GL_ARB_derivative_control; + /** When true, {@link ARBDirectStateAccess} is supported. */ + public final boolean GL_ARB_direct_state_access; + /** When true, {@link ARBDrawBuffers} is supported. */ + public final boolean GL_ARB_draw_buffers; + /** When true, {@link ARBDrawBuffersBlend} is supported. */ + public final boolean GL_ARB_draw_buffers_blend; + /** When true, {@link ARBDrawElementsBaseVertex} is supported. */ + public final boolean GL_ARB_draw_elements_base_vertex; + /** When true, {@link ARBDrawIndirect} is supported. */ + public final boolean GL_ARB_draw_indirect; + /** When true, {@link ARBDrawInstanced} is supported. */ + public final boolean GL_ARB_draw_instanced; + /** When true, {@link ARBEnhancedLayouts} is supported. */ + public final boolean GL_ARB_enhanced_layouts; + /** When true, {@link ARBES2Compatibility} is supported. */ + public final boolean GL_ARB_ES2_compatibility; + /** When true, {@link ARBES31Compatibility} is supported. */ + public final boolean GL_ARB_ES3_1_compatibility; + /** When true, {@link ARBES32Compatibility} is supported. */ + public final boolean GL_ARB_ES3_2_compatibility; + /** When true, {@link ARBES3Compatibility} is supported. */ + public final boolean GL_ARB_ES3_compatibility; + /** + * When true, the ARB_explicit_attrib_location extension is supported. + * + *This extension provides a method to pre-assign attribute locations to named vertex shader inputs and color numbers to named fragment shader outputs. + * This allows applications to globally assign a particular semantic meaning, such as diffuse color or vertex normal, to a particular attribute location + * without knowing how that attribute will be named in any particular shader.
+ * + *Requires {@link GL20 OpenGL 2.0} or {@link #GL_ARB_vertex_shader ARB_vertex_shader}. Promoted to core in {@link GL33 OpenGL 3.3}.
+ */ + public final boolean GL_ARB_explicit_attrib_location; + /** When true, {@link ARBExplicitUniformLocation} is supported. */ + public final boolean GL_ARB_explicit_uniform_location; + /** + * When true, the ARB_fragment_coord_conventions extension is supported. + * + *This extension provides alternative conventions for the fragment coordinate XY location available for programmable fragment processing.
+ * + *The scope of this extension deals *only* with how the fragment coordinate XY location appears during programming fragment processing. Beyond the scope + * of this extension are coordinate conventions used for rasterization or transformation.
+ * + *In the case of the coordinate conventions for rasterization and transformation, some combination of the viewport, depth range, culling state, and + * projection matrix state can be reconfigured to adopt other arbitrary clip-space and window-space coordinate space conventions. Adopting other clip-space + * and window-space conventions involves adjusting existing OpenGL state. However it is non-trivial to massage an arbitrary fragment shader or program to + * adopt a different window-space coordinate system because such shaders are encoded in various textual representations.
+ * + *The dominant 2D and 3D rendering APIs make two basic choices of convention when locating fragments in window space. The two choices are:
+ * + *OpenGL assumes a lower-left origin for window coordinates and assumes pixel centers are located at half-pixel coordinates. This means the XY location + * (0.5,0.5) corresponds to the lower-left-most pixel in a window.
+ * + *Other window coordinate conventions exist for other rendering APIs. X11, GDI, and Direct3D version through DirectX 9 assume an upper-left window origin + * and locate pixel centers at integer XY values. By this alternative convention, the XY location (0,0) corresponds to the upper-left-most pixel in a window.
+ * + *Direct3D for DirectX 10 assumes an upper-left origin (as do prior DirectX versions) yet assumes half-pixel coordinates (unlike prior DirectX versions). + * By the DirectX 10 convention, the XY location (0.5,0.5) corresponds to the upper-left-most pixel in a window.
+ * + *Fragment shaders can directly access the location of a given processed fragment in window space. We call this location the "fragment coordinate".
+ * + *This extension provides a means for fragment shaders written in GLSL or OpenGL assembly extensions to specify alternative conventions for determining + * the fragment coordinate value accessed during programmable fragment processing.
+ * + *The motivation for this extension is to provide an easy, efficient means for fragment shaders accessing a fragment's window-space location to adopt the + * fragment coordinate convention for which the shader was originally written.
+ * + *Promoted to core in {@link GL32 OpenGL 3.2}.
+ */ + public final boolean GL_ARB_fragment_coord_conventions; + /** + * When true, the ARB_fragment_layer_viewport extension is supported. + * + *The geometry shader has the special built-in variables gl_Layer and gl_ViewportIndex that specify which layer and viewport primitives are rendered to. + * Currently the fragment shader does not know which layer or viewport the fragments are being written to without the application implementing their own + * interface variables between the geometry and fragment shaders.
+ * + *This extension specifies that the gl_Layer and gl_ViewportIndex built-in variables are also available to the fragment shader so the application doesn't + * need to implement these manually.
+ * + *Requires {@link GL30 OpenGL 3.0} and {@link #GL_ARB_geometry_shader4 ARB_geometry_shader4}, or {@link GL32 OpenGL 3.2}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ + public final boolean GL_ARB_fragment_layer_viewport; + /** When true, {@link ARBFragmentProgram} is supported. */ + public final boolean GL_ARB_fragment_program; + /** + * When true, the ARB_fragment_program_shadow extension is supported. + * + *This extension extends ARB_fragment_program to remove the interaction with ARB_shadow and defines the program option "ARB_fragment_program_shadow".
+ * + *Requires {@link #GL_ARB_fragment_program ARB_fragment_program} and {@link #GL_ARB_shadow ARB_shadow}.
+ */ + public final boolean GL_ARB_fragment_program_shadow; + /** When true, {@link ARBFragmentShader} is supported. */ + public final boolean GL_ARB_fragment_shader; + /** + * When true, the ARB_fragment_shader_interlock extension is supported. + * + *In unextended OpenGL 4.5, applications may produce a large number of fragment shader invocations that perform loads and stores to memory using image + * uniforms, atomic counter uniforms, buffer variables, or pointers. The order in which loads and stores to common addresses are performed by different + * fragment shader invocations is largely undefined. For algorithms that use shader writes and touch the same pixels more than once, one or more of the + * following techniques may be required to ensure proper execution ordering:
+ * + *This extension provides new GLSL built-in functions beginInvocationInterlockARB() and endInvocationInterlockARB() that delimit a critical section of + * fragment shader code. For pairs of shader invocations with "overlapping" coverage in a given pixel, the OpenGL implementation will guarantee that the + * critical section of the fragment shader will be executed for only one fragment at a time.
+ * + *There are four different interlock modes supported by this extension, which are identified by layout qualifiers. The qualifiers + * "pixel_interlock_ordered" and "pixel_interlock_unordered" provides mutual exclusion in the critical section for any pair of fragments corresponding to + * the same pixel. When using multisampling, the qualifiers "sample_interlock_ordered" and "sample_interlock_unordered" only provide mutual exclusion for + * pairs of fragments that both cover at least one common sample in the same pixel; these are recommended for performance if shaders use per-sample data + * structures.
+ * + *Additionally, when the "pixel_interlock_ordered" or "sample_interlock_ordered" layout qualifier is used, the interlock also guarantees that the + * critical section for multiple shader invocations with "overlapping" coverage will be executed in the order in which the primitives were processed by + * the GL. Such a guarantee is useful for applications like blending in the fragment shader, where an application requires that fragment values to be + * composited in the framebuffer in primitive order.
+ * + *This extension can be useful for algorithms that need to access per-pixel data structures via shader loads and stores. Such algorithms using this + * extension can access such data structures in the critical section without worrying about other invocations for the same pixel accessing the data + * structures concurrently. Additionally, the ordering guarantees are useful for cases where the API ordering of fragments is meaningful. For example, + * applications may be able to execute programmable blending operations in the fragment shader, where the destination buffer is read via image loads and + * the final value is written via image stores.
+ * + *Requires {@link GL42 OpenGL 4.2} or {@link ARBShaderImageLoadStore ARB_shader_image_load_store}.
+ */ + public final boolean GL_ARB_fragment_shader_interlock; + /** When true, {@link ARBFramebufferNoAttachments} is supported. */ + public final boolean GL_ARB_framebuffer_no_attachments; + /** When true, {@link ARBFramebufferObject} is supported. */ + public final boolean GL_ARB_framebuffer_object; + /** When true, {@link ARBFramebufferSRGB} is supported. */ + public final boolean GL_ARB_framebuffer_sRGB; + /** When true, {@link ARBGeometryShader4} is supported. */ + public final boolean GL_ARB_geometry_shader4; + /** When true, {@link ARBGetProgramBinary} is supported. */ + public final boolean GL_ARB_get_program_binary; + /** When true, {@link ARBGetTextureSubImage} is supported. */ + public final boolean GL_ARB_get_texture_sub_image; + /** When true, {@link ARBGLSPIRV} is supported. */ + public final boolean GL_ARB_gl_spirv; + /** When true, {@link ARBGPUShader5} is supported. */ + public final boolean GL_ARB_gpu_shader5; + /** When true, {@link ARBGPUShaderFP64} is supported. */ + public final boolean GL_ARB_gpu_shader_fp64; + /** When true, {@link ARBGPUShaderInt64} is supported. */ + public final boolean GL_ARB_gpu_shader_int64; + /** When true, {@link ARBHalfFloatPixel} is supported. */ + public final boolean GL_ARB_half_float_pixel; + /** When true, {@link ARBHalfFloatVertex} is supported. */ + public final boolean GL_ARB_half_float_vertex; + /** When true, {@link ARBImaging} is supported. */ + public final boolean GL_ARB_imaging; + /** When true, {@link ARBIndirectParameters} is supported. */ + public final boolean GL_ARB_indirect_parameters; + /** When true, {@link ARBInstancedArrays} is supported. */ + public final boolean GL_ARB_instanced_arrays; + /** When true, {@link ARBInternalformatQuery} is supported. */ + public final boolean GL_ARB_internalformat_query; + /** When true, {@link ARBInternalformatQuery2} is supported. */ + public final boolean GL_ARB_internalformat_query2; + /** When true, {@link ARBInvalidateSubdata} is supported. */ + public final boolean GL_ARB_invalidate_subdata; + /** When true, {@link ARBMapBufferAlignment} is supported. */ + public final boolean GL_ARB_map_buffer_alignment; + /** When true, {@link ARBMapBufferRange} is supported. */ + public final boolean GL_ARB_map_buffer_range; + /** When true, {@link ARBMatrixPalette} is supported. */ + public final boolean GL_ARB_matrix_palette; + /** When true, {@link ARBMultiBind} is supported. */ + public final boolean GL_ARB_multi_bind; + /** When true, {@link ARBMultiDrawIndirect} is supported. */ + public final boolean GL_ARB_multi_draw_indirect; + /** When true, {@link ARBMultisample} is supported. */ + public final boolean GL_ARB_multisample; + /** When true, {@link ARBMultitexture} is supported. */ + public final boolean GL_ARB_multitexture; + /** When true, {@link ARBOcclusionQuery} is supported. */ + public final boolean GL_ARB_occlusion_query; + /** When true, {@link ARBOcclusionQuery2} is supported. */ + public final boolean GL_ARB_occlusion_query2; + /** When true, {@link ARBParallelShaderCompile} is supported. */ + public final boolean GL_ARB_parallel_shader_compile; + /** When true, {@link ARBPipelineStatisticsQuery} is supported. */ + public final boolean GL_ARB_pipeline_statistics_query; + /** When true, {@link ARBPixelBufferObject} is supported. */ + public final boolean GL_ARB_pixel_buffer_object; + /** When true, {@link ARBPointParameters} is supported. */ + public final boolean GL_ARB_point_parameters; + /** When true, {@link ARBPointSprite} is supported. */ + public final boolean GL_ARB_point_sprite; + /** When true, {@link ARBPolygonOffsetClamp} is supported. */ + public final boolean GL_ARB_polygon_offset_clamp; + /** + * When true, the ARB_post_depth_coverage extension is supported. + * + *This extension allows the fragment shader to control whether values in {@code gl_SampleMaskIn[]} reflect the coverage after application of the early + * depth and stencil tests. This feature can be enabled with the following layout qualifier in the fragment shader:
+ * + *
+ * layout(post_depth_coverage) in;Use of this feature implicitly enables early fragment tests.
+ */ + public final boolean GL_ARB_post_depth_coverage; + /** When true, {@link ARBProgramInterfaceQuery} is supported. */ + public final boolean GL_ARB_program_interface_query; + /** When true, {@link ARBProvokingVertex} is supported. */ + public final boolean GL_ARB_provoking_vertex; + /** When true, {@link ARBQueryBufferObject} is supported. */ + public final boolean GL_ARB_query_buffer_object; + /** + * When true, the ARB_robust_buffer_access_behavior extension is supported. + * + *This extension specifies the behavior of out-of-bounds buffer and array accesses. This is an improvement over the existing ARB_robustness extension + * which stated that the application should not crash, but the behavior is otherwise undefined. This extension specifies the access protection provided by + * the GL to ensure that out-of-bounds accesses cannot read from or write to data not owned by the application. All accesses are contained within the + * buffer object and program area they reference. These additional robustness guarantees apply to contexts created with the + * {@code CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB} feature enabled.
+ * + *Requires {@link ARBRobustness ARB_robustness}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ + public final boolean GL_ARB_robust_buffer_access_behavior; + /** When true, {@link ARBRobustness} is supported. */ + public final boolean GL_ARB_robustness; + /** + * When true, the ARB_robustness_application_isolation extension is supported. + * + *{@link ARBRobustness ARB_robustness} and supporting window system extensions allow creating an OpenGL context supporting graphics reset notification behavior. This + * extension provides stronger guarantees about the possible side-effects of a graphics reset.
+ * + *It is expected that there may be a performance cost associated with isolating an application or share group from other contexts on the GPU. For this + * reason, ARB_robustness_isolation is phrased as an opt-in mechanism, with a new context creation bit defined in the window system bindings. It is + * expected that implementations might only advertise the strings in this extension if both the implementation supports the desired isolation properties, + * and the context was created with the appropriate reset isolation bit.
+ * + *If the graphics driver advertises the {@code GL_ARB_robustness_application_isolation} extension string, then the driver guarantees that if a particular + * application causes a graphics reset to occur:
+ * + *Requires {@link ARBRobustness ARB_robustness}. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ + public final boolean GL_ARB_robustness_application_isolation; + /** + * When true, the ARB_robustness_share_group_isolation extension is supported. + * + *See {@link #GL_ARB_robustness_application_isolation ARB_robustness_application_isolation}.
+ * + *If the graphics driver advertises the {@code GL_ARB_robustness_share_group_isolation} extension string, then the driver guarantees that if a context in + * a particular share group causes a graphics reset to occur:
+ * + *The {@link ARBShaderAtomicCounters ARB_shader_atomic_counters} extension introduced atomic counters, but it limits list of potential operations that can be performed on them + * to increment, decrement, and query. This extension extends the list of GLSL built-in functions that can operate on atomic counters. The list of new + * operations include:
+ * + *Requires {@link GL42 OpenGL 4.2} or {@link ARBShaderAtomicCounters ARB_shader_atomic_counters}.
+ */ + public final boolean GL_ARB_shader_atomic_counter_ops; + /** When true, {@link ARBShaderAtomicCounters} is supported. */ + public final boolean GL_ARB_shader_atomic_counters; + /** + * When true, the ARB_shader_ballot extension is supported. + * + *This extension provides the ability for a group of invocations which execute in lockstep to do limited forms of cross-invocation communication via a + * group broadcast of a invocation value, or broadcast of a bitarray representing a predicate value from each invocation in the group.
+ * + *Requires {@link ARBGPUShaderInt64 ARB_gpu_shader_int64}.
+ */ + public final boolean GL_ARB_shader_ballot; + /** + * When true, the ARB_shader_bit_encoding extension is supported. + * + *This extension trivially adds built-in functions for getting/setting the bit encoding for floating-point values in the OpenGL Shading Language.
+ * + *Promoted to core in {@link GL33 OpenGL 3.3}.
+ */ + public final boolean GL_ARB_shader_bit_encoding; + /** + * When true, the ARB_shader_clock extension is supported. + * + *This extension exposes a 64-bit monotonically incrementing shader counter which may be used to derive local timing information within a single shader + * invocation.
+ */ + public final boolean GL_ARB_shader_clock; + /** + * When true, the ARB_shader_draw_parameters extension is supported. + * + *In unextended GL, vertex shaders have inputs named {@code gl_VertexID} and {@code gl_InstanceID}, which contain, respectively the index of the vertex + * and instance. The value of {@code gl_VertexID} is the implicitly passed index of the vertex being processed, which includes the value of baseVertex, for + * those commands that accept it. Meanwhile, {@code gl_InstanceID} is the integer index of the current instance being processed, but, even for commands + * that accept a baseInstance parameter, it does not include the value of this argument. Furthermore, the equivalents to these variables in other graphics + * APIs do not necessarily follow these conventions. The reason for this inconsistency is that there are legitimate use cases for both inclusion and + * exclusion of the baseVertex or baseInstance parameters in {@code gl_VertexID} and {@code gl_InstanceID}, respectively.
+ * + *Rather than change the semantics of either built-in variable, this extension adds two new built-in variables to the GL shading language, + * {@code gl_BaseVertexARB} and {@code gl_BaseInstanceARB}, which contain the values passed in the baseVertex and baseInstance parameters, respectively. + * Shaders provided by the application may use these variables to offset {@code gl_VertexID} or {@code gl_InstanceID} if desired, or use them for any other + * purpose.
+ * + *Additionally, this extension adds a further built-in variable, {@code gl_DrawID} to the shading language. This variable contains the index of the draw + * currently being processed by a Multi* variant of a drawing command (such as {@link GL14C#glMultiDrawElements MultiDrawElements} or {@link GL43C#glMultiDrawArraysIndirect MultiDrawArraysIndirect}).
+ * + *Requires {@link GL31 OpenGL 3.1}. Promoted to core in {@link GL33 OpenGL 3.3}.
+ */ + public final boolean GL_ARB_shader_draw_parameters; + /** + * When true, the ARB_shader_group_vote extension is supported. + * + *This extension provides new built-in functions to compute the composite of a set of boolean conditions across a group of shader invocations. These + * composite results may be used to execute shaders more efficiently on a single-instruction multiple-data (SIMD) processor. The set of shader invocations + * across which boolean conditions are evaluated is implementation-dependent, and this extension provides no guarantee over how individual shader + * invocations are assigned to such sets. In particular, the set of shader invocations has no necessary relationship with the compute shader local work + * group -- a pair of shader invocations in a single compute shader work group may end up in different sets used by these built-ins.
+ * + *Compute shaders operate on an explicitly specified group of threads (a local work group), but many implementations of OpenGL 4.3 will even group + * non-compute shader invocations and execute them in a SIMD fashion. When executing code like
+ * + *
+ * if (condition) {
+ * result = do_fast_path();
+ * } else {
+ * result = do_general_path();
+ * }where {@code condition} diverges between invocations, a SIMD implementation might first call do_fast_path() for the invocations where {@code condition} + * is true and leave the other invocations dormant. Once do_fast_path() returns, it might call do_general_path() for invocations where {@code condition} is + * false and leave the other invocations dormant. In this case, the shader executes *both* the fast and the general path and might be better off just using + * the general path for all invocations.
+ * + *This extension provides the ability to avoid divergent execution by evaluting a condition across an entire SIMD invocation group using code like:
+ * + *
+ * if (allInvocationsARB(condition)) {
+ * result = do_fast_path();
+ * } else {
+ * result = do_general_path();
+ * }The built-in function allInvocationsARB() will return the same value for all invocations in the group, so the group will either execute do_fast_path() + * or do_general_path(), but never both. For example, shader code might want to evaluate a complex function iteratively by starting with an approximation + * of the result and then refining the approximation. Some input values may require a small number of iterations to generate an accurate result + * (do_fast_path) while others require a larger number (do_general_path). In another example, shader code might want to evaluate a complex function + * (do_general_path) that can be greatly simplified when assuming a specific value for one of its inputs (do_fast_path).
+ * + *Requires {@link GL43 OpenGL 4.3} or {@link ARBComputeShader ARB_compute_shader}.
+ */ + public final boolean GL_ARB_shader_group_vote; + /** When true, {@link ARBShaderImageLoadStore} is supported. */ + public final boolean GL_ARB_shader_image_load_store; + /** + * When true, the ARB_shader_image_size extension is supported. + * + *This extension provides GLSL built-in functions allowing shaders to query the size of an image.
+ * + *Requires {@link GL42 OpenGL 4.2} and GLSL 4.20. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ + public final boolean GL_ARB_shader_image_size; + /** When true, {@link ARBShaderObjects} is supported. */ + public final boolean GL_ARB_shader_objects; + /** + * When true, the ARB_shader_precision extension is supported. + * + *This extension more clearly restricts the precision requirements of implementations of the GLSL specification. These include precision of arithmetic + * operations (operators '+', '/', ...), transcendentals (log, exp, pow, reciprocal sqrt, ...), when NaNs (not a number) and INFs (infinities) will be + * supported and generated, and denorm flushing behavior. Trigonometric built-ins and some other categories of built-ins are not addressed.
+ * + *Requires {@link GL40 OpenGL 4.0}. Promoted to core in {@link GL41 OpenGL 4.1}.
+ */ + public final boolean GL_ARB_shader_precision; + /** + * When true, the ARB_shader_stencil_export extension is supported. + * + *In OpenGL, the stencil test is a powerful mechanism to selectively discard fragments based on the content of the stencil buffer. However, facilites to + * update the content of the stencil buffer are limited to operations such as incrementing the existing value, or overwriting with a fixed reference value.
+ * + *This extension provides a mechanism whereby a shader may generate the stencil reference value per invocation. When stencil testing is enabled, this + * allows the test to be performed against the value generated in the shader. When the stencil operation is set to {@link GL11#GL_REPLACE REPLACE}, this allows a value generated + * in the shader to be written to the stencil buffer directly.
+ * + *Requires {@link #GL_ARB_fragment_shader ARB_fragment_shader}.
+ */ + public final boolean GL_ARB_shader_stencil_export; + /** When true, {@link ARBShaderStorageBufferObject} is supported. */ + public final boolean GL_ARB_shader_storage_buffer_object; + /** When true, {@link ARBShaderSubroutine} is supported. */ + public final boolean GL_ARB_shader_subroutine; + /** + * When true, the ARB_shader_texture_image_samples extension is supported. + * + *This extension provides GLSL built-in functions allowing shaders to query the number of samples of a texture.
+ * + *Requires GLSL 1.50 or {@link ARBTextureMultisample ARB_texture_multisample}.
+ */ + public final boolean GL_ARB_shader_texture_image_samples; + /** + * When true, the ARB_shader_texture_lod extension is supported. + * + *This extension adds additional texture functions to the OpenGL Shading Language which provide the shader writer with explicit control of LOD.
+ * + *Mipmap texture fetches and anisotropic texture fetches require an implicit derivatives to calculate rho, lambda and/or the line of anisotropy. These + * implicit derivatives will be undefined for texture fetches occurring inside non-uniform control flow or for vertex shader texture fetches, resulting in + * undefined texels.
+ * + *The additional texture functions introduced with this extension provide explict control of LOD (isotropic texture functions) or provide explicit + * derivatives (anisotropic texture functions).
+ * + *Anisotropic texture functions return defined texels for mipmap texture fetches or anisotropic texture fetches, even inside non-uniform control flow. + * Isotropic texture functions return defined texels for mipmap texture fetches, even inside non-uniform control flow. However, isotropic texture functions + * return undefined texels for anisotropic texture fetches.
+ * + *The existing isotropic vertex texture functions:
+ * + *
+ * texture1DLod, texture1DProjLod,
+ * texture2DLod, texture2DProjLod,
+ * texture3DLod, texture3DProjLod,
+ * textureCubeLod,
+ * shadow1DLod, shadow1DProjLod,
+ * shadow2DLod, shadow2DProjLodare added to the built-in functions for fragment shaders.
+ * + *New anisotropic texture functions, providing explicit derivatives:
+ * + *
+ * texture1DGradARB(
+ * sampler1D sampler,
+ * float P, float dPdx, float dPdy);
+ * texture1DProjGradARB(
+ * sampler1D sampler,
+ * vec2 P, float dPdx, float dPdy);
+ * texture1DProjGradARB(
+ * sampler1D sampler,
+ * vec4 P, float dPdx, float dPdy);
+ * texture2DGradARB(
+ * sampler2D sampler,
+ * vec2 P, vec2 dPdx, vec2 dPdy);
+ * texture2DProjGradARB(
+ * sampler2D sampler,
+ * vec3 P, vec2 dPdx, vec2 dPdy);
+ * texture2DProjGradARB(
+ * sampler2D sampler,
+ * vec4 P, vec2 dPdx, vec2 dPdy);
+ * texture3DGradARB(
+ * sampler3D sampler,
+ * vec3 P, vec3 dPdx, vec3 dPdy);
+ * texture3DProjGradARB(
+ * sampler3D sampler,
+ * vec4 P, vec3 dPdx, vec3 dPdy);
+ * textureCubeGradARB(
+ * samplerCube sampler,
+ * vec3 P, vec3 dPdx, vec3 dPdy);
+ *
+ * shadow1DGradARB(
+ * sampler1DShadow sampler,
+ * vec3 P, float dPdx, float dPdy);
+ * shadow1DProjGradARB(
+ * sampler1DShadow sampler,
+ * vec4 P, float dPdx, float dPdy);
+ * shadow2DGradARB(
+ * sampler2DShadow sampler,
+ * vec3 P, vec2 dPdx, vec2 dPdy);
+ * shadow2DProjGradARB(
+ * sampler2DShadow sampler,
+ * vec4 P, vec2 dPdx, vec2 dPdy);
+ *
+ * texture2DRectGradARB(
+ * sampler2DRect sampler,
+ * vec2 P, vec2 dPdx, vec2 dPdy);
+ * texture2DRectProjGradARB(
+ * sampler2DRect sampler,
+ * vec3 P, vec2 dPdx, vec2 dPdy);
+ * texture2DRectProjGradARB(
+ * sampler2DRect sampler,
+ * vec4 P, vec2 dPdx, vec2 dPdy);
+ *
+ * shadow2DRectGradARB(
+ * sampler2DRectShadow sampler,
+ * vec3 P, vec2 dPdx, vec2 dPdy);
+ * shadow2DRectProjGradARB(
+ * sampler2DRectShadow sampler,
+ * vec4 P, vec2 dPdx, vec2 dPdy);are added to the built-in functions for vertex shaders and fragment shaders.
+ * + *Requires {@link #GL_ARB_shader_objects ARB_shader_objects}. Promoted to core in {@link GL30 OpenGL 3.0}.
+ */ + public final boolean GL_ARB_shader_texture_lod; + /** + * When true, the ARB_shader_viewport_layer_array extension is supported. + * + *The gl_ViewportIndex and gl_Layer built-in variables were introduced by the in OpenGL 4.1. These variables are available in un-extended OpenGL only to + * the geometry shader. When written in the geometry shader, they cause geometry to be directed to one of an array of several independent viewport + * rectangles or framebuffer attachment layers, respectively.
+ * + *In order to use any viewport or attachment layer other than zero, a geometry shader must be present. Geometry shaders introduce processing overhead and + * potential performance issues. The AMD_vertex_shader_layer and AMD_vertex_shader_viewport_index extensions allowed the gl_Layer and gl_ViewportIndex + * outputs to be written directly from the vertex shader with no geometry shader present.
+ * + *This extension effectively merges the AMD_vertex_shader_layer and AMD_vertex_shader_viewport_index extensions together and extends them further to + * allow both outputs to be written from tessellation evaluation shaders.
+ * + *Requires {@link GL41 OpenGL 4.1}.
+ */ + public final boolean GL_ARB_shader_viewport_layer_array; + /** When true, {@link ARBShadingLanguage100} is supported. */ + public final boolean GL_ARB_shading_language_100; + /** + * When true, the ARB_shading_language_420pack extension is supported. + * + *This is a language feature only extension formed from changes made to version 4.20 of GLSL. It includes:
+ * + *Requires GLSL 1.30. Requires GLSL 1.40 for uniform block bindings. Promoted to core in {@link GL42 OpenGL 4.2}.
+ */ + public final boolean GL_ARB_shading_language_420pack; + /** When true, {@link ARBShadingLanguageInclude} is supported. */ + public final boolean GL_ARB_shading_language_include; + /** + * When true, the ARB_shading_language_packing extension is supported. + * + *This extension provides the GLSL built-in functions to convert a 32-bit unsigned integer holding a pair of 16-bit floating-point values to or from a + * two-component floating-point vector (vec2).
+ * + *This mechanism allows GLSL shaders to read and write 16-bit floating-point encodings (via 32-bit unsigned integers) without introducing a full set of + * 16-bit floating-point data types.
+ * + *This extension also adds the GLSL built-in packing functions included in GLSL version 4.00 and the ARB_gpu_shader5 extension which pack and unpack + * vectors of small fixed-point data types into a larger scalar. By putting these packing functions in this separate extension it allows implementations to + * provide these functions in hardware that supports them independent of the other {@link #GL_ARB_gpu_shader5 ARB_gpu_shader5} features.
+ * + *In addition to the packing functions from ARB_gpu_shader5 this extension also adds the missing {@code [un]packSnorm2x16} for completeness.
+ * + *Promoted to core in {@link GL42 OpenGL 4.2}.
+ */ + public final boolean GL_ARB_shading_language_packing; + /** When true, {@link ARBShadow} is supported. */ + public final boolean GL_ARB_shadow; + /** When true, {@link ARBShadowAmbient} is supported. */ + public final boolean GL_ARB_shadow_ambient; + /** When true, {@link ARBSparseBuffer} is supported. */ + public final boolean GL_ARB_sparse_buffer; + /** When true, {@link ARBSparseTexture} is supported. */ + public final boolean GL_ARB_sparse_texture; + /** + * When true, the ARB_sparse_texture2 extension is supported. + * + *This extension builds on the {@link ARBSparseTexture ARB_sparse_texture} extension, providing the following new functionality:
+ * + *Requires {@link ARBSparseTexture ARB_sparse_texture}
+ */ + public final boolean GL_ARB_sparse_texture2; + /** + * When true, the ARB_sparse_texture_clamp extension is supported. + * + *This extension builds on the {@link #GL_ARB_sparse_texture2 ARB_sparse_texture2} extension, providing the following new functionality:
+ * + *New built-in GLSL texture lookup functions are provided that specify a minimum level of detail to use for lookups where the level of detail is + * computed automatically. This allows shaders to avoid accessing unpopulated portions of high-resolution levels of detail when it knows that the memory + * accessed is unpopulated, either from a priori knowledge or from feedback provided by the return value of previously executed "sparse" texture lookup + * functions.
+ * + *Requires {@link #GL_ARB_sparse_texture2 ARB_sparse_texture2}
+ */ + public final boolean GL_ARB_sparse_texture_clamp; + /** When true, {@link ARBSPIRVExtensions} is supported. */ + public final boolean GL_ARB_spirv_extensions; + /** When true, {@link ARBStencilTexturing} is supported. */ + public final boolean GL_ARB_stencil_texturing; + /** When true, {@link ARBSync} is supported. */ + public final boolean GL_ARB_sync; + /** When true, {@link ARBTessellationShader} is supported. */ + public final boolean GL_ARB_tessellation_shader; + /** When true, {@link ARBTextureBarrier} is supported. */ + public final boolean GL_ARB_texture_barrier; + /** When true, {@link ARBTextureBorderClamp} is supported. */ + public final boolean GL_ARB_texture_border_clamp; + /** When true, {@link ARBTextureBufferObject} is supported. */ + public final boolean GL_ARB_texture_buffer_object; + /** + * When true, the ARB_texture_buffer_object_rgb32 extension is supported. + * + *This extension adds three new buffer texture formats - RGB32F, RGB32I, and RGB32UI. This partially addresses one of the limitations of buffer textures + * in the original {@link #GL_EXT_texture_buffer_object EXT_texture_buffer_object} extension and in {@link GL31 OpenGL 3.1}, which provide no support for three-component formats.
+ * + *Promoted to core in {@link GL40 OpenGL 4.0}.
+ */ + public final boolean GL_ARB_texture_buffer_object_rgb32; + /** When true, {@link ARBTextureBufferRange} is supported. */ + public final boolean GL_ARB_texture_buffer_range; + /** When true, {@link ARBTextureCompression} is supported. */ + public final boolean GL_ARB_texture_compression; + /** When true, {@link ARBTextureCompressionBPTC} is supported. */ + public final boolean GL_ARB_texture_compression_bptc; + /** When true, {@link ARBTextureCompressionRGTC} is supported. */ + public final boolean GL_ARB_texture_compression_rgtc; + /** When true, {@link ARBTextureCubeMap} is supported. */ + public final boolean GL_ARB_texture_cube_map; + /** When true, {@link ARBTextureCubeMapArray} is supported. */ + public final boolean GL_ARB_texture_cube_map_array; + /** + * When true, the ARB_texture_env_add extension is supported. + * + *This extension adds a new texture environment function: ADD.
+ * + *Promoted to core in {@link GL13 OpenGL 1.3}.
+ */ + public final boolean GL_ARB_texture_env_add; + /** When true, {@link ARBTextureEnvCombine} is supported. */ + public final boolean GL_ARB_texture_env_combine; + /** + * When true, the ARB_texture_env_crossbar extension is supported. + * + *This extension adds the capability to use the texture color from other texture units as sources to the {@link ARBTextureEnvCombine#GL_COMBINE_ARB COMBINE_ARB} environment + * function. The {@link ARBTextureEnvCombine ARB_texture_env_combine} extension defined texture environment functions which could use the color from the current texture unit + * as a source. This extension adds the ability to use the color from any texture unit as a source.
+ * + *Requires {@link #GL_ARB_multitexture ARB_multitexture} and {@link ARBTextureEnvCombine ARB_texture_env_combine}. Promoted to core in {@link GL14 OpenGL 1.4}.
+ */ + public final boolean GL_ARB_texture_env_crossbar; + /** When true, {@link ARBTextureEnvDot3} is supported. */ + public final boolean GL_ARB_texture_env_dot3; + /** When true, {@link ARBTextureFilterAnisotropic} is supported. */ + public final boolean GL_ARB_texture_filter_anisotropic; + /** When true, {@link ARBTextureFilterMinmax} is supported. */ + public final boolean GL_ARB_texture_filter_minmax; + /** When true, {@link ARBTextureFloat} is supported. */ + public final boolean GL_ARB_texture_float; + /** When true, {@link ARBTextureGather} is supported. */ + public final boolean GL_ARB_texture_gather; + /** When true, {@link ARBTextureMirrorClampToEdge} is supported. */ + public final boolean GL_ARB_texture_mirror_clamp_to_edge; + /** When true, {@link ARBTextureMirroredRepeat} is supported. */ + public final boolean GL_ARB_texture_mirrored_repeat; + /** When true, {@link ARBTextureMultisample} is supported. */ + public final boolean GL_ARB_texture_multisample; + /** + * When true, the ARB_texture_non_power_of_two extension is supported. + * + *Conventional OpenGL texturing is limited to images with power-of-two dimensions and an optional 1-texel border. This extension relaxes the size + * restrictions for the 1D, 2D, cube map, and 3D texture targets.
+ * + *Promoted to core in {@link GL20 OpenGL 2.0}.
+ */ + public final boolean GL_ARB_texture_non_power_of_two; + /** + * When true, the ARB_texture_query_levels extension is supported. + * + *This extension provides a new set of texture functions ({@code textureQueryLevels}) in the OpenGL Shading Language that exposes the number of accessible + * mipmap levels in the texture associated with a GLSL sampler variable. The set of accessible levels includes all the levels of the texture defined either + * through TexImage*, TexStorage*, or TextureView* ({@link ARBTextureView ARB_texture_view}) APIs that are not below the {@link GL12#GL_TEXTURE_BASE_LEVEL TEXTURE_BASE_LEVEL} or above the + * {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} parameters. For textures defined with TexImage*, the set of resident levels is somewhat implementation-dependent. For fully + * defined results, applications should use TexStorage*/TextureView unless the texture has a full mipmap chain and is used with a mipmapped minification + * filter.
+ * + *These functions means that shaders are not required to manually recompute, approximate, or maintain a uniform holding a pre-computed level count, since + * the true level count is already available to the implementation. This value can be used to avoid black or leaking pixel artifacts for rendering methods + * which are using texture images as memory pages (eg: virtual textures); methods that can't only rely on the fixed pipeline texture functions which take + * advantage of {@link GL12#GL_TEXTURE_MAX_LEVEL TEXTURE_MAX_LEVEL} for their sampling.
+ * + *Requires {@link GL30 OpenGL 3.0} and GLSL 1.30. Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ + public final boolean GL_ARB_texture_query_levels; + /** + * When true, the ARB_texture_query_lod extension is supported. + * + *This extension provides a new set of fragment shader texture functions ({@code textureLOD}) that return the results of automatic level-of-detail + * computations that would be performed if a texture lookup were performed.
+ * + *Requires {@link GL20 OpenGL 2.0}, {@link #GL_EXT_gpu_shader4 EXT_gpu_shader4}, {@link #GL_EXT_texture_array EXT_texture_array} and GLSL 1.30. Promoted to core in {@link GL40 OpenGL 4.0}.
+ */ + public final boolean GL_ARB_texture_query_lod; + /** When true, {@link ARBTextureRectangle} is supported. */ + public final boolean GL_ARB_texture_rectangle; + /** When true, {@link ARBTextureRG} is supported. */ + public final boolean GL_ARB_texture_rg; + /** When true, {@link ARBTextureRGB10_A2UI} is supported. */ + public final boolean GL_ARB_texture_rgb10_a2ui; + /** + * When true, the ARB_texture_stencil8 extension is supported. + * + *This extension accepts {@link GL30#GL_STENCIL_INDEX8 STENCIL_INDEX8} as a texture internal format, and adds STENCIL_INDEX8 to the required internal format list. This removes the + * need to use renderbuffers if a stencil-only format is desired.
+ * + *Promoted to core in {@link GL44 OpenGL 4.4}.
+ */ + public final boolean GL_ARB_texture_stencil8; + /** When true, {@link ARBTextureStorage} is supported. */ + public final boolean GL_ARB_texture_storage; + /** When true, {@link ARBTextureStorageMultisample} is supported. */ + public final boolean GL_ARB_texture_storage_multisample; + /** When true, {@link ARBTextureSwizzle} is supported. */ + public final boolean GL_ARB_texture_swizzle; + /** When true, {@link ARBTextureView} is supported. */ + public final boolean GL_ARB_texture_view; + /** When true, {@link ARBTimerQuery} is supported. */ + public final boolean GL_ARB_timer_query; + /** When true, {@link ARBTransformFeedback2} is supported. */ + public final boolean GL_ARB_transform_feedback2; + /** When true, {@link ARBTransformFeedback3} is supported. */ + public final boolean GL_ARB_transform_feedback3; + /** When true, {@link ARBTransformFeedbackInstanced} is supported. */ + public final boolean GL_ARB_transform_feedback_instanced; + /** When true, {@link ARBTransformFeedbackOverflowQuery} is supported. */ + public final boolean GL_ARB_transform_feedback_overflow_query; + /** When true, {@link ARBTransposeMatrix} is supported. */ + public final boolean GL_ARB_transpose_matrix; + /** When true, {@link ARBUniformBufferObject} is supported. */ + public final boolean GL_ARB_uniform_buffer_object; + /** When true, {@link ARBVertexArrayBGRA} is supported. */ + public final boolean GL_ARB_vertex_array_bgra; + /** When true, {@link ARBVertexArrayObject} is supported. */ + public final boolean GL_ARB_vertex_array_object; + /** When true, {@link ARBVertexAttrib64Bit} is supported. */ + public final boolean GL_ARB_vertex_attrib_64bit; + /** When true, {@link ARBVertexAttribBinding} is supported. */ + public final boolean GL_ARB_vertex_attrib_binding; + /** When true, {@link ARBVertexBlend} is supported. */ + public final boolean GL_ARB_vertex_blend; + /** When true, {@link ARBVertexBufferObject} is supported. */ + public final boolean GL_ARB_vertex_buffer_object; + /** When true, {@link ARBVertexProgram} is supported. */ + public final boolean GL_ARB_vertex_program; + /** When true, {@link ARBVertexShader} is supported. */ + public final boolean GL_ARB_vertex_shader; + /** + * When true, the ARB_vertex_type_10f_11f_11f_rev extension is supported. + * + *This extension a new vertex attribute data format: a packed 11.11.10 unsigned float vertex data format. This vertex data format can be used to describe + * a compressed 3 component stream of values that can be represented by 10- or 11-bit unsigned floating point values.
+ * + *The {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} vertex attribute type is equivalent to the {@link GL30#GL_R11F_G11F_B10F R11F_G11F_B10F} texture internal format.
+ * + *Requires {@link GL30 OpenGL 3.0} and {@link ARBVertexType2_10_10_10_REV ARB_vertex_type_2_10_10_10_rev}. Promoted to core in {@link GL44 OpenGL 4.4}.
+ */ + public final boolean GL_ARB_vertex_type_10f_11f_11f_rev; + /** When true, {@link ARBVertexType2_10_10_10_REV} is supported. */ + public final boolean GL_ARB_vertex_type_2_10_10_10_rev; + /** When true, {@link ARBViewportArray} is supported. */ + public final boolean GL_ARB_viewport_array; + /** When true, {@link ARBWindowPos} is supported. */ + public final boolean GL_ARB_window_pos; + /** When true, {@link ATIMeminfo} is supported. */ + public final boolean GL_ATI_meminfo; + /** When true, the ATI_shader_texture_lod extension is supported. */ + public final boolean GL_ATI_shader_texture_lod; + /** When true, {@link ATITextureCompression3DC} is supported. */ + public final boolean GL_ATI_texture_compression_3dc; + /** When true, {@link EXT422Pixels} is supported. */ + public final boolean GL_EXT_422_pixels; + /** When true, {@link EXTABGR} is supported. */ + public final boolean GL_EXT_abgr; + /** When true, {@link EXTBGRA} is supported. */ + public final boolean GL_EXT_bgra; + /** When true, {@link EXTBindableUniform} is supported. */ + public final boolean GL_EXT_bindable_uniform; + /** When true, {@link EXTBlendColor} is supported. */ + public final boolean GL_EXT_blend_color; + /** When true, {@link EXTBlendEquationSeparate} is supported. */ + public final boolean GL_EXT_blend_equation_separate; + /** When true, {@link EXTBlendFuncSeparate} is supported. */ + public final boolean GL_EXT_blend_func_separate; + /** When true, {@link EXTBlendMinmax} is supported. */ + public final boolean GL_EXT_blend_minmax; + /** When true, {@link EXTBlendSubtract} is supported. */ + public final boolean GL_EXT_blend_subtract; + /** When true, {@link EXTClipVolumeHint} is supported. */ + public final boolean GL_EXT_clip_volume_hint; + /** When true, {@link EXTCompiledVertexArray} is supported. */ + public final boolean GL_EXT_compiled_vertex_array; + /** When true, {@link EXTDebugLabel} is supported. */ + public final boolean GL_EXT_debug_label; + /** When true, {@link EXTDebugMarker} is supported. */ + public final boolean GL_EXT_debug_marker; + /** When true, {@link EXTDepthBoundsTest} is supported. */ + public final boolean GL_EXT_depth_bounds_test; + /** When true, {@link EXTDirectStateAccess} is supported. */ + public final boolean GL_EXT_direct_state_access; + /** When true, {@link EXTDrawBuffers2} is supported. */ + public final boolean GL_EXT_draw_buffers2; + /** When true, {@link EXTDrawInstanced} is supported. */ + public final boolean GL_EXT_draw_instanced; + /** When true, {@link EXTEGLImageStorage} is supported. */ + public final boolean GL_EXT_EGL_image_storage; + /** When true, {@link EXTExternalBuffer} is supported. */ + public final boolean GL_EXT_external_buffer; + /** When true, {@link EXTFramebufferBlit} is supported. */ + public final boolean GL_EXT_framebuffer_blit; + /** When true, {@link EXTFramebufferMultisample} is supported. */ + public final boolean GL_EXT_framebuffer_multisample; + /** When true, {@link EXTFramebufferMultisampleBlitScaled} is supported. */ + public final boolean GL_EXT_framebuffer_multisample_blit_scaled; + /** When true, {@link EXTFramebufferObject} is supported. */ + public final boolean GL_EXT_framebuffer_object; + /** When true, {@link EXTFramebufferSRGB} is supported. */ + public final boolean GL_EXT_framebuffer_sRGB; + /** When true, {@link EXTGeometryShader4} is supported. */ + public final boolean GL_EXT_geometry_shader4; + /** When true, {@link EXTGPUProgramParameters} is supported. */ + public final boolean GL_EXT_gpu_program_parameters; + /** When true, {@link EXTGPUShader4} is supported. */ + public final boolean GL_EXT_gpu_shader4; + /** When true, {@link EXTMemoryObject} is supported. */ + public final boolean GL_EXT_memory_object; + /** When true, {@link EXTMemoryObjectFD} is supported. */ + public final boolean GL_EXT_memory_object_fd; + /** When true, {@link EXTMemoryObjectWin32} is supported. */ + public final boolean GL_EXT_memory_object_win32; + /** + * When true, the EXT_multiview_tessellation_geometry_shader extension is supported. + * + *This extension removes one of the limitations of the {@code OVR_multiview} extension by allowing the use of tessellation control, tessellation + * evaluation, and geometry shaders during multiview rendering. {@code OVR_multiview} by itself forbids the use of any of these shader types.
+ * + *When using tessellation control, tessellation evaluation, and geometry shaders during multiview rendering, any such shader must use the + * "{@code num_views}" layout qualifier provided by the matching shading language extension to specify a view count. The view count specified in these + * shaders must match the count specified in the vertex shader. Additionally, the shading language extension allows these shaders to use the + * {@code gl_ViewID_OVR} built-in to handle tessellation or geometry shader processing differently for each view.
+ * + *{@code OVR_multiview2} extends {@code OVR_multiview} by allowing view-dependent values for any vertex attributes instead of just the position. This new + * extension does not imply the availability of {@code OVR_multiview2}, but if both are available, view-dependent values for any vertex attributes are + * also allowed in tessellation control, tessellation evaluation, and geometry shaders.
+ * + *Requires {@link GL40 OpenGL 4.0} and {@link OVRMultiview OVR_multiview}.
+ */ + public final boolean GL_EXT_multiview_tessellation_geometry_shader; + /** + * When true, the EXT_multiview_texture_multisample extension is supported. + * + *This extension removes one of the limitations of the {@code OVR_multiview} extension by allowing the use of multisample textures during multiview + * rendering.
+ * + *This is one of two extensions that allow multisampling when using {@code OVR_multiview}. Each supports one of the two different approaches to + * multisampling in OpenGL:
+ * + *Core OpenGL has explicit support for multisample texture types, such as {@link GL32#GL_TEXTURE_2D_MULTISAMPLE TEXTURE_2D_MULTISAMPLE}. Applications can access the values of individual + * samples and can explicitly "resolve" the samples of each pixel down to a single color.
+ * + *The extension {@code EXT_multisampled_render_to_texture} provides support for multisampled rendering to non-multisample texture types, such as + * {@link GL11#GL_TEXTURE_2D TEXTURE_2D}. The individual samples for each pixel are maintained internally by the implementation and can not be accessed directly by applications. + * These samples are eventually resolved implicitly to a single color for each pixel.
+ * + *This extension supports the first multisampling style with multiview rendering; the {@code OVR_multiview_multisampled_render_to_texture} extension + * supports the second style. Note that support for one of these multiview extensions does not imply support for the other.
+ * + *Requires {@link GL40 OpenGL 4.0} and {@link OVRMultiview OVR_multiview}.
+ */ + public final boolean GL_EXT_multiview_texture_multisample; + /** + * When true, the EXT_multiview_timer_query extension is supported. + * + *This extension removes one of the limitations of the {@code OVR_multiview} extension by allowing the use of timer queries during multiview rendering. + * {@code OVR_multiview} does not specify defined behavior for such usage.
+ * + *Requires {@link GL40 OpenGL 4.0} and {@link OVRMultiview OVR_multiview}.
+ */ + public final boolean GL_EXT_multiview_timer_query; + /** When true, {@link EXTPackedDepthStencil} is supported. */ + public final boolean GL_EXT_packed_depth_stencil; + /** When true, {@link EXTPackedFloat} is supported. */ + public final boolean GL_EXT_packed_float; + /** When true, {@link EXTPixelBufferObject} is supported. */ + public final boolean GL_EXT_pixel_buffer_object; + /** When true, {@link EXTPointParameters} is supported. */ + public final boolean GL_EXT_point_parameters; + /** When true, {@link EXTPolygonOffsetClamp} is supported. */ + public final boolean GL_EXT_polygon_offset_clamp; + /** + * When true, the EXT_post_depth_coverage extension is supported. + * + *This extension allows the fragment shader to control whether values in {@code gl_SampleMaskIn[]} reflect the coverage after application of the early + * depth and stencil tests. This feature can be enabled with the following layout qualifier in the fragment shader:
+ * + *
+ * layout(post_depth_coverage) in;To use this feature, early fragment tests must also be enabled in the fragment shader via:
+ * + *
+ * layout(early_fragment_tests) in;{@link ARBShaderImageLoadStore ARB_shader_image_load_store} (and OpenGL 4.2) added support for random access load and store from/to texture images, but due to hardware + * limitations, loads were required to declare the image format in the shader source. This extension relaxes that requirement, and the return values from + * {@code imageLoad} can be format-converted based on the format of the image binding.
+ */ + public final boolean GL_EXT_shader_image_load_formatted; + /** When true, {@link EXTShaderImageLoadStore} is supported. */ + public final boolean GL_EXT_shader_image_load_store; + /** + * When true, the EXT_shader_integer_mix extension is supported. + * + *GLSL 1.30 (and GLSL ES 3.00) expanded the mix() built-in function to operate on a boolean third argument that does not interpolate but selects. This + * extension extends mix() to select between int, uint, and bool components.
+ * + *Requires {@link GL30 OpenGL 3.0}.
+ */ + public final boolean GL_EXT_shader_integer_mix; + /** + * When true, the EXT_shadow_funcs extension is supported. + * + *This extension generalizes the {@link #GL_ARB_shadow ARB_shadow} extension to support all eight binary texture comparison functions rather than just {@link GL11#GL_LEQUAL LEQUAL} and + * {@link GL11#GL_GEQUAL GEQUAL}.
+ * + *Requires {@link #GL_ARB_depth_texture ARB_depth_texture} and {@link #GL_ARB_shadow ARB_shadow}.
+ */ + public final boolean GL_EXT_shadow_funcs; + /** When true, {@link EXTSharedTexturePalette} is supported. */ + public final boolean GL_EXT_shared_texture_palette; + /** + * When true, the EXT_sparse_texture2 extension is supported. + * + *This extension builds on the {@link ARBSparseTexture ARB_sparse_texture} extension, providing the following new functionality:
+ * + *New built-in GLSL texture lookup functions are provided that specify a minimum level of detail to use for lookups where the level of detail is + * computed automatically. This allows shaders to avoid accessing unpopulated portions of high-resolution levels of detail when it knows that the + * memory accessed is unpopulated, either from a priori knowledge or from feedback provided by the return value of previously executed "sparse" + * texture lookup functions.
+ * + *Reads of uncommitted texture memory will act as though such memory were filled with zeroes; previously, the values returned by reads were undefined.
+ * + *Standard implementation-independent virtual page sizes for internal formats required to be supported with sparse textures. These standard sizes can + * be requested by leaving {@link ARBSparseTexture#GL_VIRTUAL_PAGE_SIZE_INDEX_ARB VIRTUAL_PAGE_SIZE_INDEX_ARB} at its initial value (0).
+ * + *Support for creating sparse multisample and multisample array textures is added. However, the virtual page sizes for such textures remain fully + * implementation-dependent.
Requires {@link ARBSparseTexture ARB_sparse_texture}.
+ */ + public final boolean GL_EXT_sparse_texture2; + /** When true, {@link EXTStencilClearTag} is supported. */ + public final boolean GL_EXT_stencil_clear_tag; + /** When true, {@link EXTStencilTwoSide} is supported. */ + public final boolean GL_EXT_stencil_two_side; + /** When true, {@link EXTStencilWrap} is supported. */ + public final boolean GL_EXT_stencil_wrap; + /** When true, {@link EXTTextureArray} is supported. */ + public final boolean GL_EXT_texture_array; + /** When true, {@link EXTTextureBufferObject} is supported. */ + public final boolean GL_EXT_texture_buffer_object; + /** When true, {@link EXTTextureCompressionLATC} is supported. */ + public final boolean GL_EXT_texture_compression_latc; + /** When true, {@link EXTTextureCompressionRGTC} is supported. */ + public final boolean GL_EXT_texture_compression_rgtc; + /** When true, {@link EXTTextureCompressionS3TC} is supported. */ + public final boolean GL_EXT_texture_compression_s3tc; + /** When true, {@link EXTTextureFilterAnisotropic} is supported. */ + public final boolean GL_EXT_texture_filter_anisotropic; + /** When true, {@link EXTTextureFilterMinmax} is supported. */ + public final boolean GL_EXT_texture_filter_minmax; + /** When true, {@link EXTTextureInteger} is supported. */ + public final boolean GL_EXT_texture_integer; + /** When true, {@link EXTTextureMirrorClamp} is supported. */ + public final boolean GL_EXT_texture_mirror_clamp; + /** + * This extension adds support for various shadow sampler types with texture functions having interactions with the LOD of texture lookups. + * + *Modern shading languages support LOD queries for shadow sampler types, but until now the OpenGL Shading Language Specification has excluded multiple + * texture function overloads involving LOD calculations with various shadow samplers. Shading languages for other APIs do support the equivalent + * LOD-based texture sampling functions for these types which has made porting between those shading languages to GLSL cumbersome and has required the + * usage of sub-optimal workarounds.
+ * + *Requires {@link GL20 OpenGL 2.0} and {@link EXTGPUShader4 EXT_gpu_shader4} or equivalent functionality.
+ */ + public final boolean GL_EXT_texture_shadow_lod; + /** When true, {@link EXTTextureSharedExponent} is supported. */ + public final boolean GL_EXT_texture_shared_exponent; + /** When true, {@link EXTTextureSnorm} is supported. */ + public final boolean GL_EXT_texture_snorm; + /** When true, {@link EXTTextureSRGB} is supported. */ + public final boolean GL_EXT_texture_sRGB; + /** When true, {@link EXTTextureSRGBDecode} is supported. */ + public final boolean GL_EXT_texture_sRGB_decode; + /** When true, {@link EXTTextureSRGBR8} is supported. */ + public final boolean GL_EXT_texture_sRGB_R8; + /** When true, {@link EXTTextureSwizzle} is supported. */ + public final boolean GL_EXT_texture_swizzle; + /** When true, {@link EXTTimerQuery} is supported. */ + public final boolean GL_EXT_timer_query; + /** When true, {@link EXTTransformFeedback} is supported. */ + public final boolean GL_EXT_transform_feedback; + /** + * When true, the EXT_vertex_array_bgra extension is supported. + * + *This extension provides a single new component format for vertex arrays to read 4-component unsigned byte vertex attributes with a BGRA component + * ordering.
+ * + *OpenGL expects vertex arrays containing 4 unsigned bytes per element to be in the RGBA, STRQ, or XYZW order (reading components left-to-right in their + * lower address to higher address order). Essentially the order the components appear in memory is the order the components appear in the resulting + * vertex attribute vector.
+ * + *However Direct3D has color (diffuse and specular) vertex arrays containing 4 unsigned bytes per element that are in a BGRA order (again reading + * components left-to-right in their lower address to higher address order). Direct3D calls this "ARGB" reading the components in the opposite order + * (reading components left-to-right in their higher address to lower address order). This ordering is generalized in the DirectX 10 by the + * DXGI_FORMAT_B8G8R8A8_UNORM format.
+ * + *For an OpenGL application to source color data from a vertex buffer formatted for Direct3D's color array format conventions, the application is forced + * to either:
+ * + *Neither option is entirely satisfactory.
+ * + *Option 1 means vertex shaders have to be re-written to source colors differently. If the same vertex shader is used with vertex arrays configured to + * source the color as 4 floating-point color components, the swizzle for BGRA colors stored as 4 unsigned bytes is no longer appropriate. The shader's + * swizzling of colors becomes dependent on the type and number of color components. Ideally the vertex shader should be independent from the format and + * component ordering of the data it sources.
+ * + *Option 2 is expensive because vertex buffers may have to be reformatted prior to use. OpenGL treats the memory for vertex arrays (whether client-side + * memory or buffer objects) as essentially untyped memory and vertex arrays can be stored separately, interleaved, or even interwoven (where multiple + * arrays overlap with differing strides and formats).
+ * + *Rather than force a re-ordering of either vertex array components in memory or a vertex array format-dependent re-ordering of vertex shader inputs, + * OpenGL can simply provide a vertex array format that matches the Direct3D color component ordering.
+ * + *This approach mimics that of the EXT_bgra extension for pixel and texel formats except for vertex instead of image data.
+ */ + public final boolean GL_EXT_vertex_array_bgra; + /** When true, {@link EXTVertexAttrib64bit} is supported. */ + public final boolean GL_EXT_vertex_attrib_64bit; + /** When true, {@link EXTWin32KeyedMutex} is supported. */ + public final boolean GL_EXT_win32_keyed_mutex; + /** When true, {@link EXTWindowRectangles} is supported. */ + public final boolean GL_EXT_window_rectangles; + /** When true, {@link EXTX11SyncObject} is supported. */ + public final boolean GL_EXT_x11_sync_object; + /** When true, {@link GREMEDYFrameTerminator} is supported. */ + public final boolean GL_GREMEDY_frame_terminator; + /** When true, {@link GREMEDYStringMarker} is supported. */ + public final boolean GL_GREMEDY_string_marker; + /** When true, {@link INTELBlackholeRender} is supported. */ + public final boolean GL_INTEL_blackhole_render; + /** When true, {@link INTELConservativeRasterization} is supported. */ + public final boolean GL_INTEL_conservative_rasterization; + /** + * When true, the INTEL_fragment_shader_ordering extension is supported. + * + *Graphics devices may execute in parallel fragment shaders referring to the same window xy coordinates. Framebuffer writes are guaranteed to be + * processed in primitive rasterization order, but there is no order guarantee for other instructions and image or buffer object accesses in particular.
+ * + *The extension introduces a new GLSL built-in function, beginFragmentShaderOrderingINTEL(), which blocks execution of a fragment shader invocation until + * invocations from previous primitives that map to the same xy window coordinates (and same sample when per-sample shading is active) complete their + * execution. All memory transactions from previous fragment shader invocations are made visible to the fragment shader invocation that called + * beginFragmentShaderOrderingINTEL() when the function returns.
+ */ + public final boolean GL_INTEL_fragment_shader_ordering; + /** When true, {@link INTELFramebufferCMAA} is supported. */ + public final boolean GL_INTEL_framebuffer_CMAA; + /** When true, {@link INTELMapTexture} is supported. */ + public final boolean GL_INTEL_map_texture; + /** When true, {@link INTELPerformanceQuery} is supported. */ + public final boolean GL_INTEL_performance_query; + /** When true, {@link KHRBlendEquationAdvanced} is supported. */ + public final boolean GL_KHR_blend_equation_advanced; + /** When true, {@link KHRBlendEquationAdvancedCoherent} is supported. */ + public final boolean GL_KHR_blend_equation_advanced_coherent; + /** When true, {@link KHRContextFlushControl} is supported. */ + public final boolean GL_KHR_context_flush_control; + /** When true, {@link KHRDebug} is supported. */ + public final boolean GL_KHR_debug; + /** When true, {@link KHRNoError} is supported. */ + public final boolean GL_KHR_no_error; + /** When true, {@link KHRParallelShaderCompile} is supported. */ + public final boolean GL_KHR_parallel_shader_compile; + /** + * When true, the KHR_robust_buffer_access_behavior extension is supported. + * + *This extension specifies the behavior of out-of-bounds buffer and array accesses. This is an improvement over the existing {@link #GL_KHR_robustness KHR_robustness} + * extension which states that the application should not crash, but that behavior is otherwise undefined. This extension specifies the access protection + * provided by the GL to ensure that out-of-bounds accesses cannot read from or write to data not owned by the application. All accesses are contained + * within the buffer object and program area they reference. These additional robustness guarantees apply to contexts created with the robust access flag + * set.
+ * + *Requires {@link GL32 OpenGL 3.2} and {@link #GL_KHR_robustness KHR_robustness}.
+ */ + public final boolean GL_KHR_robust_buffer_access_behavior; + /** When true, {@link KHRRobustness} is supported. */ + public final boolean GL_KHR_robustness; + /** When true, {@link KHRShaderSubgroup} is supported. */ + public final boolean GL_KHR_shader_subgroup; + /** + * When true, the KHR_texture_compression_astc_hdr extension is supported. + * + *This extension corresponds to the ASTC HDR Profile, see {@link KHRTextureCompressionASTCLDR KHR_texture_compression_astc_ldr} for details.
+ */ + public final boolean GL_KHR_texture_compression_astc_hdr; + /** When true, {@link KHRTextureCompressionASTCLDR} is supported. */ + public final boolean GL_KHR_texture_compression_astc_ldr; + /** + * When true, the KHR_texture_compression_astc_sliced_3d extension is supported. + * + *Adaptive Scalable Texture Compression (ASTC) is a new texture compression technology that offers unprecendented flexibility, while producing better or + * comparable results than existing texture compressions at all bit rates. It includes support for 2D and slice-based 3D textures, with low and high + * dynamic range, at bitrates from below 1 bit/pixel up to 8 bits/pixel in fine steps.
+ * + *This extension extends the functionality of {@link KHRTextureCompressionASTCLDR KHR_texture_compression_astc_ldr} to include slice-based 3D textures for textures using the LDR + * profile in the same way as the HDR profile allows slice-based 3D textures.
+ * + *Requires {@link KHRTextureCompressionASTCLDR KHR_texture_compression_astc_ldr}.
+ */ + public final boolean GL_KHR_texture_compression_astc_sliced_3d; + /** When true, {@link NVAlphaToCoverageDitherControl} is supported. */ + public final boolean GL_NV_alpha_to_coverage_dither_control; + /** When true, {@link NVBindlessMultiDrawIndirect} is supported. */ + public final boolean GL_NV_bindless_multi_draw_indirect; + /** When true, {@link NVBindlessMultiDrawIndirectCount} is supported. */ + public final boolean GL_NV_bindless_multi_draw_indirect_count; + /** When true, {@link NVBindlessTexture} is supported. */ + public final boolean GL_NV_bindless_texture; + /** When true, {@link NVBlendEquationAdvanced} is supported. */ + public final boolean GL_NV_blend_equation_advanced; + /** When true, {@link NVBlendEquationAdvancedCoherent} is supported. */ + public final boolean GL_NV_blend_equation_advanced_coherent; + /** When true, {@link NVBlendMinmaxFactor} is supported. */ + public final boolean GL_NV_blend_minmax_factor; + /** When true, the NV_blend_square extension is supported. */ + public final boolean GL_NV_blend_square; + /** When true, {@link NVClipSpaceWScaling} is supported. */ + public final boolean GL_NV_clip_space_w_scaling; + /** When true, {@link NVCommandList} is supported. */ + public final boolean GL_NV_command_list; + /** + * When true, the NV_compute_shader_derivatives extension is supported. + * + *This extension adds OpenGL API support for the OpenGL Shading Language (GLSL) extension {@code "NV_compute_shader_derivatives"}.
+ * + *That extension, when enabled, allows applications to use derivatives in compute shaders. It adds compute shader support for explicit derivative + * built-in functions like {@code dFdx()}, automatic derivative computation in texture lookup functions like {@code texture()}, use of the optional LOD + * bias parameter to adjust the computed level of detail values in texture lookup functions, and the texture level of detail query function + * {@code textureQueryLod()}.
+ * + *Requires {@link GL45 OpenGL 4.5}.
+ */ + public final boolean GL_NV_compute_shader_derivatives; + /** When true, {@link NVConditionalRender} is supported. */ + public final boolean GL_NV_conditional_render; + /** When true, {@link NVConservativeRaster} is supported. */ + public final boolean GL_NV_conservative_raster; + /** When true, {@link NVConservativeRasterDilate} is supported. */ + public final boolean GL_NV_conservative_raster_dilate; + /** When true, {@link NVConservativeRasterPreSnap} is supported. */ + public final boolean GL_NV_conservative_raster_pre_snap; + /** When true, {@link NVConservativeRasterPreSnapTriangles} is supported. */ + public final boolean GL_NV_conservative_raster_pre_snap_triangles; + /** + * When true, the NV_conservative_raster_underestimation extension is supported. + * + *The extension {@link NVConservativeRaster NV_conservative_raster} provides a new rasterization mode known as "Overestimated Conservative Rasterization", where any pixel + * that is partially covered, even if no sample location is covered, is treated as fully covered and a corresponding fragment will be shaded. There is + * also an "Underestimated Conservative Rasterization" variant, where only the pixels that are completely covered by the primitive are rasterized.
+ * + *This extension provides the underestimated conservative rasterization information for each fragment in the fragment shader through a new built-in + * {@code gl_FragFullyCoveredNV}.
+ */ + public final boolean GL_NV_conservative_raster_underestimation; + /** When true, {@link NVCopyDepthToColor} is supported. */ + public final boolean GL_NV_copy_depth_to_color; + /** When true, {@link NVCopyImage} is supported. */ + public final boolean GL_NV_copy_image; + /** When true, {@link NVDeepTexture3D} is supported. */ + public final boolean GL_NV_deep_texture3D; + /** When true, {@link NVDepthBufferFloat} is supported. */ + public final boolean GL_NV_depth_buffer_float; + /** When true, {@link NVDepthClamp} is supported. */ + public final boolean GL_NV_depth_clamp; + /** When true, {@link NVDrawTexture} is supported. */ + public final boolean GL_NV_draw_texture; + /** When true, {@link NVDrawVulkanImage} is supported. */ + public final boolean GL_NV_draw_vulkan_image; + /** When true, the NV_ES3_1_compatibility extension is supported. */ + public final boolean GL_NV_ES3_1_compatibility; + /** When true, {@link NVExplicitMultisample} is supported. */ + public final boolean GL_NV_explicit_multisample; + /** When true, {@link NVFence} is supported. */ + public final boolean GL_NV_fence; + /** When true, {@link NVFillRectangle} is supported. */ + public final boolean GL_NV_fill_rectangle; + /** When true, {@link NVFloatBuffer} is supported. */ + public final boolean GL_NV_float_buffer; + /** When true, {@link NVFogDistance} is supported. */ + public final boolean GL_NV_fog_distance; + /** When true, {@link NVFragmentCoverageToColor} is supported. */ + public final boolean GL_NV_fragment_coverage_to_color; + /** When true, the NV_fragment_program4 extension is supported. */ + public final boolean GL_NV_fragment_program4; + /** When true, the NV_fragment_program_option extension is supported. */ + public final boolean GL_NV_fragment_program_option; + /** + * When true, the NV_fragment_shader_barycentric extension is supported. + * + *This extension advertises OpenGL support for the OpenGL Shading Language (GLSL) extension {@code "NV_fragment_shader_barycentric"}, which provides + * fragment shader built-in variables holding barycentric weight vectors that identify the location of the fragment within its primitive. Additionally, + * the GLSL extension allows fragment the ability to read raw attribute values for each of the vertices of the primitive that produced the fragment.
+ * + *Requires {@link GL45 OpenGL 4.5}.
+ */ + public final boolean GL_NV_fragment_shader_barycentric; + /** + * When true, the NV_fragment_shader_interlock extension is supported. + * + *In unextended OpenGL 4.3, applications may produce a large number of fragment shader invocations that perform loads and stores to memory using image + * uniforms, atomic counter uniforms, buffer variables, or pointers. The order in which loads and stores to common addresses are performed by different + * fragment shader invocations is largely undefined. For algorithms that use shader writes and touch the same pixels more than once, one or more of the + * following techniques may be required to ensure proper execution ordering:
+ * + *This extension provides new GLSL built-in functions beginInvocationInterlockNV() and endInvocationInterlockNV() that delimit a critical section of + * fragment shader code. For pairs of shader invocations with "overlapping" coverage in a given pixel, the OpenGL implementation will guarantee that the + * critical section of the fragment shader will be executed for only one fragment at a time.
+ * + *There are four different interlock modes supported by this extension, which are identified by layout qualifiers. The qualifiers + * "pixel_interlock_ordered" and "pixel_interlock_unordered" provides mutual exclusion in the critical section for any pair of fragments corresponding to + * the same pixel. When using multisampling, the qualifiers "sample_interlock_ordered" and "sample_interlock_unordered" only provide mutual exclusion for + * pairs of fragments that both cover at least one common sample in the same pixel; these are recommended for performance if shaders use per-sample data + * structures.
+ * + *Additionally, when the "pixel_interlock_ordered" or "sample_interlock_ordered" layout qualifier is used, the interlock also guarantees that the + * critical section for multiple shader invocations with "overlapping" coverage will be executed in the order in which the primitives were processed by + * the GL. Such a guarantee is useful for applications like blending in the fragment shader, where an application requires that fragment values to be + * composited in the framebuffer in primitive order.
+ * + *This extension can be useful for algorithms that need to access per-pixel data structures via shader loads and stores. Such algorithms using this + * extension can access such data structures in the critical section without worrying about other invocations for the same pixel accessing the data + * structures concurrently. Additionally, the ordering guarantees are useful for cases where the API ordering of fragments is meaningful. For example, + * applications may be able to execute programmable blending operations in the fragment shader, where the destination buffer is read via image loads and + * the final value is written via image stores.
+ * + *Requires {@link GL43 OpenGL 4.3} and GLSL 4.30.
+ */ + public final boolean GL_NV_fragment_shader_interlock; + /** When true, {@link NVFramebufferMixedSamples} is supported. */ + public final boolean GL_NV_framebuffer_mixed_samples; + /** When true, {@link NVFramebufferMultisampleCoverage} is supported. */ + public final boolean GL_NV_framebuffer_multisample_coverage; + /** + * When true, the NV_geometry_shader4 extension is supported. + * + *This extension builds upon the {@link #GL_EXT_geometry_shader4 EXT_geometry_shader4} specification to provide two additional capabilities:
+ * + *Requires {@link #GL_EXT_geometry_shader4 EXT_geometry_shader4}.
+ */ + public final boolean GL_NV_geometry_shader4; + /** + * When true, the NV_geometry_shader_passthrough extension is supported. + * + *This extension provides a shading language abstraction to express such shaders without requiring explicit logic to manually copy attributes from input + * vertices to output vertices.
+ */ + public final boolean GL_NV_geometry_shader_passthrough; + /** When true, {@link NVGPUMulticast} is supported. */ + public final boolean GL_NV_gpu_multicast; + /** When true, {@link NVGPUShader5} is supported. */ + public final boolean GL_NV_gpu_shader5; + /** When true, {@link NVHalfFloat} is supported. */ + public final boolean GL_NV_half_float; + /** When true, {@link NVInternalformatSampleQuery} is supported. */ + public final boolean GL_NV_internalformat_sample_query; + /** When true, {@link NVLightMaxExponent} is supported. */ + public final boolean GL_NV_light_max_exponent; + /** When true, {@link NVMemoryAttachment} is supported. */ + public final boolean GL_NV_memory_attachment; + /** When true, {@link NVMeshShader} is supported. */ + public final boolean GL_NV_mesh_shader; + /** When true, {@link NVMultisampleCoverage} is supported. */ + public final boolean GL_NV_multisample_coverage; + /** When true, {@link NVMultisampleFilterHint} is supported. */ + public final boolean GL_NV_multisample_filter_hint; + /** When true, {@link NVPackedDepthStencil} is supported. */ + public final boolean GL_NV_packed_depth_stencil; + /** When true, {@link NVPathRendering} is supported. */ + public final boolean GL_NV_path_rendering; + /** When true, {@link NVPathRenderingSharedEdge} is supported. */ + public final boolean GL_NV_path_rendering_shared_edge; + /** When true, {@link NVPixelDataRange} is supported. */ + public final boolean GL_NV_pixel_data_range; + /** When true, {@link NVPointSprite} is supported. */ + public final boolean GL_NV_point_sprite; + /** When true, {@link NVPrimitiveRestart} is supported. */ + public final boolean GL_NV_primitive_restart; + /** When true, {@link NVQueryResource} is supported. */ + public final boolean GL_NV_query_resource; + /** When true, {@link NVQueryResourceTag} is supported. */ + public final boolean GL_NV_query_resource_tag; + /** When true, {@link NVRepresentativeFragmentTest} is supported. */ + public final boolean GL_NV_representative_fragment_test; + /** When true, {@link NVRobustnessVideoMemoryPurge} is supported. */ + public final boolean GL_NV_robustness_video_memory_purge; + /** When true, {@link NVSampleLocations} is supported. */ + public final boolean GL_NV_sample_locations; + /** + * When true, the NV_sample_mask_override_coverage extension is supported. + * + *This extension allows the fragment shader to control whether the gl_SampleMask output can enable samples that were not covered by the original + * primitive, or that failed the early depth/stencil tests.
+ */ + public final boolean GL_NV_sample_mask_override_coverage; + /** When true, {@link NVScissorExclusive} is supported. */ + public final boolean GL_NV_scissor_exclusive; + /** + * When true, the NV_shader_atomic_float extension is supported. + * + *This extension provides GLSL built-in functions and assembly opcodes allowing shaders to perform atomic read-modify-write operations to buffer or + * texture memory with floating-point components. The set of atomic operations provided by this extension is limited to adds and exchanges. Providing + * atomic add support allows shaders to atomically accumulate the sum of floating-point values into buffer or texture memory across multiple (possibly + * concurrent) shader invocations.
+ * + *This extension provides GLSL support for atomics targeting image uniforms (if GLSL 4.20, {@link #GL_ARB_shader_image_load_store ARB_shader_image_load_store}, or + * {@link #GL_EXT_shader_image_load_store EXT_shader_image_load_store} is supported) or floating-point pointers (if {@link #GL_NV_gpu_shader5 NV_gpu_shader5} is supported). Additionally, assembly opcodes + * for these operations is also provided if NV_gpu_program5 is supported.
+ */ + public final boolean GL_NV_shader_atomic_float; + /** + * When true, the NV_shader_atomic_float64 extension is supported. + * + *This extension provides GLSL built-in functions and assembly opcodes allowing shaders to perform atomic read-modify-write operations to buffer or + * shared memory with double-precision floating-point components. The set of atomic operations provided by this extension is limited to adds and + * exchanges. Providing atomic add support allows shaders to atomically accumulate the sum of double-precision floating-point values into buffer memory + * across multiple (possibly concurrent) shader invocations.
+ * + *This extension provides GLSL support for atomics targeting double-precision floating-point pointers (if {@link NVGPUShader5 NV_gpu_shader5} is supported). + * Additionally, assembly opcodes for these operations are also provided if {@code NV_gpu_program5} is supported.
+ * + *Requires {@link ARBGPUShaderFP64 ARB_gpu_shader_fp64} or {@code NV_gpu_program_fp64}.
+ */ + public final boolean GL_NV_shader_atomic_float64; + /** + * When true, the NV_shader_atomic_fp16_vector extension is supported. + * + *This extension provides GLSL built-in functions and assembly opcodes allowing shaders to perform a limited set of atomic read-modify-write operations + * to buffer or texture memory with 16-bit floating point vector surface formats.
+ * + *Requires {@link #GL_NV_gpu_shader5 NV_gpu_shader5}.
+ */ + public final boolean GL_NV_shader_atomic_fp16_vector; + /** + * When true, the NV_shader_atomic_int64 extension is supported. + * + *This extension provides additional GLSL built-in functions and assembly opcodes allowing shaders to perform additional atomic read-modify-write + * operations on 64-bit signed and unsigned integers stored in buffer object memory.
+ */ + public final boolean GL_NV_shader_atomic_int64; + /** When true, {@link NVShaderBufferLoad} is supported. */ + public final boolean GL_NV_shader_buffer_load; + /** When true, {@link NVShaderBufferStore} is supported. */ + public final boolean GL_NV_shader_buffer_store; + /** When true, {@link NVShaderSubgroupPartitioned} is supported. */ + public final boolean GL_NV_shader_subgroup_partitioned; + /** + * When true, the NV_shader_texture_footprint extension is supported. + * + *This extension adds OpenGL API support for the OpenGL Shading Language (GLSL) extension {@code "NV_shader_texture_footprint"}. That extension adds a + * new set of texture query functions ({@code "textureFootprint*NV"}) to GLSL. These built-in functions prepare to perform a filtered texture lookup based + * on coordinates and other parameters passed in by the calling code. However, instead of returning data from the provided texture image, these query + * functions instead return data identifying the texture footprint for an equivalent texture access. The texture footprint identifies a set of + * texels that may be accessed in order to return a filtered result for the texture access.
+ * + *The footprint itself is a structure that includes integer values that identify a small neighborhood of texels in the texture being accessed and a + * bitfield that indicates which texels in that neighborhood would be used. Each bit in the returned bitfield identifies whether any texel in a small + * aligned block of texels would be fetched by the texture lookup. The size of each block is specified by an access granularity provided by the + * shader. The minimum granularity supported by this extension is 2x2 (for 2D textures) and 2x2x2 (for 3D textures); the maximum granularity is 256x256 + * (for 2D textures) or 64x32x32 (for 3D textures). Each footprint query returns the footprint from a single texture level. When using minification + * filters that combine accesses from multiple mipmap levels, shaders must perform separate queries for the two levels accessed ("fine" and "coarse"). The + * footprint query also returns a flag indicating if the texture lookup would access texels from only one mipmap level or from two neighboring levels.
+ * + *This extension should be useful for multi-pass rendering operations that do an initial expensive rendering pass to produce a first image that is then + * used as a texture for a second pass. If the second pass ends up accessing only portions of the first image (e.g., due to visibility), the work spent + * rendering the non-accessed portion of the first image was wasted. With this feature, an application can limit this waste using an initial pass over the + * geometry in the second image that performs a footprint query for each visible pixel to determine the set of pixels that it needs from the first image. + * This pass would accumulate an aggregate footprint of all visible pixels into a separate "footprint texture" using shader atomics. Then, when rendering + * the first image, the application can kill all shading work for pixels not in this aggregate footprint.
+ * + *The implementation of this extension has a number of limitations. The texture footprint query functions are only supported for two- and + * three-dimensional textures ({@link GL11#GL_TEXTURE_2D TEXTURE_2D}, {@link GL12#GL_TEXTURE_3D TEXTURE_3D}). Texture footprint evaluation only supports the {@link GL12#GL_CLAMP_TO_EDGE CLAMP_TO_EDGE} wrap mode; results are undefined + * for all other wrap modes. The implementation supports only a limited set of granularity values and does not support separate coverage information for + * each texel in the original texture.
+ * + *Requires {@link GL45 OpenGL 4.5}.
+ */ + public final boolean GL_NV_shader_texture_footprint; + /** When true, {@link NVShaderThreadGroup} is supported. */ + public final boolean GL_NV_shader_thread_group; + /** + * When true, the NV_shader_thread_shuffle extension is supported. + * + *Implementations of the OpenGL Shading Language may, but are not required, to run multiple shader threads for a single stage as a SIMD thread group, + * where individual execution threads are assigned to thread groups in an undefined, implementation-dependent order. This extension provides a set of + * new features to the OpenGL Shading Language to share data between multiple threads within a thread group.
+ * + *Requires {@link GL43 OpenGL 4.3} and GLSL 4.3.
+ */ + public final boolean GL_NV_shader_thread_shuffle; + /** When true, {@link NVShadingRateImage} is supported. */ + public final boolean GL_NV_shading_rate_image; + /** + * When true, the NV_stereo_view_rendering extension is supported. + * + *Virtual reality (VR) applications often render a single logical scene from multiple views corresponding to a pair of eyes. The views (eyes) are + * separated by a fixed offset in the X direction.
+ * + *Traditionally, multiple views are rendered via multiple rendering passes. This is expensive for the GPU because the objects in the scene must be + * transformed, rasterized, shaded, and fragment processed redundantly. This is expensive for the CPU because the scene graph needs to be visited multiple + * times and driver validation happens for each view. Rendering N passes tends to take N times longer than a single pass.
+ * + *This extension provides a mechanism to render binocular (stereo) views from a single stream of OpenGL rendering commands. Vertex, tessellation, and + * geometry (VTG) shaders can output two positions for each vertex corresponding to the two eye views. A built-in "gl_SecondaryPositionNV" is added to + * specify the second position. The positions from each view may be sent to different viewports and/or layers. A built-in "gl_SecondaryViewportMaskNV[]" + * is also added to specify the viewport mask for the second view. A new layout-qualifier "secondary_view_offset" is added for built-in output "gl_Layer" + * which allows for the geometry from each view to be sent to different layers for rendering.
+ * + *Requires {@link #GL_NV_viewport_array2 NV_viewport_array2}.
+ */ + public final boolean GL_NV_stereo_view_rendering; + /** When true, {@link NVTexgenReflection} is supported. */ + public final boolean GL_NV_texgen_reflection; + /** When true, {@link NVTextureBarrier} is supported. */ + public final boolean GL_NV_texture_barrier; + /** + * When true, the NV_texture_compression_vtc extension is supported. + * + *This extension adds support for the VTC 3D texture compression formats, which are analogous to the S3TC texture compression formats, with the addition + * of some retiling in the Z direction. VTC has the same compression ratio as S3TC and uses 4x4x1, 4x4x2, (4x4x3 when non-power-of-two textures are + * supported), or 4x4x4 blocks.
+ */ + public final boolean GL_NV_texture_compression_vtc; + /** When true, {@link NVTextureMultisample} is supported. */ + public final boolean GL_NV_texture_multisample; + /** + * When true, the NV_texture_rectangle_compressed extension is supported. + * + *This extension allows applications to use compressed texture formats with the {@link GL31#GL_TEXTURE_RECTANGLE TEXTURE_RECTANGLE} texture target, removing an old limitation that + * prohibited such usage globally for rectangle textures.
+ */ + public final boolean GL_NV_texture_rectangle_compressed; + /** When true, {@link NVTransformFeedback} is supported. */ + public final boolean GL_NV_transform_feedback; + /** When true, {@link NVTransformFeedback2} is supported. */ + public final boolean GL_NV_transform_feedback2; + /** When true, {@link NVUniformBufferUnifiedMemory} is supported. */ + public final boolean GL_NV_uniform_buffer_unified_memory; + /** When true, {@link NVVertexArrayRange} is supported. */ + public final boolean GL_NV_vertex_array_range; + /** When true, {@link NVVertexArrayRange2} is supported. */ + public final boolean GL_NV_vertex_array_range2; + /** When true, {@link NVVertexAttribInteger64bit} is supported. */ + public final boolean GL_NV_vertex_attrib_integer_64bit; + /** When true, {@link NVVertexBufferUnifiedMemory} is supported. */ + public final boolean GL_NV_vertex_buffer_unified_memory; + /** + * When true, the NV_viewport_array2 extension is supported. + * + *This extension provides new support allowing a single primitive to be broadcast to multiple viewports and/or multiple layers. A shader output + * gl_ViewportMask[] is provided, allowing a single primitive to be output to multiple viewports simultaneously. Also, a new shader option is provided to + * control whether the effective viewport index is added into gl_Layer. These capabilities allow a single primitive to be output to multiple layers + * simultaneously.
+ * + *The gl_ViewportMask[] output is available in vertex, tessellation control, tessellation evaluation, and geometry shaders. gl_ViewportIndex and gl_Layer + * are also made available in all these shader stages. The actual viewport index or mask and render target layer values are taken from the last active + * shader stage from this set of stages.
+ * + *This extension is a superset of the GL_AMD_vertex_shader_layer and GL_AMD_vertex_shader_viewport_index extensions, and thus those extension strings are + * expected to be exported if GL_NV_viewport_array2 is supported.
+ */ + public final boolean GL_NV_viewport_array2; + /** When true, {@link NVViewportSwizzle} is supported. */ + public final boolean GL_NV_viewport_swizzle; + /** + * When true, the NVX_blend_equation_advanced_multi_draw_buffers extension is supported. + * + *This extension adds support for using advanced blend equations introduced with {@link NVBlendEquationAdvanced NV_blend_equation_advanced} (and standardized by + * {@link KHRBlendEquationAdvanced KHR_blend_equation_advanced}) in conjunction with multiple draw buffers. The NV_blend_equation_advanced extension supports advanced blending + * equations only when rending to a single color buffer using fragment color zero and throws and {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error when multiple draw buffers are + * used. This extension removes this restriction.
+ * + *Requires either {@link NVBlendEquationAdvanced NV_blend_equation_advanced} or {@link KHRBlendEquationAdvanced KHR_blend_equation_advanced}.
+ */ + public final boolean GL_NVX_blend_equation_advanced_multi_draw_buffers; + /** When true, {@link NVXConditionalRender} is supported. */ + public final boolean GL_NVX_conditional_render; + /** When true, {@link NVXGPUMemoryInfo} is supported. */ + public final boolean GL_NVX_gpu_memory_info; + /** When true, {@link NVXGpuMulticast2} is supported. */ + public final boolean GL_NVX_gpu_multicast2; + /** When true, {@link NVXProgressFence} is supported. */ + public final boolean GL_NVX_progress_fence; + /** When true, {@link OVRMultiview} is supported. */ + public final boolean GL_OVR_multiview; + /** + * When true, the OVR_multiview2 extension is supported. + * + *This extension relaxes the restriction in OVR_multiview that only {@code gl_Position} can depend on {@code ViewID} in the vertex shader. With this + * change, view-dependent outputs like reflection vectors and similar are allowed.
+ * + *Requires {@link GL30 OpenGL 3.0} and {@link OVRMultiview OVR_multiview}.
+ */ + public final boolean GL_OVR_multiview2; + + /** When true, deprecated functions are not available. */ + public final boolean forwardCompatible; + + /** Off-heap array of the above function addresses. */ + final PointerBuffer addresses; + + GLCapabilities(FunctionProvider provider, Set
+ * void (*) (
+ * GLuint id,
+ * GLenum category,
+ * GLenum severity,
+ * GLsizei length,
+ * GLchar const *message,
+ * void *userParam
+ * )This method may only be used inside a GLDebugMessageAMDCallback invocation.
+ * + * @param length the GLDebugMessageAMDCallback {@code length} argument + * @param message the GLDebugMessageAMDCallback {@code message} argument + * + * @return the message as a String + */ + public static String getMessage(int length, long message) { + return memUTF8(memByteBuffer(message, length)); + } + + private static final class Container extends GLDebugMessageAMDCallback { + + private final GLDebugMessageAMDCallbackI delegate; + + Container(long functionPointer, GLDebugMessageAMDCallbackI delegate) { + super(functionPointer); + this.delegate = delegate; + } + + @Override + public void invoke(int id, int category, int severity, int length, long message, long userParam) { + delegate.invoke(id, category, severity, length, message, userParam); + } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLDebugMessageAMDCallbackI.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLDebugMessageAMDCallbackI.java new file mode 100644 index 00000000..ec1d9133 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLDebugMessageAMDCallbackI.java @@ -0,0 +1,60 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.dyncall.DynCallback.*; + +/** + * Instances of this interface may be passed to the {@link AMDDebugOutput#glDebugMessageCallbackAMD DebugMessageCallbackAMD} method. + * + *
+ * void (*) (
+ * GLuint id,
+ * GLenum category,
+ * GLenum severity,
+ * GLsizei length,
+ * GLchar const *message,
+ * void *userParam
+ * )
+ * void (*) (
+ * GLenum source,
+ * GLenum type,
+ * GLuint id,
+ * GLenum severity,
+ * GLsizei length,
+ * GLchar const *message,
+ * void const *userParam
+ * )This method may only be used inside a GLDebugMessageARBCallback invocation.
+ * + * @param length the GLDebugMessageARBCallback {@code length} argument + * @param message the GLDebugMessageARBCallback {@code message} argument + * + * @return the message as a String + */ + public static String getMessage(int length, long message) { + return memUTF8(memByteBuffer(message, length)); + } + + private static final class Container extends GLDebugMessageARBCallback { + + private final GLDebugMessageARBCallbackI delegate; + + Container(long functionPointer, GLDebugMessageARBCallbackI delegate) { + super(functionPointer); + this.delegate = delegate; + } + + @Override + public void invoke(int source, int type, int id, int severity, int length, long message, long userParam) { + delegate.invoke(source, type, id, severity, length, message, userParam); + } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLDebugMessageARBCallbackI.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLDebugMessageARBCallbackI.java new file mode 100644 index 00000000..61cfdcd1 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLDebugMessageARBCallbackI.java @@ -0,0 +1,63 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.dyncall.DynCallback.*; + +/** + * Instances of this interface may be passed to the {@link ARBDebugOutput#glDebugMessageCallbackARB DebugMessageCallbackARB} method. + * + *
+ * void (*) (
+ * GLenum source,
+ * GLenum type,
+ * GLuint id,
+ * GLenum severity,
+ * GLsizei length,
+ * GLchar const *message,
+ * void const *userParam
+ * )
+ * void (*) (
+ * GLenum source,
+ * GLenum type,
+ * GLuint id,
+ * GLenum severity,
+ * GLsizei length,
+ * GLchar const *message,
+ * void const *userParam
+ * )This method may only be used inside a GLDebugMessageCallback invocation.
+ * + * @param length the GLDebugMessageCallback {@code length} argument + * @param message the GLDebugMessageCallback {@code message} argument + * + * @return the message as a String + */ + public static String getMessage(int length, long message) { + return memUTF8(memByteBuffer(message, length)); + } + + private static final class Container extends GLDebugMessageCallback { + + private final GLDebugMessageCallbackI delegate; + + Container(long functionPointer, GLDebugMessageCallbackI delegate) { + super(functionPointer); + this.delegate = delegate; + } + + @Override + public void invoke(int source, int type, int id, int severity, int length, long message, long userParam) { + delegate.invoke(source, type, id, severity, length, message, userParam); + } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLDebugMessageCallbackI.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLDebugMessageCallbackI.java new file mode 100644 index 00000000..d7366f1a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLDebugMessageCallbackI.java @@ -0,0 +1,63 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.dyncall.DynCallback.*; + +/** + * Instances of this interface may be passed to the {@link GL43#glDebugMessageCallback} and {@link KHRDebug#glDebugMessageCallback} methods. + * + *
+ * void (*) (
+ * GLenum source,
+ * GLenum type,
+ * GLuint id,
+ * GLenum severity,
+ * GLsizei length,
+ * GLchar const *message,
+ * void const *userParam
+ * )If {@code ctx} is still current to any thread, {@code ctx} is not destroyed until it is no longer current. In any event, the associated XID will be + * destroyed and {@code ctx} cannot subsequently be made current to any thread.
+ * + * @param display the connection to the X server + * @param ctx the GLXContext to destroy + */ + public static void glXDestroyContext(@NativeType("Display *") long display, @NativeType("GLXContext") long ctx) { + long __functionAddress = Functions.DestroyContext; + if (CHECKS) { + check(display); + check(ctx); + } + callPPV(display, ctx, __functionAddress); + } + + // --- [ glXGetCurrentContext ] --- + + /** Returns the GLXContext that is current in the current thread. */ + @NativeType("GLXContext") + public static long glXGetCurrentContext() { + long __functionAddress = Functions.GetCurrentContext; + return callP(__functionAddress); + } + + // --- [ glXGetCurrentDrawable ] --- + + /** Returns the XID of the current drawable used for rendering. */ + @NativeType("GLXDrawable") + public static long glXGetCurrentDrawable() { + long __functionAddress = Functions.GetCurrentDrawable; + return callP(__functionAddress); + } + + // --- [ glXWaitGL ] --- + + /** + * Prevents X requests from executing until any outstanding OpenGL rendering is done. + * + *OpenGL calls made prior to {@code glXWaitGL} are guaranteed to be executed before X rendering calls made after {@code glXWaitGL}. While the same result + * can be achieved using {@link GL11C#glFinish Finish}, {@code glXWaitGL} does not require a round trip to the server, and is therefore more efficient in cases + * where the client and server are on separate machines.
+ */ + public static void glXWaitGL() { + long __functionAddress = Functions.WaitGL; + callV(__functionAddress); + } + + // --- [ glXWaitX ] --- + + /** + * Prevents the OpenGL command sequence from executing until any outstanding X requests are completed. + * + *X rendering calls made prior to {@code glXWaitX} are guaranteed to be executed before OpenGL rendering calls made after {@code glXWaitX}. While the same + * result can be achieved using {@code XSync()}, {@code glXWaitX} does not require a round trip to the server, and may therefore be more efficient.
+ */ + public static void glXWaitX() { + long __functionAddress = Functions.WaitX; + callV(__functionAddress); + } + + // --- [ glXSwapBuffers ] --- + + /** + * For drawables that are double buffered, makes the contexts of the back buffer potentially visible (i.e., become the contents of the front buffer). + * + *The contents of the back buffer then become undefined. This operation is a no-op if draw was created with a non-double-buffered GLXFBConfig, or if draw + * is a GLXPixmap.
+ * + * @param display the connection to the X server + * @param draw a double buffered GLXDrawable + */ + public static void glXSwapBuffers(@NativeType("Display *") long display, @NativeType("GLXDrawable") long draw) { + long __functionAddress = Functions.SwapBuffers; + if (CHECKS) { + check(display); + check(draw); + } + callPPV(display, draw, __functionAddress); + } + + // --- [ glXUseXFont ] --- + + /** + * Provides a shortcut for using X fonts. + * + * @param font the font to use + * @param first the first glyph in the font to use + * @param count the number of display lists to define + * @param list_base the base list number + */ + public static void glXUseXFont(@NativeType("Font") long font, int first, int count, int list_base) { + long __functionAddress = Functions.UseXFont; + callNV(font, first, count, list_base, __functionAddress); + } + + // --- [ glXCreateGLXPixmap ] --- + + /** Unsafe version of: {@link #glXCreateGLXPixmap CreateGLXPixmap} */ + public static long nglXCreateGLXPixmap(long display, long visual, long pixmap) { + long __functionAddress = Functions.CreateGLXPixmap; + if (CHECKS) { + check(display); + XVisualInfo.validate(visual); + } + return callPPNP(display, visual, pixmap, __functionAddress); + } + + /** + * Creates a GLXPixmap from a Pixmap. + * + * @param display the connection to the X server + * @param visual a pointer to a {@link XVisualInfo} structure + * @param pixmap the Pixmap + */ + @NativeType("GLXPixmap") + public static long glXCreateGLXPixmap(@NativeType("Display *") long display, @NativeType("XVisualInfo *") XVisualInfo visual, @NativeType("Pixmap") long pixmap) { + return nglXCreateGLXPixmap(display, visual.address(), pixmap); + } + + // --- [ glXDestroyGLXPixmap ] --- + + /** + * Destroys a GLXPixmap. + * + * @param display the connection to the X server + * @param pixmap the GLXPixmap to destroy. + */ + public static void glXDestroyGLXPixmap(@NativeType("Display *") long display, @NativeType("GLXPixmap") long pixmap) { + long __functionAddress = Functions.DestroyGLXPixmap; + if (CHECKS) { + check(display); + check(pixmap); + } + callPPV(display, pixmap, __functionAddress); + } + + /** Array version of: {@link #glXQueryExtension QueryExtension} */ + @NativeType("Bool") + public static boolean glXQueryExtension(@NativeType("Display *") long display, @NativeType("int *") int[] error_base, @NativeType("int *") int[] event_base) { + long __functionAddress = Functions.QueryExtension; + if (CHECKS) { + check(display); + check(error_base, 1); + check(event_base, 1); + } + return callPPPI(display, error_base, event_base, __functionAddress) != 0; + } + + /** Array version of: {@link #glXQueryVersion QueryVersion} */ + @NativeType("Bool") + public static boolean glXQueryVersion(@NativeType("Display *") long display, @NativeType("int *") int[] major, @NativeType("int *") int[] minor) { + long __functionAddress = Functions.QueryVersion; + if (CHECKS) { + check(display); + check(major, 1); + check(minor, 1); + } + return callPPPI(display, major, minor, __functionAddress) != 0; + } + + /** Array version of: {@link #glXGetConfig GetConfig} */ + public static int glXGetConfig(@NativeType("Display *") long display, @NativeType("XVisualInfo *") XVisualInfo visual, int attribute, @NativeType("int *") int[] value) { + long __functionAddress = Functions.GetConfig; + if (CHECKS) { + check(display); + check(value, 1); + XVisualInfo.validate(visual.address()); + } + return callPPPI(display, visual.address(), attribute, value, __functionAddress); + } + + /** Array version of: {@link #glXChooseVisual ChooseVisual} */ + @Nullable + @NativeType("XVisualInfo *") + public static XVisualInfo glXChooseVisual(@NativeType("Display *") long display, int screen, @Nullable @NativeType("int *") int[] attrib_list) { + long __functionAddress = Functions.ChooseVisual; + if (CHECKS) { + check(display); + checkNTSafe(attrib_list); + } + long __result = callPPP(display, screen, attrib_list, __functionAddress); + return XVisualInfo.createSafe(__result); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLX11.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLX11.java new file mode 100644 index 00000000..db0297d5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLX11.java @@ -0,0 +1,111 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** Native bindings to GLX 1.1. */ +public class GLX11 extends GLX { + + /** Names for attributes to {@link #glXGetClientString GetClientString}. */ + public static final int + GLX_VENDOR = 0x1, + GLX_VERSION = 0x2, + GLX_EXTENSIONS = 0x3; + + protected GLX11() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXQueryExtensionsString, caps.glXGetClientString, caps.glXQueryServerString + ); + } + + // --- [ glXQueryExtensionsString ] --- + + /** Unsafe version of: {@link #glXQueryExtensionsString QueryExtensionsString} */ + public static long nglXQueryExtensionsString(long display, int screen) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryExtensionsString; + if (CHECKS) { + check(__functionAddress); + check(display); + } + return callPP(display, screen, __functionAddress); + } + + /** + * Returns a string describing which GLX extensions are supported on the connection. + * + * @param display the connection to the X server + * @param screen the screen number + */ + @Nullable + @NativeType("char const *") + public static String glXQueryExtensionsString(@NativeType("Display *") long display, int screen) { + long __result = nglXQueryExtensionsString(display, screen); + return memASCIISafe(__result); + } + + // --- [ glXGetClientString ] --- + + /** Unsafe version of: {@link #glXGetClientString GetClientString} */ + public static long nglXGetClientString(long display, int name) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetClientString; + if (CHECKS) { + check(__functionAddress); + check(display); + } + return callPP(display, name, __functionAddress); + } + + /** + * Returns a pointer to a string describing some aspect of the client library. + * + * @param display the connection to the X server + * @param name the string to query + */ + @Nullable + @NativeType("char const *") + public static String glXGetClientString(@NativeType("Display *") long display, int name) { + long __result = nglXGetClientString(display, name); + return memASCIISafe(__result); + } + + // --- [ glXQueryServerString ] --- + + /** Unsafe version of: {@link #glXQueryServerString QueryServerString} */ + public static long nglXQueryServerString(long display, int screen, int name) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryServerString; + if (CHECKS) { + check(__functionAddress); + check(display); + } + return callPP(display, screen, name, __functionAddress); + } + + /** + * Returns a pointer to a string describing some aspect of the server's GLX extension. + * + * @param display the connection to the X server + * @param screen the screen number + * @param name the string to query + */ + @Nullable + @NativeType("char const *") + public static String glXQueryServerString(@NativeType("Display *") long display, int screen, int name) { + long __result = nglXQueryServerString(display, screen, name); + return memASCIISafe(__result); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLX12.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLX12.java new file mode 100644 index 00000000..8e3ea5f0 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLX12.java @@ -0,0 +1,38 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** Native bindings to GLX 1.2. */ +public class GLX12 extends GLX11 { + + protected GLX12() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXGetCurrentDisplay + ); + } + + // --- [ glXGetCurrentDisplay ] --- + + /** Returns the display associated with the current context and drawable. */ + @NativeType("Display *") + public static long glXGetCurrentDisplay() { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetCurrentDisplay; + if (CHECKS) { + check(__functionAddress); + } + return callP(__functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLX13.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLX13.java new file mode 100644 index 00000000..b1ef4c1c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLX13.java @@ -0,0 +1,617 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +import org.lwjgl.system.linux.*; + +/** Native bindings to GLX 1.3. */ +public class GLX13 extends GLX12 { + + /** Added in GLX 1.3. */ + public static final int + GLX_WINDOW_BIT = 0x1, + GLX_PIXMAP_BIT = 0x2, + GLX_PBUFFER_BIT = 0x4, + GLX_RGBA_BIT = 0x1, + GLX_COLOR_INDEX_BIT = 0x2, + GLX_PBUFFER_CLOBBER_MASK = 0x8000000, + GLX_FRONT_LEFT_BUFFER_BIT = 0x1, + GLX_FRONT_RIGHT_BUFFER_BIT = 0x2, + GLX_BACK_LEFT_BUFFER_BIT = 0x4, + GLX_BACK_RIGHT_BUFFER_BIT = 0x8, + GLX_AUX_BUFFERS_BIT = 0x10, + GLX_DEPTH_BUFFER_BIT = 0x20, + GLX_STENCIL_BUFFER_BIT = 0x40, + GLX_ACCUM_BUFFER_BIT = 0x80, + GLX_CONFIG_CAVEAT = 0x20, + GLX_X_VISUAL_TYPE = 0x22, + GLX_TRANSPARENT_TYPE = 0x23, + GLX_TRANSPARENT_INDEX_VALUE = 0x24, + GLX_TRANSPARENT_RED_VALUE = 0x25, + GLX_TRANSPARENT_GREEN_VALUE = 0x26, + GLX_TRANSPARENT_BLUE_VALUE = 0x27, + GLX_TRANSPARENT_ALPHA_VALUE = 0x28, + GLX_DONT_CARE = 0xFFFFFFFF, + GLX_NONE = 0x8000, + GLX_SLOW_CONFIG = 0x8001, + GLX_TRUE_COLOR = 0x8002, + GLX_DIRECT_COLOR = 0x8003, + GLX_PSEUDO_COLOR = 0x8004, + GLX_STATIC_COLOR = 0x8005, + GLX_GRAY_SCALE = 0x8006, + GLX_STATIC_GRAY = 0x8007, + GLX_TRANSPARENT_RGB = 0x8008, + GLX_TRANSPARENT_INDEX = 0x8009, + GLX_VISUAL_ID = 0x800B, + GLX_SCREEN = 0x800C, + GLX_NON_CONFORMANT_CONFIG = 0x800D, + GLX_DRAWABLE_TYPE = 0x8010, + GLX_RENDER_TYPE = 0x8011, + GLX_X_RENDERABLE = 0x8012, + GLX_FBCONFIG_ID = 0x8013, + GLX_RGBA_TYPE = 0x8014, + GLX_COLOR_INDEX_TYPE = 0x8015, + GLX_MAX_PBUFFER_WIDTH = 0x8016, + GLX_MAX_PBUFFER_HEIGHT = 0x8017, + GLX_MAX_PBUFFER_PIXELS = 0x8018, + GLX_PRESERVED_CONTENTS = 0x801B, + GLX_LARGEST_PBUFFER = 0x801C, + GLX_WIDTH = 0x801D, + GLX_HEIGHT = 0x801E, + GLX_EVENT_MASK = 0x801F, + GLX_DAMAGED = 0x8020, + GLX_SAVED = 0x8021, + GLX_WINDOW = 0x8022, + GLX_PBUFFER = 0x8023, + GLX_PBUFFER_HEIGHT = 0x8040, + GLX_PBUFFER_WIDTH = 0x8041; + + protected GLX13() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXGetFBConfigs, caps.glXChooseFBConfig, caps.glXGetFBConfigAttrib, caps.glXGetVisualFromFBConfig, caps.glXCreateWindow, caps.glXCreatePixmap, + caps.glXDestroyPixmap, caps.glXCreatePbuffer, caps.glXDestroyPbuffer, caps.glXQueryDrawable, caps.glXCreateNewContext, caps.glXMakeContextCurrent, + caps.glXGetCurrentReadDrawable, caps.glXQueryContext, caps.glXSelectEvent, caps.glXGetSelectedEvent + ); + } + + // --- [ glXGetFBConfigs ] --- + + /** + * Unsafe version of: {@link #glXGetFBConfigs GetFBConfigs} + * + * @param nelements returns the number of GLXFBConfigs in the returned list + */ + public static long nglXGetFBConfigs(long display, int screen, long nelements) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetFBConfigs; + if (CHECKS) { + check(__functionAddress); + check(display); + } + return callPPP(display, screen, nelements, __functionAddress); + } + + /** + * Returns the list of all GLXFBConfigs that are available on the specified screen. + * + * @param display the connection to the X server + * @param screen the screen number + */ + @Nullable + @NativeType("GLXFBConfig *") + public static PointerBuffer glXGetFBConfigs(@NativeType("Display *") long display, int screen) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + IntBuffer nelements = stack.callocInt(1); + try { + long __result = nglXGetFBConfigs(display, screen, memAddress(nelements)); + return memPointerBufferSafe(__result, nelements.get(0)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glXChooseFBConfig ] --- + + /** + * Unsafe version of: {@link #glXChooseFBConfig ChooseFBConfig} + * + * @param nelements returns the number of GLXFBConfigs matched + */ + public static long nglXChooseFBConfig(long display, int screen, long attrib_list, long nelements) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXChooseFBConfig; + if (CHECKS) { + check(__functionAddress); + check(display); + } + return callPPPP(display, screen, attrib_list, nelements, __functionAddress); + } + + /** + * Returns a list of GLXFBConfigs that match a list of attributes. + * + * @param display the connection to the X server + * @param screen the screen number + * @param attrib_list a list of attributes terminated with {@code None} + */ + @Nullable + @NativeType("GLXFBConfig *") + public static PointerBuffer glXChooseFBConfig(@NativeType("Display *") long display, int screen, @Nullable @NativeType("int const *") IntBuffer attrib_list) { + if (CHECKS) { + checkNTSafe(attrib_list); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + IntBuffer nelements = stack.callocInt(1); + try { + long __result = nglXChooseFBConfig(display, screen, memAddressSafe(attrib_list), memAddress(nelements)); + return memPointerBufferSafe(__result, nelements.get(0)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glXGetFBConfigAttrib ] --- + + /** Unsafe version of: {@link #glXGetFBConfigAttrib GetFBConfigAttrib} */ + public static int nglXGetFBConfigAttrib(long display, long config, int attribute, long value) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetFBConfigAttrib; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + } + return callPPPI(display, config, attribute, value, __functionAddress); + } + + /** + * Queries the value of a GLX attribute for a GLXFBConfig. + * + * @param display the connection to the X server + * @param config the GLXFBConfig being queried + * @param attribute the attribute to query + * @param value the attribute value + */ + public static int glXGetFBConfigAttrib(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config, int attribute, @NativeType("int *") IntBuffer value) { + if (CHECKS) { + check(value, 1); + } + return nglXGetFBConfigAttrib(display, config, attribute, memAddress(value)); + } + + // --- [ glXGetVisualFromFBConfig ] --- + + /** Unsafe version of: {@link #glXGetVisualFromFBConfig GetVisualFromFBConfig} */ + public static long nglXGetVisualFromFBConfig(long display, long config) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetVisualFromFBConfig; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + } + return callPPP(display, config, __functionAddress); + } + + /** + * Retrieves the associated visual of a GLXFBConfig. + * + * @param display the connection to the X server + * @param config the GLXFBConfig + */ + @Nullable + @NativeType("XVisualInfo *") + public static XVisualInfo glXGetVisualFromFBConfig(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config) { + long __result = nglXGetVisualFromFBConfig(display, config); + return XVisualInfo.createSafe(__result); + } + + // --- [ glXCreateWindow ] --- + + /** Unsafe version of: {@link #glXCreateWindow CreateWindow} */ + public static long nglXCreateWindow(long display, long config, long win, long attrib_list) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCreateWindow; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + } + return callPPNPP(display, config, win, attrib_list, __functionAddress); + } + + /** + * Create an onscreen rendering area from an X Window and a desired GLXFBConfig. + * + * @param display the connection to the X server + * @param config the GLXFBConfig + * @param win the X Window + * @param attrib_list a list of attributes terminated with {@code None} + */ + @NativeType("GLXWindow") + public static long glXCreateWindow(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config, @NativeType("Window") long win, @Nullable @NativeType("int const *") IntBuffer attrib_list) { + if (CHECKS) { + checkNTSafe(attrib_list); + } + return nglXCreateWindow(display, config, win, memAddressSafe(attrib_list)); + } + + // --- [ glXCreatePixmap ] --- + + /** Unsafe version of: {@link #glXCreatePixmap CreatePixmap} */ + public static long nglXCreatePixmap(long display, long config, long pixmap, long attrib_list) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCreatePixmap; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + } + return callPPNPP(display, config, pixmap, attrib_list, __functionAddress); + } + + /** + * Creates a GLXPixmap offscreen rendering area from an X Pixmap and a desired GLXFBConfig. + * + * @param display the connection to the X server + * @param config the GLXFBConfig + * @param pixmap the X Pixmap + * @param attrib_list a list of attributes terminated with {@code None} + */ + @NativeType("GLXPixmap") + public static long glXCreatePixmap(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config, @NativeType("Pixmap") long pixmap, @Nullable @NativeType("int const *") IntBuffer attrib_list) { + if (CHECKS) { + checkNTSafe(attrib_list); + } + return nglXCreatePixmap(display, config, pixmap, memAddressSafe(attrib_list)); + } + + // --- [ glXDestroyPixmap ] --- + + /** + * Destroys a GLXPixmap. + * + * @param display the connection to the X server + * @param pixmap the GLXPixmap to destroy + */ + public static void glXDestroyPixmap(@NativeType("Display *") long display, @NativeType("GLXPixmap") long pixmap) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXDestroyPixmap; + if (CHECKS) { + check(__functionAddress); + check(display); + check(pixmap); + } + callPPV(display, pixmap, __functionAddress); + } + + // --- [ glXCreatePbuffer ] --- + + /** Unsafe version of: {@link #glXCreatePbuffer CreatePbuffer} */ + public static long nglXCreatePbuffer(long display, long config, long attrib_list) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCreatePbuffer; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + } + return callPPPP(display, config, attrib_list, __functionAddress); + } + + /** + * Creates a GLXPbuffer from a GLXFBConfig. + * + * @param display the connection to the X server + * @param config the GLXFBConfig + * @param attrib_list a list of attributes terminated with {@code None} + */ + @NativeType("GLXPbuffer") + public static long glXCreatePbuffer(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config, @Nullable @NativeType("int const *") IntBuffer attrib_list) { + if (CHECKS) { + checkNTSafe(attrib_list); + } + return nglXCreatePbuffer(display, config, memAddressSafe(attrib_list)); + } + + // --- [ glXDestroyPbuffer ] --- + + /** + * Destroys a GLXPbuffer. + * + * @param display the connection to the X server + * @param pbuf the GLXPbuffer to destroy + */ + public static void glXDestroyPbuffer(@NativeType("Display *") long display, @NativeType("GLXPbuffer") long pbuf) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXDestroyPbuffer; + if (CHECKS) { + check(__functionAddress); + check(display); + check(pbuf); + } + callPPV(display, pbuf, __functionAddress); + } + + // --- [ glXQueryDrawable ] --- + + /** Unsafe version of: {@link #glXQueryDrawable QueryDrawable} */ + public static void nglXQueryDrawable(long display, long draw, int attribute, long value) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryDrawable; + if (CHECKS) { + check(__functionAddress); + check(display); + check(draw); + } + callPPPV(display, draw, attribute, value, __functionAddress); + } + + /** + * Queries an attribute associated with a GLXDrawable. + * + * @param display the connection to the X server + * @param draw the GLXDrawable being queried + * @param attribute the attribute to query + * @param value returns the attribute value + */ + public static void glXQueryDrawable(@NativeType("Display *") long display, @NativeType("GLXDrawable") long draw, int attribute, @NativeType("unsigned int *") IntBuffer value) { + if (CHECKS) { + check(value, 1); + } + nglXQueryDrawable(display, draw, attribute, memAddress(value)); + } + + /** + * Queries an attribute associated with a GLXDrawable. + * + * @param display the connection to the X server + * @param draw the GLXDrawable being queried + * @param attribute the attribute to query + */ + @NativeType("void") + public static int glXQueryDrawable(@NativeType("Display *") long display, @NativeType("GLXDrawable") long draw, int attribute) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer value = stack.callocInt(1); + nglXQueryDrawable(display, draw, attribute, memAddress(value)); + return value.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glXCreateNewContext ] --- + + /** + * Creates an OpenGL rendering context. + * + * @param display the connection to the X server + * @param config the GLXFBConfig + * @param render_type the render type + * @param share_list a GLXContext to share objects with + * @param direct whether direct rendering is requested + */ + @NativeType("GLXContext") + public static long glXCreateNewContext(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config, int render_type, @NativeType("GLXContext") long share_list, @NativeType("Bool") boolean direct) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCreateNewContext; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + } + return callPPPP(display, config, render_type, share_list, direct ? 1 : 0, __functionAddress); + } + + // --- [ glXMakeContextCurrent ] --- + + /** + * Makes a GLXContext current in the current thread. + * + * @param display the connection to the X server + * @param draw the draw GLXDrawable + * @param read the read GLXDrawable + * @param ctx the GLXContext + */ + @NativeType("Bool") + public static boolean glXMakeContextCurrent(@NativeType("Display *") long display, @NativeType("GLXDrawable") long draw, @NativeType("GLXDrawable") long read, @NativeType("GLXContext") long ctx) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXMakeContextCurrent; + if (CHECKS) { + check(__functionAddress); + check(display); + } + return callPPPPI(display, draw, read, ctx, __functionAddress) != 0; + } + + // --- [ glXGetCurrentReadDrawable ] --- + + /** Returns the current GLXDrawable used for reading in the current thread. */ + @NativeType("GLXDrawable") + public static long glXGetCurrentReadDrawable() { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetCurrentReadDrawable; + if (CHECKS) { + check(__functionAddress); + } + return callP(__functionAddress); + } + + // --- [ glXQueryContext ] --- + + /** Unsafe version of: {@link #glXQueryContext QueryContext} */ + public static int nglXQueryContext(long display, long ctx, int attribute, long value) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryContext; + if (CHECKS) { + check(__functionAddress); + check(display); + check(ctx); + } + return callPPPI(display, ctx, attribute, value, __functionAddress); + } + + /** + * Queries the value of a GLXContext attribute. + * + * @param display the connection to the X server + * @param ctx the GLXContext being queried + * @param attribute the attribute to query + * @param value returns the attribute value + */ + public static int glXQueryContext(@NativeType("Display *") long display, @NativeType("GLXContext") long ctx, int attribute, @NativeType("int *") IntBuffer value) { + if (CHECKS) { + check(value, 1); + } + return nglXQueryContext(display, ctx, attribute, memAddress(value)); + } + + // --- [ glXSelectEvent ] --- + + /** + * Selects which GLX events should be received on a GLXDrawable. + * + * @param display the connection to the X server + * @param draw the GLXDrawable + * @param event_mask the selection mask + */ + public static void glXSelectEvent(@NativeType("Display *") long display, @NativeType("GLXDrawable") long draw, @NativeType("unsigned long") long event_mask) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXSelectEvent; + if (CHECKS) { + check(__functionAddress); + check(display); + check(draw); + } + callPPNV(display, draw, event_mask, __functionAddress); + } + + // --- [ glXGetSelectedEvent ] --- + + /** Unsafe version of: {@link #glXGetSelectedEvent GetSelectedEvent} */ + public static void nglXGetSelectedEvent(long display, long draw, long event_mask) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetSelectedEvent; + if (CHECKS) { + check(__functionAddress); + check(display); + check(draw); + } + callPPPV(display, draw, event_mask, __functionAddress); + } + + /** + * Returns which GLX events are selected for a GLXDrawable. + * + * @param display the connection to the X server + * @param draw the GLXDrawable + * @param event_mask returns the selection mask + */ + public static void glXGetSelectedEvent(@NativeType("Display *") long display, @NativeType("GLXDrawable") long draw, @NativeType("unsigned long *") CLongBuffer event_mask) { + if (CHECKS) { + check(event_mask, 1); + } + nglXGetSelectedEvent(display, draw, memAddress(event_mask)); + } + + /** Array version of: {@link #glXChooseFBConfig ChooseFBConfig} */ + @Nullable + @NativeType("GLXFBConfig *") + public static PointerBuffer glXChooseFBConfig(@NativeType("Display *") long display, int screen, @Nullable @NativeType("int const *") int[] attrib_list) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXChooseFBConfig; + if (CHECKS) { + check(__functionAddress); + check(display); + checkNTSafe(attrib_list); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + IntBuffer nelements = stack.callocInt(1); + try { + long __result = callPPPP(display, screen, attrib_list, memAddress(nelements), __functionAddress); + return memPointerBufferSafe(__result, nelements.get(0)); + } finally { + stack.setPointer(stackPointer); + } + } + + /** Array version of: {@link #glXGetFBConfigAttrib GetFBConfigAttrib} */ + public static int glXGetFBConfigAttrib(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config, int attribute, @NativeType("int *") int[] value) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetFBConfigAttrib; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + check(value, 1); + } + return callPPPI(display, config, attribute, value, __functionAddress); + } + + /** Array version of: {@link #glXCreateWindow CreateWindow} */ + @NativeType("GLXWindow") + public static long glXCreateWindow(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config, @NativeType("Window") long win, @Nullable @NativeType("int const *") int[] attrib_list) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCreateWindow; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + checkNTSafe(attrib_list); + } + return callPPNPP(display, config, win, attrib_list, __functionAddress); + } + + /** Array version of: {@link #glXCreatePixmap CreatePixmap} */ + @NativeType("GLXPixmap") + public static long glXCreatePixmap(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config, @NativeType("Pixmap") long pixmap, @Nullable @NativeType("int const *") int[] attrib_list) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCreatePixmap; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + checkNTSafe(attrib_list); + } + return callPPNPP(display, config, pixmap, attrib_list, __functionAddress); + } + + /** Array version of: {@link #glXCreatePbuffer CreatePbuffer} */ + @NativeType("GLXPbuffer") + public static long glXCreatePbuffer(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config, @Nullable @NativeType("int const *") int[] attrib_list) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCreatePbuffer; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + checkNTSafe(attrib_list); + } + return callPPPP(display, config, attrib_list, __functionAddress); + } + + /** Array version of: {@link #glXQueryDrawable QueryDrawable} */ + public static void glXQueryDrawable(@NativeType("Display *") long display, @NativeType("GLXDrawable") long draw, int attribute, @NativeType("unsigned int *") int[] value) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryDrawable; + if (CHECKS) { + check(__functionAddress); + check(display); + check(draw); + check(value, 1); + } + callPPPV(display, draw, attribute, value, __functionAddress); + } + + /** Array version of: {@link #glXQueryContext QueryContext} */ + public static int glXQueryContext(@NativeType("Display *") long display, @NativeType("GLXContext") long ctx, int attribute, @NativeType("int *") int[] value) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryContext; + if (CHECKS) { + check(__functionAddress); + check(display); + check(ctx); + check(value, 1); + } + return callPPPI(display, ctx, attribute, value, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLX14.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLX14.java new file mode 100644 index 00000000..69707939 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLX14.java @@ -0,0 +1,108 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** Native bindings to GLX 1.4. */ +public class GLX14 extends GLX13 { + + /** Added in GLX 1.4. */ + public static final int + GLX_SAMPLE_BUFFERS = 0x186A0, + GLX_SAMPLES = 0x186A1; + + protected GLX14() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXGetProcAddress + ); + } + + // --- [ glXGetProcAddress ] --- + + /** Unsafe version of: {@link #glXGetProcAddress GetProcAddress} */ + public static long nglXGetProcAddress(long procName) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetProcAddress; + if (CHECKS) { + check(__functionAddress); + } + return callPP(procName, __functionAddress); + } + + /** + * Returns the address of the extension function named by {@code procName}. The pointer returned should be cast to a function pointer type matching the + * extension function's definition in that extension specification. A return value of {@code NULL} indicates that the specified function does not exist for the + * implementation. + * + *A non-{@code NULL} return value for {@code glXGetProcAddress} does not guarantee that an extension function is actually supported at runtime. The client must + * also query {@link GL11C#glGetString GetString}({@link GL11#GL_EXTENSIONS}) or {@link GLX11#glXQueryExtensionsString QueryExtensionsString} to determine if an extension is supported by a particular context.
+ * + *GL function pointers returned by {@code glXGetProcAddress} are independent of the currently bound context and may be used by any context which supports + * the extension.
+ * + *{@code glXGetProcAddress} may be queried for all of the following functions:
+ * + *A non-{@code NULL} return value for {@code glXGetProcAddress} does not guarantee that an extension function is actually supported at runtime. The client must + * also query {@link GL11C#glGetString GetString}({@link GL11#GL_EXTENSIONS}) or {@link GLX11#glXQueryExtensionsString QueryExtensionsString} to determine if an extension is supported by a particular context.
+ * + *GL function pointers returned by {@code glXGetProcAddress} are independent of the currently bound context and may be used by any context which supports + * the extension.
+ * + *{@code glXGetProcAddress} may be queried for all of the following functions:
+ * + *There currently is no way for applications to efficiently use GPU resources in systems that contain more than one GPU. Vendors have provided methods + * that attempt to split the workload for an application among the available GPU resources. This has proven to be very inefficient because most + * applications were never written with these sorts of optimizations in mind.
+ * + *This extension provides a mechanism for applications to explicitly use the GPU resources on a given system individually. By providing this + * functionality, a driver allows applications to make appropriate decisions regarding where and when to distribute rendering tasks.
+ * + *Requires {@link GL15 OpenGL 1.5}, {@link GLX13 GLX 1.3}, {@link EXTFramebufferObject EXT_framebuffer_object} and {@link GLXARBGetProcAddress GLX_ARB_get_proc_address}.
+ */ +public class GLXAMDGPUAssociation { + + /** Accepted by the {@code property} parameter of {@link #glXGetGPUInfoAMD GetGPUInfoAMD}. */ + public static final int + GLX_GPU_VENDOR_AMD = 0x1F00, + GLX_GPU_RENDERER_STRING_AMD = 0x1F01, + GLX_GPU_OPENGL_VERSION_STRING_AMD = 0x1F02, + GLX_GPU_FASTEST_TARGET_GPUS_AMD = 0x21A2, + GLX_GPU_RAM_AMD = 0x21A3, + GLX_GPU_CLOCK_AMD = 0x21A4, + GLX_GPU_NUM_PIPES_AMD = 0x21A5, + GLX_GPU_NUM_SIMD_AMD = 0x21A6, + GLX_GPU_NUM_RB_AMD = 0x21A7, + GLX_GPU_NUM_SPI_AMD = 0x21A8; + + protected GLXAMDGPUAssociation() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXBlitContextFramebufferAMD, caps.glXCreateAssociatedContextAMD, caps.glXCreateAssociatedContextAttribsAMD, + caps.glXDeleteAssociatedContextAMD, caps.glXGetContextGPUIDAMD, caps.glXGetCurrentAssociatedContextAMD, caps.glXGetGPUIDsAMD, caps.glXGetGPUInfoAMD, + caps.glXMakeAssociatedContextCurrentAMD + ); + } + + // --- [ glXBlitContextFramebufferAMD ] --- + + public static void glXBlitContextFramebufferAMD(@NativeType("GLXContext") long dstCtx, @NativeType("GLint") int srcX0, @NativeType("GLint") int srcY0, @NativeType("GLint") int srcX1, @NativeType("GLint") int srcY1, @NativeType("GLint") int dstX0, @NativeType("GLint") int dstY0, @NativeType("GLint") int dstX1, @NativeType("GLint") int dstY1, @NativeType("GLbitfield") int mask, @NativeType("GLenum") int filter) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXBlitContextFramebufferAMD; + if (CHECKS) { + check(__functionAddress); + check(dstCtx); + } + callPV(dstCtx, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter, __functionAddress); + } + + // --- [ glXCreateAssociatedContextAMD ] --- + + /** Creates an associated context. */ + @NativeType("GLXContext") + public static long glXCreateAssociatedContextAMD(@NativeType("unsigned int") int id, @NativeType("GLXContext") long share_list) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCreateAssociatedContextAMD; + if (CHECKS) { + check(__functionAddress); + check(share_list); + } + return callPP(id, share_list, __functionAddress); + } + + // --- [ glXCreateAssociatedContextAttribsAMD ] --- + + /** Unsafe version of: {@link #glXCreateAssociatedContextAttribsAMD CreateAssociatedContextAttribsAMD} */ + public static long nglXCreateAssociatedContextAttribsAMD(int id, long share_context, long attribList) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCreateAssociatedContextAttribsAMD; + if (CHECKS) { + check(__functionAddress); + check(share_context); + } + return callPPP(id, share_context, attribList, __functionAddress); + } + + /** Creates an associated context and requests a specific GL version. */ + @NativeType("GLXContext") + public static long glXCreateAssociatedContextAttribsAMD(@NativeType("unsigned int") int id, @NativeType("GLXContext") long share_context, @NativeType("int const *") IntBuffer attribList) { + if (CHECKS) { + checkNT(attribList); + } + return nglXCreateAssociatedContextAttribsAMD(id, share_context, memAddress(attribList)); + } + + // --- [ glXDeleteAssociatedContextAMD ] --- + + /** + * Deletes an associated context. + * + * @param ctx the GLXContext + */ + @NativeType("Bool") + public static boolean glXDeleteAssociatedContextAMD(@NativeType("GLXContext") long ctx) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXDeleteAssociatedContextAMD; + if (CHECKS) { + check(__functionAddress); + check(ctx); + } + return callPI(ctx, __functionAddress) != 0; + } + + // --- [ glXGetContextGPUIDAMD ] --- + + /** + * Determines which GPU a context is attached to. + * + * @param ctx the GLXContext + */ + @NativeType("unsigned int") + public static int glXGetContextGPUIDAMD(@NativeType("GLXContext") long ctx) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetContextGPUIDAMD; + if (CHECKS) { + check(__functionAddress); + check(ctx); + } + return callPI(ctx, __functionAddress); + } + + // --- [ glXGetCurrentAssociatedContextAMD ] --- + + /** Queries the crrent associated context. */ + @NativeType("GLXContext") + public static long glXGetCurrentAssociatedContextAMD() { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetCurrentAssociatedContextAMD; + if (CHECKS) { + check(__functionAddress); + } + return callP(__functionAddress); + } + + // --- [ glXGetGPUIDsAMD ] --- + + /** Queries the IDs for available GPUs. */ + @NativeType("unsigned int") + public static int glXGetGPUIDsAMD(@NativeType("unsigned int") int maxCount, @NativeType("unsigned int") int ids) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetGPUIDsAMD; + if (CHECKS) { + check(__functionAddress); + } + return callI(maxCount, ids, __functionAddress); + } + + // --- [ glXGetGPUInfoAMD ] --- + + /** Unsafe version of: {@link #glXGetGPUInfoAMD GetGPUInfoAMD} */ + public static int nglXGetGPUInfoAMD(int id, int property, int dataType, int size, long data) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetGPUInfoAMD; + if (CHECKS) { + check(__functionAddress); + } + return callPI(id, property, dataType, size, data, __functionAddress); + } + + /** + * Queries GPU properties. + * + * @param property one of:| {@link #GLX_GPU_VENDOR_AMD GPU_VENDOR_AMD} | {@link #GLX_GPU_RENDERER_STRING_AMD GPU_RENDERER_STRING_AMD} | {@link #GLX_GPU_OPENGL_VERSION_STRING_AMD GPU_OPENGL_VERSION_STRING_AMD} | {@link #GLX_GPU_FASTEST_TARGET_GPUS_AMD GPU_FASTEST_TARGET_GPUS_AMD} |
| {@link #GLX_GPU_RAM_AMD GPU_RAM_AMD} | {@link #GLX_GPU_CLOCK_AMD GPU_CLOCK_AMD} | {@link #GLX_GPU_NUM_PIPES_AMD GPU_NUM_PIPES_AMD} | {@link #GLX_GPU_NUM_SIMD_AMD GPU_NUM_SIMD_AMD} |
| {@link #GLX_GPU_NUM_RB_AMD GPU_NUM_RB_AMD} | {@link #GLX_GPU_NUM_SPI_AMD GPU_NUM_SPI_AMD} |
The GLX version of {@link KHRContextFlushControl}. This extension adds new context creation parameters the allow an application to specify the behavior + * that is desired when a context is made non-current, and specifically to opt out of the implicit flush behavior.
+ */ +public final class GLXARBContextFlushControl { + + /** Accepted as an attribute name in the {@code *attrib_list} argument to {@link GLXARBCreateContext#glXCreateContextAttribsARB CreateContextAttribsARB}. */ + public static final int GLX_CONTEXT_RELEASE_BEHAVIOR_ARB = 0x2097; + + /** + * Accepted as an attribute value for {@link #GLX_CONTEXT_RELEASE_BEHAVIOR_ARB CONTEXT_RELEASE_BEHAVIOR_ARB} in the {@code *attrib_list} argument to + * {@link GLXARBCreateContext#glXCreateContextAttribsARB CreateContextAttribsARB}. + */ + public static final int + GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB = 0x0, + GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB = 0x2098; + + private GLXARBContextFlushControl() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBCreateContext.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBCreateContext.java new file mode 100644 index 00000000..5bbdf8f6 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBCreateContext.java @@ -0,0 +1,113 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the GLX_ARB_create_context extension. + * + *With the advent of new versions of OpenGL which deprecate features and/or break backward compatibility with older versions, there is a need and desire + * to indicate at context creation which interface will be used. These extensions add a new context creation routine with attributes specifying the GL + * version and context properties requested for the context, and additionally add an attribute specifying the GL profile requested for a context of OpenGL + * 3.2 or later. It also allows making an OpenGL 3.0 or later context current without providing a default framebuffer.
+ * + *Requires {@link GLX14 GLX 1.4}.
+ */ +public class GLXARBCreateContext { + + /** Accepted as an attribute name in {@code attrib_list}. */ + public static final int + GLX_CONTEXT_MAJOR_VERSION_ARB = 0x2091, + GLX_CONTEXT_MINOR_VERSION_ARB = 0x2092, + GLX_CONTEXT_FLAGS_ARB = 0x2094; + + /** Accepted as bits in the attribute value for {@link #GLX_CONTEXT_FLAGS_ARB CONTEXT_FLAGS_ARB} in {@code attrib_list}. */ + public static final int + GLX_CONTEXT_DEBUG_BIT_ARB = 0x1, + GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = 0x2; + + protected GLXARBCreateContext() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXCreateContextAttribsARB + ); + } + + // --- [ glXCreateContextAttribsARB ] --- + + /** Unsafe version of: {@link #glXCreateContextAttribsARB CreateContextAttribsARB} */ + public static long nglXCreateContextAttribsARB(long display, long config, long share_context, int direct, long attrib_list) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCreateContextAttribsARB; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + } + return callPPPPP(display, config, share_context, direct, attrib_list, __functionAddress); + } + + /** + * Creates an OpenGL rendering context. + * + *If {@code glXCreateContextAttribsARB} succeeds, it initializes the context to the initial state defined by the OpenGL specification, and returns a + * handle to it. This handle can be used to render to any GLX surface (window, pixmap, or pbuffer) compatible with {@code config}, subject to constraints + * imposed by the OpenGL API version of the context.
+ * + *If {@code share_context} is not {@code NULL}, then all shareable data (excluding OpenGL texture objects named 0) will be shared by {@code share_context}, all + * other contexts {@code share_context} already shares with, and the newly created context. An arbitrary number of {@code GLXContexts} can share data in + * this fashion. The server context state for all sharing contexts must exist in a single address space.
+ * + * @param display the connection to the X server + * @param config the {@code GLXFBConfig} + * @param share_context if not {@code NULL}, then all shareable data (excluding OpenGL texture objects named 0) will be shared by {@code share_context}, all other contexts + * {@code share_context} already shares with, and the newly created context. An arbitrary number of GLXContexts can share data in this fashion. The + * server context state for all sharing contexts must exist in a single address space. + * @param direct direct rendering is requested if {@code direct} is {@code True}, and indirect rendering if {@code direct} is {@code False}. If + * {@code direct} is {@code True}, the implementation may nonetheless create an indirect rendering context if any of the following conditions hold: + * + *Use {@link GLX#glXIsDirect IsDirect} to determine whether or not a request for a direct rendering context succeeded.
+ * @param attrib_list an optional list of attributes for the context, terminated with {@code None} + */ + @NativeType("GLXContext") + public static long glXCreateContextAttribsARB(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config, @NativeType("GLXContext") long share_context, @NativeType("Bool") boolean direct, @Nullable @NativeType("int const *") IntBuffer attrib_list) { + if (CHECKS) { + checkNTSafe(attrib_list); + } + return nglXCreateContextAttribsARB(display, config, share_context, direct ? 1 : 0, memAddressSafe(attrib_list)); + } + + /** Array version of: {@link #glXCreateContextAttribsARB CreateContextAttribsARB} */ + @NativeType("GLXContext") + public static long glXCreateContextAttribsARB(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config, @NativeType("GLXContext") long share_context, @NativeType("Bool") boolean direct, @Nullable @NativeType("int const *") int[] attrib_list) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCreateContextAttribsARB; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + checkNTSafe(attrib_list); + } + return callPPPPP(display, config, share_context, direct ? 1 : 0, attrib_list, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBCreateContextNoError.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBCreateContextNoError.java new file mode 100644 index 00000000..8b7af629 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBCreateContextNoError.java @@ -0,0 +1,23 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_ARB_create_context_no_error extension. + * + *This extension allows the creation of an OpenGL or OpenGL ES context that doesn't generate errors if the context supports a no error mode. The + * implications of this feature are discussed in the {@link KHRNoError KHR_no_error} extension.
+ * + *Requires {@link WGLARBCreateContext WGL_ARB_create_context}.
+ */ +public final class GLXARBCreateContextNoError { + + /** Accepted as an attribute name in the {@code *attrib_list} argument to {@link GLXARBCreateContext#glXCreateContextAttribsARB CreateContextAttribsARB}. */ + public static final int GLX_CONTEXT_OPENGL_NO_ERROR_ARB = 0x31B3; + + private GLXARBCreateContextNoError() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBCreateContextProfile.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBCreateContextProfile.java new file mode 100644 index 00000000..c9917369 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBCreateContextProfile.java @@ -0,0 +1,30 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_ARB_create_context_profile extension. + * + *Adds an attribute to {@link GLXARBCreateContext}, specifying the GL profile requested for a context of OpenGL 3.2 or later.
+ * + *Requires {@link GLX14 GLX 1.4} and {@link GL32 OpenGL 3.2}.
+ */ +public final class GLXARBCreateContextProfile { + + /** Accepted as an attribute name in {@code attrib_list}. */ + public static final int GLX_CONTEXT_PROFILE_MASK_ARB = 0x9126; + + /** Accepted as bits in the attribute value for {@link #GLX_CONTEXT_PROFILE_MASK_ARB CONTEXT_PROFILE_MASK_ARB} in {@code attrib_list}. */ + public static final int + GLX_CONTEXT_CORE_PROFILE_BIT_ARB = 0x1, + GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = 0x2; + + /** GLX error. */ + public static final int GLXBadProfileARB = 13; + + private GLXARBCreateContextProfile() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBCreateContextRobustness.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBCreateContextRobustness.java new file mode 100644 index 00000000..4d4a225e --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBCreateContextRobustness.java @@ -0,0 +1,36 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_ARB_create_context_robustness extension. + * + *This extension allows creating an OpenGL context supporting robust buffer access behavior and a specified graphics reset notification behavior.
+ * + *Requires {@link GLX14 GLX 1.4}, {@link GLXARBCreateContext GLX_ARB_create_context} and {@link ARBRobustness ARB_robustness}.
+ */ +public final class GLXARBCreateContextRobustness { + + /** + * Accepted as a bit in the attribute value for {@link GLXARBCreateContext#GLX_CONTEXT_FLAGS_ARB CONTEXT_FLAGS_ARB} in the {@code attrib_list} argument to + * {@link GLXARBCreateContext#glXCreateContextAttribsARB CreateContextAttribsARB}. + */ + public static final int GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB = 0x4; + + /** Accepted as an attribute name in the {@code attrib_list} argument to {@link GLXARBCreateContext#glXCreateContextAttribsARB CreateContextAttribsARB}. */ + public static final int GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = 0x8256; + + /** + * Accepted as an attribute value for {@link #GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB} in the {@code attrib_list} argument to + * {@link GLXARBCreateContext#glXCreateContextAttribsARB CreateContextAttribsARB}. + */ + public static final int + GLX_NO_RESET_NOTIFICATION_ARB = 0x8261, + GLX_LOSE_CONTEXT_ON_RESET_ARB = 0x8252; + + private GLXARBCreateContextRobustness() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBFBConfigFloat.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBFBConfigFloat.java new file mode 100644 index 00000000..059cfbbf --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBFBConfigFloat.java @@ -0,0 +1,26 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_ARB_fbconfig_float extension. + * + *The standard OpenGL pipeline is based on a fixed-point pipeline. While color components are nominally floating-point values in the pipeline, components + * are frequently clamped to the range [0,1] to accomodate the fixed-point color buffer representation and allow for fixed-point computational hardware.
+ * + *This extension adds pixel formats or visuals with floating-point RGBA color components and controls for clamping of color components within the pipeline.
+ */ +public final class GLXARBFBConfigFloat { + + /** Accepted as values of the {@code render_type} arguments in the {@link GLX13#glXCreateNewContext CreateNewContext} and {@link GLX#glXCreateContext CreateContext} functions. */ + public static final int GLX_RGBA_FLOAT_TYPE_ARB = 0x20B9; + + /** Accepted as a bit set in the GLX_RENDER_TYPE variable. */ + public static final int GLX_RGBA_FLOAT_BIT_ARB = 0x4; + + private GLXARBFBConfigFloat() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBFramebufferSRGB.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBFramebufferSRGB.java new file mode 100644 index 00000000..bf68b089 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBFramebufferSRGB.java @@ -0,0 +1,20 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_ARB_framebuffer_sRGB extension. + * + *GLX functionality for {@link ARBFramebufferSRGB ARB_framebuffer_sRGB}.
+ */ +public final class GLXARBFramebufferSRGB { + + /** Accepted by the {@code attribList} parameter of {@link GLX#glXChooseVisual ChooseVisual}, and by the {@code attrib} parameter of {@link GLX#glXGetConfig GetConfig}. */ + public static final int GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB = 0x20B2; + + private GLXARBFramebufferSRGB() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBGetProcAddress.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBGetProcAddress.java new file mode 100644 index 00000000..1b6d2bc9 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBGetProcAddress.java @@ -0,0 +1,111 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the GLX_ARB_get_proc_address extension. + * + *This extension adds a function to return the address of GLX and GL extension functions, given the function name. This is necessary with (for example) + * heterogenous implementations where hardware drivers may implement extension functions not known to the link library; a similar situation on Windows + * implementations resulted in the {@code wglGetProcAddress} function.
+ */ +public class GLXARBGetProcAddress { + + protected GLXARBGetProcAddress() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXGetProcAddressARB + ); + } + + // --- [ glXGetProcAddressARB ] --- + + /** Unsafe version of: {@link #glXGetProcAddressARB GetProcAddressARB} */ + public static long nglXGetProcAddressARB(long procName) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetProcAddressARB; + if (CHECKS) { + check(__functionAddress); + } + return callPP(procName, __functionAddress); + } + + /** + * Returns the address of the extension function named by procName. The pointer returned should be cast to a function pointer type matching the extension + * function's definition in that extension specification. A return value of {@code NULL} indicates that the specified function does not exist for the + * implementation. + * + *A non-{@code NULL} return value for {@code glXGetProcAddressARB} does not guarantee that an extension function is actually supported at runtime. The client + * must must also query {@link GL11C#glGetString GetString}({@link GL11#GL_EXTENSIONS}) or {@link GLX11#glXQueryExtensionsString QueryExtensionsString} to determine if an extension is supported by a particular + * context.
+ * + *GL function pointers returned by {@code glXGetProcAddressARB} are independent of the currently bound context and may be used by any context which + * supports the extension.
+ * + *{@code glXGetProcAddressARB} may be queried for all of the following functions:
+ * + *A non-{@code NULL} return value for {@code glXGetProcAddressARB} does not guarantee that an extension function is actually supported at runtime. The client + * must must also query {@link GL11C#glGetString GetString}({@link GL11#GL_EXTENSIONS}) or {@link GLX11#glXQueryExtensionsString QueryExtensionsString} to determine if an extension is supported by a particular + * context.
+ * + *GL function pointers returned by {@code glXGetProcAddressARB} are independent of the currently bound context and may be used by any context which + * supports the extension.
+ * + *{@code glXGetProcAddressARB} may be queried for all of the following functions:
+ * + *See {@link ARBMultisample} for details.
+ */ +public final class GLXARBMultisample { + + /** Accepted by the {@code attribList} parameter of {@link GLX#glXChooseVisual ChooseVisual}, and by the {@code attrib} parameter of {@link GLX#glXGetConfig GetConfig}. */ + public static final int + GLX_SAMPLE_BUFFERS_ARB = 100000, + GLX_SAMPLES_ARB = 100001; + + private GLXARBMultisample() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBRobustnessApplicationIsolation.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBRobustnessApplicationIsolation.java new file mode 100644 index 00000000..c84833db --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBRobustnessApplicationIsolation.java @@ -0,0 +1,34 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_ARB_robustness_application_isolation extension. + * + *GL_ARB_robustness and GLX_ARB_create_context_robustness allow creating an OpenGL context supporting graphics reset notification behavior. + * GLX_ARB_robustness_application_isolation provides stronger guarantees about the possible side-effects of a graphics reset.
+ * + *If the graphics driver advertises the GLX_ARB_robustness_application_isolation extension string, then the driver guarantees that if a particular + * application causes a graphics reset to occur:
+ * + *Requires {@link GLX14 GLX 1.4} and {@link GLXARBCreateContextRobustness GLX_ARB_create_context_robustness}.
+ */ +public final class GLXARBRobustnessApplicationIsolation { + + /** + * Accepted as a bit in the attribute value for {@link GLXARBCreateContext#GLX_CONTEXT_FLAGS_ARB CONTEXT_FLAGS_ARB} in the {@code attrib_list} argument to + * {@link GLXARBCreateContext#glXCreateContextAttribsARB CreateContextAttribsARB}. + */ + public static final int GLX_CONTEXT_RESET_ISOLATION_BIT_ARB = 0x8; + + private GLXARBRobustnessApplicationIsolation() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBVertexBufferObject.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBVertexBufferObject.java new file mode 100644 index 00000000..ef07c8e7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXARBVertexBufferObject.java @@ -0,0 +1,27 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_ARB_vertex_buffer_object extension. + * + *It is the client's responsibility to convert buffer data to and from the server's byte order. Since only the client knows the correct format of the + * data, and there may be multiple clients with different byte orderings sharing a single buffer object, it is unreasonable to ask the GL to handle buffer + * object byte-swapping. To avoid errors caused by naive clients attempting to use buffer objects without performing the appropriate byte swapping, clients + * must opt in to buffer object support at context creation time using the {@link #GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB} context attrib. If this attribute + * is not specified and the byte ordering of the client and server differ, the VBO extension must not be exposed and the maximum context version that can + * be reported is 1.4.
+ * + *Requires {@link GLXARBCreateContext GLX_ARB_create_context} and {@link ARBVertexBufferObject ARB_vertex_buffer_object}.
+ */ +public final class GLXARBVertexBufferObject { + + /** Accepted as an attribute name in the {@code attrib_list} parameter of {@link GLXARBCreateContext#glXCreateContextAttribsARB CreateContextAttribsARB}. */ + public static final int GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB = 0x2095; + + private GLXARBVertexBufferObject() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXCapabilities.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXCapabilities.java new file mode 100644 index 00000000..e4a990da --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXCapabilities.java @@ -0,0 +1,330 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; +import java.util.Set; + +import static org.lwjgl.system.APIUtil.*; + +/** Defines the GLX capabilities of a connection. */ +public final class GLXCapabilities { + + public final long + glXQueryExtensionsString, + glXGetClientString, + glXQueryServerString, + glXGetCurrentDisplay, + glXGetFBConfigs, + glXChooseFBConfig, + glXGetFBConfigAttrib, + glXGetVisualFromFBConfig, + glXCreateWindow, + glXCreatePixmap, + glXDestroyPixmap, + glXCreatePbuffer, + glXDestroyPbuffer, + glXQueryDrawable, + glXCreateNewContext, + glXMakeContextCurrent, + glXGetCurrentReadDrawable, + glXQueryContext, + glXSelectEvent, + glXGetSelectedEvent, + glXGetProcAddress, + glXBlitContextFramebufferAMD, + glXCreateAssociatedContextAMD, + glXCreateAssociatedContextAttribsAMD, + glXDeleteAssociatedContextAMD, + glXGetContextGPUIDAMD, + glXGetCurrentAssociatedContextAMD, + glXGetGPUIDsAMD, + glXGetGPUInfoAMD, + glXMakeAssociatedContextCurrentAMD, + glXCreateContextAttribsARB, + glXGetProcAddressARB, + glXGetCurrentDisplayEXT, + glXQueryContextInfoEXT, + glXGetContextIDEXT, + glXImportContextEXT, + glXFreeContextEXT, + glXSwapIntervalEXT, + glXBindTexImageEXT, + glXReleaseTexImageEXT, + glXCopyBufferSubDataNV, + glXNamedCopyBufferSubDataNV, + glXCopyImageSubDataNV, + glXDelayBeforeSwapNV, + glXJoinSwapGroupNV, + glXBindSwapBarrierNV, + glXQuerySwapGroupNV, + glXQueryMaxSwapGroupsNV, + glXQueryFrameCountNV, + glXResetFrameCountNV, + glXMakeCurrentReadSGI, + glXGetCurrentReadDrawableSGI, + glXSwapIntervalSGI, + glXGetVideoSyncSGI, + glXWaitVideoSyncSGI, + glXGetFBConfigAttribSGIX, + glXChooseFBConfigSGIX, + glXCreateGLXPixmapWithConfigSGIX, + glXCreateContextWithConfigSGIX, + glXGetVisualFromFBConfigSGIX, + glXGetFBConfigFromVisualSGIX, + glXCreateGLXPbufferSGIX, + glXDestroyGLXPbufferSGIX, + glXQueryGLXPbufferSGIX, + glXSelectEventSGIX, + glXGetSelectedEventSGIX, + glXBindSwapBarrierSGIX, + glXQueryMaxSwapBarriersSGIX, + glXJoinSwapGroupSGIX; + + /** When true, {@link GLX11} is supported. */ + public final boolean GLX11; + /** When true, {@link GLX12} is supported. */ + public final boolean GLX12; + /** When true, {@link GLX13} is supported. */ + public final boolean GLX13; + /** When true, {@link GLX14} is supported. */ + public final boolean GLX14; + /** When true, {@link GLXAMDGPUAssociation} is supported. */ + public final boolean GLX_AMD_gpu_association; + /** When true, {@link GLXARBContextFlushControl} is supported. */ + public final boolean GLX_ARB_context_flush_control; + /** When true, {@link GLXARBCreateContext} is supported. */ + public final boolean GLX_ARB_create_context; + /** When true, {@link GLXARBCreateContextNoError} is supported. */ + public final boolean GLX_ARB_create_context_no_error; + /** When true, {@link GLXARBCreateContextProfile} is supported. */ + public final boolean GLX_ARB_create_context_profile; + /** When true, {@link GLXARBCreateContextRobustness} is supported. */ + public final boolean GLX_ARB_create_context_robustness; + /** When true, {@link GLXARBFBConfigFloat} is supported. */ + public final boolean GLX_ARB_fbconfig_float; + /** When true, {@link GLXARBFramebufferSRGB} is supported. */ + public final boolean GLX_ARB_framebuffer_sRGB; + /** When true, {@link GLXARBGetProcAddress} is supported. */ + public final boolean GLX_ARB_get_proc_address; + /** When true, {@link GLXARBMultisample} is supported. */ + public final boolean GLX_ARB_multisample; + /** When true, {@link GLXARBRobustnessApplicationIsolation} is supported. */ + public final boolean GLX_ARB_robustness_application_isolation; + /** + * When true, the GLX_ARB_robustness_share_group_isolation extension is supported. + * + *GL_ARB_robustness and GLX_ARB_create_context_robustness allow creating an OpenGL context supporting graphics reset notification behavior. + * GLX_ARB_robustness_share_group_isolation provides stronger guarantees about the possible side-effects of a graphics reset.
+ * + *If the graphics driver advertises the GLX_ARB_robustness_share_group_isolation extension string, then the driver guarantees that if a context in a + * particular share group causes a graphics reset to occur:
+ * + *Requires {@link GLX14 GLX 1.4} and {@link GLXARBCreateContextRobustness GLX_ARB_create_context_robustness}.
+ */ + public final boolean GLX_ARB_robustness_share_group_isolation; + /** When true, {@link GLXARBVertexBufferObject} is supported. */ + public final boolean GLX_ARB_vertex_buffer_object; + /** When true, {@link GLXEXTBufferAge} is supported. */ + public final boolean GLX_EXT_buffer_age; + /** When true, {@link GLXEXTContextPriority} is supported. */ + public final boolean GLX_EXT_context_priority; + /** When true, {@link GLXEXTCreateContextES2Profile} is supported. */ + public final boolean GLX_EXT_create_context_es2_profile; + /** When true, {@link GLXEXTCreateContextESProfile} is supported. */ + public final boolean GLX_EXT_create_context_es_profile; + /** When true, {@link GLXEXTFBConfigPackedFloat} is supported. */ + public final boolean GLX_EXT_fbconfig_packed_float; + /** When true, {@link GLXEXTFramebufferSRGB} is supported. */ + public final boolean GLX_EXT_framebuffer_sRGB; + /** When true, {@link GLXEXTImportContext} is supported. */ + public final boolean GLX_EXT_import_context; + /** + * When true, the GLX_EXT_no_config_context extension is supported. + * + *Modern GPUs allow contexts to render to almost any combination of supported color and auxiliary buffer formats. Traditionally GLX context creation is + * done with respect to a GLXFBConfig specifying buffer formats, and constrains contexts to only work with drawables created with a "compatible" config.
+ * + *This extension allows creation of GL & ES contexts without specifying a {@code GLXFBConfig}.
+ */ + public final boolean GLX_EXT_no_config_context; + /** When true, {@link GLXEXTStereoTree} is supported. */ + public final boolean GLX_EXT_stereo_tree; + /** When true, {@link GLXEXTSwapControl} is supported. */ + public final boolean GLX_EXT_swap_control; + /** When true, {@link GLXEXTSwapControlTear} is supported. */ + public final boolean GLX_EXT_swap_control_tear; + /** When true, {@link GLXEXTTextureFromPixmap} is supported. */ + public final boolean GLX_EXT_texture_from_pixmap; + /** When true, {@link GLXEXTVisualInfo} is supported. */ + public final boolean GLX_EXT_visual_info; + /** When true, {@link GLXEXTVisualRating} is supported. */ + public final boolean GLX_EXT_visual_rating; + /** When true, {@link GLXINTELSwapEvent} is supported. */ + public final boolean GLX_INTEL_swap_event; + /** When true, {@link GLXNVCopyBuffer} is supported. */ + public final boolean GLX_NV_copy_buffer; + /** When true, {@link GLXNVCopyImage} is supported. */ + public final boolean GLX_NV_copy_image; + /** When true, {@link GLXNVDelayBeforeSwap} is supported. */ + public final boolean GLX_NV_delay_before_swap; + /** When true, {@link GLXNVFloatBuffer} is supported. */ + public final boolean GLX_NV_float_buffer; + /** When true, {@link GLXNVMultisampleCoverage} is supported. */ + public final boolean GLX_NV_multisample_coverage; + /** When true, {@link GLXNVRobustnessVideoMemoryPurge} is supported. */ + public final boolean GLX_NV_robustness_video_memory_purge; + /** When true, {@link GLXNVSwapGroup} is supported. */ + public final boolean GLX_NV_swap_group; + /** When true, {@link GLXSGIMakeCurrentRead} is supported. */ + public final boolean GLX_SGI_make_current_read; + /** When true, {@link GLXSGISwapControl} is supported. */ + public final boolean GLX_SGI_swap_control; + /** When true, {@link GLXSGIVideoSync} is supported. */ + public final boolean GLX_SGI_video_sync; + /** When true, {@link GLXSGIXFBConfig} is supported. */ + public final boolean GLX_SGIX_fbconfig; + /** When true, {@link GLXSGIXPbuffer} is supported. */ + public final boolean GLX_SGIX_pbuffer; + /** When true, {@link GLXSGIXSwapBarrier} is supported. */ + public final boolean GLX_SGIX_swap_barrier; + /** When true, {@link GLXSGIXSwapGroup} is supported. */ + public final boolean GLX_SGIX_swap_group; + + GLXCapabilities(FunctionProvider provider, SetThe aim of this extension is to expose enough information to applications about how the driver manages the set of front and back buffers associated with + * a given surface to allow applications to re-use the contents of old frames and minimize how much must be redrawn for the next frame.
+ * + *Requires {@link GLX14 GLX 1.4}.
+ */ +public final class GLXEXTBufferAge { + + /** Accepted by {@link GLX13#glXQueryDrawable QueryDrawable}. */ + public static final int GLX_BACK_BUFFER_AGE_EXT = 0x20F4; + + private GLXEXTBufferAge() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTContextPriority.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTContextPriority.java new file mode 100644 index 00000000..a029c93f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTContextPriority.java @@ -0,0 +1,30 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_EXT_context_priority extension. + * + *This extension allows a {@code GLXContext} to be created with a priority hint. It is possible that an implementation will not honour the hint, + * especially if there are constraints on the number of high priority contexts available in the system, or system policy limits access to high priority + * contexts to appropriate system privilege level. A query is provided to find the real priority level assigned to the context after creation.
+ * + *Requires {@link GLXARBCreateContext GLX_ARB_create_context}.
+ */ +public final class GLXEXTContextPriority { + + /** New attributes accepted by the {@code attrib_list} argument of {@link GLXARBCreateContext#glXCreateContextAttribsARB CreateContextAttribsARB}. */ + public static final int GLX_CONTEXT_PRIORITY_LEVEL_EXT = 0x3100; + + /** New attribute values accepted in the {@code attrib_list} argument of {@link GLXARBCreateContext#glXCreateContextAttribsARB CreateContextAttribsARB}. */ + public static final int + GLX_CONTEXT_PRIORITY_HIGH_EXT = 0x3101, + GLX_CONTEXT_PRIORITY_MEDIUM_EXT = 0x3102, + GLX_CONTEXT_PRIORITY_LOW_EXT = 0x3103; + + private GLXEXTContextPriority() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTCreateContextES2Profile.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTCreateContextES2Profile.java new file mode 100644 index 00000000..c345ea0a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTCreateContextES2Profile.java @@ -0,0 +1,22 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_EXT_create_context_es2_profile extension. + * + *This extension allows creating an OpenGL ES context.
+ * + *Requires {@link GLX14 GLX 1.4}, {@link GLXARBCreateContext GLX_ARB_create_context}, {@link GLXARBCreateContextProfile GLX_ARB_create_context_profile} and an OpenGL ES implemenation.
+ */ +public final class GLXEXTCreateContextES2Profile { + + /** Accepted as a bit in the attribute value for {@link GLXARBCreateContextProfile#GLX_CONTEXT_PROFILE_MASK_ARB CONTEXT_PROFILE_MASK_ARB} in {@code attrib_list}. */ + public static final int GLX_CONTEXT_ES2_PROFILE_BIT_EXT = 0x4; + + private GLXEXTCreateContextES2Profile() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTCreateContextESProfile.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTCreateContextESProfile.java new file mode 100644 index 00000000..f277c671 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTCreateContextESProfile.java @@ -0,0 +1,22 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_EXT_create_context_es_profile extension. + * + *This extension allows creating an OpenGL ES context.
+ * + *Requires {@link GLX14 GLX 1.4}, {@link GLXARBCreateContext GLX_ARB_create_context}, {@link GLXARBCreateContextProfile GLX_ARB_create_context_profile} and an OpenGL ES implemenation.
+ */ +public final class GLXEXTCreateContextESProfile { + + /** Accepted as a bit in the attribute value for {@link GLXARBCreateContextProfile#GLX_CONTEXT_PROFILE_MASK_ARB CONTEXT_PROFILE_MASK_ARB} in {@code attrib_list}. */ + public static final int GLX_CONTEXT_ES_PROFILE_BIT_EXT = 0x4; + + private GLXEXTCreateContextESProfile() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTFBConfigPackedFloat.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTFBConfigPackedFloat.java new file mode 100644 index 00000000..cf7df34a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTFBConfigPackedFloat.java @@ -0,0 +1,37 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_EXT_fbconfig_packed_float extension. + * + *This extension adds a new 3-component floating-point texture format that fits within a single 32-bit word. This format stores 5 bits of biased exponent + * per component in the same manner as 16-bit floating-point formats, but rather than 10 mantissa bits, the red, green, and blue components have 6, 6, and + * 5 bits respectively. Each mantissa is assumed to have an implied leading one except in the denorm exponent case. There is no sign bit so only + * non-negative values can be represented. Positive infinity, positive denorms, and positive NaN values are representable. The value of the fourth + * component returned by a texture fetch is always 1.0.
+ * + *This extension also provides support for rendering into an unsigned floating-point rendering format with the assumption that the texture format + * described above could also be advertised as an unsigned floating-point format for rendering.
+ * + *The extension also provides a pixel external format for specifying packed float values directly.
+ * + *Requires {@link GLX13 GLX 1.3}.
+ */ +public final class GLXEXTFBConfigPackedFloat { + + /** Accepted as values of the {@code render_type} arguments in the {@link GLX13#glXCreateNewContext CreateNewContext} and {@link GLX#glXCreateContext CreateContext} functions. */ + public static final int GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = 0x20B1; + + /** + * Returned by {@link GLX13#glXGetFBConfigAttrib GetFBConfigAttrib} (when {@code attribute} is set to GLX_RENDER_TYPE) and accepted by the {@code attrib_list} parameter of + * {@link GLX13#glXChooseFBConfig ChooseFBConfig} (following the GLX_RENDER_TYPE token). + */ + public static final int GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = 0x8; + + private GLXEXTFBConfigPackedFloat() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTFramebufferSRGB.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTFramebufferSRGB.java new file mode 100644 index 00000000..3dc6f71c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTFramebufferSRGB.java @@ -0,0 +1,20 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_EXT_framebuffer_sRGB extension. + * + *GLX functionality for {@link EXTFramebufferSRGB EXT_framebuffer_sRGB}.
+ */ +public final class GLXEXTFramebufferSRGB { + + /** Accepted by the {@code attribList} parameter of glXChooseVisual, and by the {@code attrib} parameter of glXGetConfig. */ + public static final int GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x20B2; + + private GLXEXTFramebufferSRGB() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTImportContext.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTImportContext.java new file mode 100644 index 00000000..2def5b97 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTImportContext.java @@ -0,0 +1,146 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the GLX_EXT_import_context extension. + * + *This extension allows multiple X clients to share an indirect rendering context.
+ * + *Additional convenience procedures to get the current Display* bound to a context as well as other context information are also added.
+ */ +public class GLXEXTImportContext { + + /** Accepted by the {@code attribute} parameter of {@link #glXQueryContextInfoEXT QueryContextInfoEXT}. */ + public static final int + GLX_SHARE_CONTEXT_EXT = 0x800A, + GLX_VISUAL_ID_EXT = 0x800B, + GLX_SCREEN_EXT = 0x800C; + + protected GLXEXTImportContext() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXGetCurrentDisplayEXT, caps.glXQueryContextInfoEXT, caps.glXGetContextIDEXT, caps.glXImportContextEXT, caps.glXFreeContextEXT + ); + } + + // --- [ glXGetCurrentDisplayEXT ] --- + + /** Returns the display associated with the current context. */ + @NativeType("Display *") + public static long glXGetCurrentDisplayEXT() { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetCurrentDisplayEXT; + if (CHECKS) { + check(__functionAddress); + } + return callP(__functionAddress); + } + + // --- [ glXQueryContextInfoEXT ] --- + + /** Unsafe version of: {@link #glXQueryContextInfoEXT QueryContextInfoEXT} */ + public static int nglXQueryContextInfoEXT(long display, long context, int attribute, long value) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryContextInfoEXT; + if (CHECKS) { + check(__functionAddress); + check(display); + check(context); + } + return callPPPI(display, context, attribute, value, __functionAddress); + } + + /** + * Obtains the value of a context's attribute. + * + * @param display the connection to the X server + * @param context the context being queried + * @param attribute the attribute to query + * @param value returns the attribute value + */ + public static int glXQueryContextInfoEXT(@NativeType("Display *") long display, @NativeType("GLXContext") long context, int attribute, @NativeType("int *") IntBuffer value) { + if (CHECKS) { + check(value, 1); + } + return nglXQueryContextInfoEXT(display, context, attribute, memAddress(value)); + } + + // --- [ glXGetContextIDEXT ] --- + + /** + * Returns the XID of a GLXContext. + * + * @param context the context + */ + @NativeType("GLXContextID") + public static long glXGetContextIDEXT(@NativeType("GLXContext const") long context) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetContextIDEXT; + if (CHECKS) { + check(__functionAddress); + check(context); + } + return callPN(context, __functionAddress); + } + + // --- [ glXImportContextEXT ] --- + + /** + * May be used in place of glXCreateContext to share another process's indirect rendering context. + * + * @param display the connection to the X server + * @param contextID the context XID + */ + @NativeType("GLXContext") + public static long glXImportContextEXT(@NativeType("Display *") long display, @NativeType("GLXContextID") long contextID) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXImportContextEXT; + if (CHECKS) { + check(__functionAddress); + check(display); + } + return callPNP(display, contextID, __functionAddress); + } + + // --- [ glXFreeContextEXT ] --- + + /** + * Frees the client-side part of a GLXContext that was created with {@link #glXImportContextEXT ImportContextEXT}. + * + * @param display the connection to the X server + * @param context the context to free + */ + public static void glXFreeContextEXT(@NativeType("Display *") long display, @NativeType("GLXContext") long context) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXFreeContextEXT; + if (CHECKS) { + check(__functionAddress); + check(display); + check(context); + } + callPPV(display, context, __functionAddress); + } + + /** Array version of: {@link #glXQueryContextInfoEXT QueryContextInfoEXT} */ + public static int glXQueryContextInfoEXT(@NativeType("Display *") long display, @NativeType("GLXContext") long context, int attribute, @NativeType("int *") int[] value) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryContextInfoEXT; + if (CHECKS) { + check(__functionAddress); + check(display); + check(context); + check(value, 1); + } + return callPPPI(display, context, attribute, value, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTStereoTree.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTStereoTree.java new file mode 100644 index 00000000..8de6de3e --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTStereoTree.java @@ -0,0 +1,37 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_EXT_stereo_tree extension. + * + *When using stereoscopic rendering with the X composite extension, a stereo-aware GLX composite manager can be used to composite both the left and right + * buffers of a window's backing pixmap to the left and right buffers of the root or composite overlay window to preserve the stereo effect of a + * redirected window or any of its child windows. However, to do this, the composite manager needs a method to determine which windows have both left and + * right buffers available without needing to walk entire window trees or be aware of other clients' GLX drawables.
+ * + *This extension provides a new drawable tree query, which can be used by the composite manager when it begins tracking a window, and an event, which can + * be used to listen for updates to a tracked window. This query and event provide the composite manager with a boolean value representing the stereo + * status of an entire redirected window tree. With this information, the composite manager is able to properly choose between a stereoscopic or + * monoscopic format when creating a GLXPixmap for a given window tree's backing pixmap.
+ */ +public final class GLXEXTStereoTree { + + /** Accepted by the {@code attribute} parameter of glXQueryDrawable and glXQueryGLXPbufferSGIX. */ + public static final int GLX_STEREO_TREE_EXT = 0x20F5; + + /** + * Accepted in the {@code event_mask} parameter of glXSelectEvent and glXSelectEventSGIX, and returned in the {@code event_mask} parameter of + * glXGetSelectedEvent and glXGetSelectedEventSGIX. + */ + public static final int GLX_STEREO_NOTIFY_MASK_EXT = 0x1; + + /** Returned in the {@code evtype} field of XGenericEventCookie events. */ + public static final int GLX_STEREO_NOTIFY_EXT = 0x0; + + private GLXEXTStereoTree() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTSwapControl.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTSwapControl.java new file mode 100644 index 00000000..9e955ec2 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTSwapControl.java @@ -0,0 +1,57 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** + * Native bindings to the GLX_EXT_swap_control extension. + * + *This extension allows an application to specify a minimum periodicity of color buffer swaps, measured in video frame periods, for a particular drawable. + * It also allows an application to query the swap interval and the implementation-dependent maximum swap interval of a drawable.
+ */ +public class GLXEXTSwapControl { + + /** The current swap interval and implementation-dependent max swap interval for a particular drawable. */ + public static final int + GLX_SWAP_INTERVAL_EXT = 0x20F1, + GLX_MAX_SWAP_INTERVAL_EXT = 0x20F2; + + protected GLXEXTSwapControl() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXSwapIntervalEXT + ); + } + + // --- [ glXSwapIntervalEXT ] --- + + /** + * Specifies the minimum number of video frame periods per buffer swap for a particular GLX drawable (e.g. a value of two means that the color buffers will + * be swapped at most every other video frame). The interval takes effect when {@link GLX#glXSwapBuffers SwapBuffers} is first called on the drawable subsequent to the + * {@code glXSwapIntervalEXT} call. + * + * @param display the connection to the X server + * @param drawable the drawable + * @param interval the swap interval + */ + public static void glXSwapIntervalEXT(@NativeType("Display *") long display, @NativeType("GLXDrawable") long drawable, int interval) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXSwapIntervalEXT; + if (CHECKS) { + check(__functionAddress); + check(display); + check(drawable); + } + callPPV(display, drawable, interval, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTSwapControlTear.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTSwapControlTear.java new file mode 100644 index 00000000..b6b83a61 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTSwapControlTear.java @@ -0,0 +1,24 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_EXT_swap_control_tear extension. + * + *This extension extends the existing GLX_EXT_swap_control extension by allowing a negative {@code interval} parameter to + * {@link GLXEXTSwapControl#glXSwapIntervalEXT SwapIntervalEXT}. The negative {@code interval} allows late swaps to occur without synchronization to the video frame. This + * reduces the visual stutter on late frames and reduces the stall on subsequent frames.
+ * + *Requires {@link GLXEXTSwapControl GLX_EXT_swap_control}.
+ */ +public final class GLXEXTSwapControlTear { + + /** Accepted by {@link GLX13#glXQueryDrawable QueryDrawable}. */ + public static final int GLX_LATE_SWAPS_TEAR_EXT = 0x20F3; + + private GLXEXTSwapControlTear() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTTextureFromPixmap.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTTextureFromPixmap.java new file mode 100644 index 00000000..96babf0e --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTTextureFromPixmap.java @@ -0,0 +1,154 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the GLX_EXT_texture_from_pixmap extension. + * + *This extension allows a color buffer to be used for both rendering and texturing.
+ * + *Requires {@link GLX13 GLX 1.3}.
+ */ +public class GLXEXTTextureFromPixmap { + + /** Accepted by the {@code attribute} parameter of {@link GLX13#glXGetFBConfigAttrib GetFBConfigAttrib} and the {@code attrib_list} parameter of {@link GLX13#glXChooseFBConfig ChooseFBConfig}. */ + public static final int + GLX_BIND_TO_TEXTURE_RGB_EXT = 0x20D0, + GLX_BIND_TO_TEXTURE_RGBA_EXT = 0x20D1, + GLX_BIND_TO_MIPMAP_TEXTURE_EXT = 0x20D2, + GLX_BIND_TO_TEXTURE_TARGETS_EXT = 0x20D3, + GLX_Y_INVERTED_EXT = 0x20D4; + + /** Accepted as an attribute in the {@code attrib_list} parameter of {@link GLX13#glXCreatePixmap CreatePixmap}, and by the {@code attribute} parameter of {@link GLX13#glXQueryDrawable QueryDrawable}. */ + public static final int + GLX_TEXTURE_FORMAT_EXT = 0x20D5, + GLX_TEXTURE_TARGET_EXT = 0x20D6, + GLX_MIPMAP_TEXTURE_EXT = 0x20D7; + + /** + * Accepted as a value in the {@code attrib_list} parameter of {@link GLX13#glXCreatePixmap CreatePixmap} and returned in the {@code value} parameter of + * {@link GLX13#glXQueryDrawable QueryDrawable} when {@code attribute} is {@link #GLX_TEXTURE_FORMAT_EXT TEXTURE_FORMAT_EXT}. + */ + public static final int + GLX_TEXTURE_FORMAT_NONE_EXT = 0x20D8, + GLX_TEXTURE_FORMAT_RGB_EXT = 0x20D9, + GLX_TEXTURE_FORMAT_RGBA_EXT = 0x20DA; + + /** Accepted as bits in the {@link #GLX_BIND_TO_TEXTURE_TARGETS_EXT BIND_TO_TEXTURE_TARGETS_EXT} variable. */ + public static final int + GLX_TEXTURE_1D_BIT_EXT = 0x1, + GLX_TEXTURE_2D_BIT_EXT = 0x2, + GLX_TEXTURE_RECTANGLE_BIT_EXT = 0x4; + + /** + * Accepted as a value in the {@code attrib_list} parameter of {@link GLX13#glXCreatePixmap CreatePixmap} and returned in the {@code value} parameter of + * {@link GLX13#glXQueryDrawable QueryDrawable} when {@code attribute} is {@link #GLX_TEXTURE_TARGET_EXT TEXTURE_TARGET_EXT}. + */ + public static final int + GLX_TEXTURE_1D_EXT = 0x20DB, + GLX_TEXTURE_2D_EXT = 0x20DC, + GLX_TEXTURE_RECTANGLE_EXT = 0x20DD; + + /** Accepted by the {@code buffer} parameter of {@link #glXBindTexImageEXT BindTexImageEXT} and {@link #glXReleaseTexImageEXT ReleaseTexImageEXT}. */ + public static final int + GLX_FRONT_LEFT_EXT = 0x20DE, + GLX_FRONT_RIGHT_EXT = 0x20DF, + GLX_BACK_LEFT_EXT = 0x20E0, + GLX_BACK_RIGHT_EXT = 0x20E1, + GLX_FRONT_EXT = GLX_FRONT_LEFT_EXT, + GLX_BACK_EXT = GLX_BACK_LEFT_EXT, + GLX_AUX0_EXT = 0x20E2, + GLX_AUX1_EXT = 0x20E3, + GLX_AUX2_EXT = 0x20E4, + GLX_AUX3_EXT = 0x20E5, + GLX_AUX4_EXT = 0x20E6, + GLX_AUX5_EXT = 0x20E7, + GLX_AUX6_EXT = 0x20E8, + GLX_AUX7_EXT = 0x20E9, + GLX_AUX8_EXT = 0x20EA, + GLX_AUX9_EXT = 0x20EB; + + protected GLXEXTTextureFromPixmap() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXBindTexImageEXT, caps.glXReleaseTexImageEXT + ); + } + + // --- [ glXBindTexImageEXT ] --- + + /** Unsafe version of: {@link #glXBindTexImageEXT BindTexImageEXT} */ + public static void nglXBindTexImageEXT(long display, long drawable, int buffer, long attrib_list) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXBindTexImageEXT; + if (CHECKS) { + check(__functionAddress); + check(display); + check(drawable); + } + callPPPV(display, drawable, buffer, attrib_list, __functionAddress); + } + + /** + * Defines a one- or two-dimensional texture image. The texture image is taken from {@code buffer} and need not be copied. The texture target, the texture + * format, and the size of the texture components are derived from attributes of {@code drawable}. + * + * @param display the connection to the X server + * @param drawable the drawable + * @param buffer the buffer + * @param attrib_list an optional null-terminated list of attributes + */ + public static void glXBindTexImageEXT(@NativeType("Display *") long display, @NativeType("GLXDrawable") long drawable, int buffer, @Nullable @NativeType("int const *") IntBuffer attrib_list) { + if (CHECKS) { + checkNTSafe(attrib_list); + } + nglXBindTexImageEXT(display, drawable, buffer, memAddressSafe(attrib_list)); + } + + // --- [ glXReleaseTexImageEXT ] --- + + /** + * Releases a color buffer that is being used as a texture. + * + * @param display the connection to the X server + * @param drawable the drawable + * @param buffer the buffer + */ + public static void glXReleaseTexImageEXT(@NativeType("Display *") long display, @NativeType("GLXDrawable") long drawable, int buffer) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXReleaseTexImageEXT; + if (CHECKS) { + check(__functionAddress); + check(display); + check(drawable); + } + callPPV(display, drawable, buffer, __functionAddress); + } + + /** Array version of: {@link #glXBindTexImageEXT BindTexImageEXT} */ + public static void glXBindTexImageEXT(@NativeType("Display *") long display, @NativeType("GLXDrawable") long drawable, int buffer, @Nullable @NativeType("int const *") int[] attrib_list) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXBindTexImageEXT; + if (CHECKS) { + check(__functionAddress); + check(display); + check(drawable); + checkNTSafe(attrib_list); + } + callPPPV(display, drawable, buffer, attrib_list, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTVisualInfo.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTVisualInfo.java new file mode 100644 index 00000000..c201979d --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTVisualInfo.java @@ -0,0 +1,53 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_EXT_visual_info extension. + * + *This extension allows the user to request a particular X visual type to be associated with a GLX visual, and allows the user to query the X visual type + * underlying a GLX visual.
+ * + *In addition, this extension provides a means to request a visual with a transparent pixel and to query whether a visual supports a transparent pixel + * value and the value of the transparent pixel. Note that the notion of level and transparent pixels are orthogonal as both layer 1 and layer 0 visuals + * may or may not have a transparent pixel value.
+ */ +public final class GLXEXTVisualInfo { + + /** Accepted by the {@code attrib} parameter of {@link GLX#glXGetConfig GetConfig}, and by the {@code attrib_list} parameter of {@link GLX#glXChooseVisual ChooseVisual}. */ + public static final int + GLX_X_VISUAL_TYPE_EXT = 0x22, + GLX_TRANSPARENT_TYPE_EXT = 0x23, + GLX_TRANSPARENT_INDEX_VALUE_EXT = 0x24, + GLX_TRANSPARENT_RED_VALUE_EXT = 0x25, + GLX_TRANSPARENT_GREEN_VALUE_EXT = 0x26, + GLX_TRANSPARENT_BLUE_VALUE_EXT = 0x27, + GLX_TRANSPARENT_ALPHA_VALUE_EXT = 0x28; + + /** + * Returned by {@link GLX#glXGetConfig GetConfig}, and accepted by the {@code attrib_list} parameter of {@link GLX#glXChooseVisual ChooseVisual} (following the + * {@link #GLX_X_VISUAL_TYPE_EXT X_VISUAL_TYPE_EXT} token). + */ + public static final int + GLX_TRUE_COLOR_EXT = 0x8002, + GLX_DIRECT_COLOR_EXT = 0x8003, + GLX_PSEUDO_COLOR_EXT = 0x8004, + GLX_STATIC_COLOR_EXT = 0x8005, + GLX_GRAY_SCALE_EXT = 0x8006, + GLX_STATIC_GRAY_EXT = 0x8007; + + /** + * Returned by {@link GLX#glXGetConfig GetConfig}, and accepted by the {@code attrib_list} parameter of {@link GLX#glXChooseVisual ChooseVisual} (following the + * {@link #GLX_TRANSPARENT_TYPE_EXT TRANSPARENT_TYPE_EXT} token). + */ + public static final int + GLX_NONE_EXT = 0x8000, + GLX_TRANSPARENT_RGB_EXT = 0x8008, + GLX_TRANSPARENT_INDEX_EXT = 0x8009; + + private GLXEXTVisualInfo() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTVisualRating.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTVisualRating.java new file mode 100644 index 00000000..aeb4a881 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXEXTVisualRating.java @@ -0,0 +1,35 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_EXT_visual_rating extension. + * + *This extension allows servers to identify a particular GLX visual as undesirable. A new visual attribute is introduced, providing a way for servers to + * specify caveats (e.g., slow) for a visual. The attribute may be queried using {@link GLX#glXGetConfig GetConfig}, and can therefore be used by + * application-specific visual selection routines. The new attribute is also used by {@link GLX#glXChooseVisual ChooseVisual} to discriminate against visuals with + * caveats.
+ * + *This extension allows servers to export visuals with improved features or image quality, but lower performance or greater system burden, without having + * to have these visuals selected preferentially. It is intended to insure that most applications get the "right" visual, not that all applications do.
+ */ +public final class GLXEXTVisualRating { + + /** Accepted by the {@code attribute} parameter of {@link GLX#glXGetConfig GetConfig} and by the {@code attrib_list} parameter of {@link GLX#glXChooseVisual ChooseVisual}. */ + public static final int GLX_VISUAL_CAVEAT_EXT = 0x20; + + /** + * Returned by the {@code value} parameter of {@link GLX#glXGetConfig GetConfig} (when {@code attribute} is set to {@link #GLX_VISUAL_CAVEAT_EXT VISUAL_CAVEAT_EXT}) and accepted by the {@code attrib_list} + * parameter of {@link GLX#glXChooseVisual ChooseVisual} (following the {@link #GLX_VISUAL_CAVEAT_EXT VISUAL_CAVEAT_EXT} token). + */ + public static final int + GLX_NONE_EXT = 0x8000, + GLX_SLOW_VISUAL_EXT = 0x8001, + GLX_NON_CONFORMANT_VISUAL_EXT = 0x800D; + + private GLXEXTVisualRating() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXINTELSwapEvent.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXINTELSwapEvent.java new file mode 100644 index 00000000..fbbf1fc4 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXINTELSwapEvent.java @@ -0,0 +1,29 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_INTEL_swap_event extension. + * + *This extension adds a new event type, {@link #GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK BUFFER_SWAP_COMPLETE_INTEL_MASK}, which is sent to the client via the X11 event stream and + * selected/consumed by the normal GLX event mask mechanisms, to indicate when a previously queued swap has completed.
+ * + *Requires {@link GLX13 GLX 1.3}.
+ */ +public final class GLXINTELSwapEvent { + + /** Accepted by the {@code mask} parameter of {@link GLX13#glXSelectEvent SelectEvent} and returned in the {@code mask} parameter of {@link GLX13#glXGetSelectedEvent GetSelectedEvent}. */ + public static final int GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK = 0x4000000; + + /** Returned in the {@code event_type} field of a "swap complete" event. */ + public static final int + GLX_EXCHANGE_COMPLETE_INTEL = 0x8180, + GLX_COPY_COMPLETE_INTEL = 0x8181, + GLX_FLIP_COMPLETE_INTEL = 0x8182; + + private GLXINTELSwapEvent() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVCopyBuffer.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVCopyBuffer.java new file mode 100644 index 00000000..ea09ffa1 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVCopyBuffer.java @@ -0,0 +1,58 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** + * Native bindings to the GLX_NV_copy_buffer extension. + * + *Extends {@link ARBCopyBuffer ARB_copy_buffer} to have GLX bindings.
+ */ +public class GLXNVCopyBuffer { + + protected GLXNVCopyBuffer() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXCopyBufferSubDataNV, caps.glXNamedCopyBufferSubDataNV + ); + } + + // --- [ glXCopyBufferSubDataNV ] --- + + /** @param display the connection to the X server */ + public static void glXCopyBufferSubDataNV(@NativeType("Display *") long display, @NativeType("GLXContext") long readCtx, @NativeType("GLXContext") long writeCtx, @NativeType("GLenum") int readTarget, @NativeType("GLenum") int writeTarget, @NativeType("GLintptr") long readOffset, @NativeType("GLintptr") long writeOffset, @NativeType("GLsizeiptr") long size) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCopyBufferSubDataNV; + if (CHECKS) { + check(__functionAddress); + check(display); + check(readCtx); + check(writeCtx); + } + callPPPPPPV(display, readCtx, writeCtx, readTarget, writeTarget, readOffset, writeOffset, size, __functionAddress); + } + + // --- [ glXNamedCopyBufferSubDataNV ] --- + + /** @param display the connection to the X server */ + public static void glXNamedCopyBufferSubDataNV(@NativeType("Display *") long display, @NativeType("GLXContext") long readCtx, @NativeType("GLXContext") long writeCtx, @NativeType("GLuint") int readBuffer, @NativeType("GLuint") int writeBuffer, @NativeType("GLintptr") long readOffset, @NativeType("GLintptr") long writeOffset, @NativeType("GLsizeiptr") long size) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXNamedCopyBufferSubDataNV; + if (CHECKS) { + check(__functionAddress); + check(display); + check(readCtx); + check(writeCtx); + } + callPPPPPPV(display, readCtx, writeCtx, readBuffer, writeBuffer, readOffset, writeOffset, size, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVCopyImage.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVCopyImage.java new file mode 100644 index 00000000..e1188de7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVCopyImage.java @@ -0,0 +1,52 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** + * Native bindings to the GLX_NV_copy_image extension. + * + *This extension enables efficient image data transfer between image objects (i.e. textures and renderbuffers) without the need to bind the objects or + * otherwise configure the rendering pipeline. The GLX version allows copying between images in different contexts, even if those contexts are in different + * sharelists or even on different physical devices.
+ */ +public class GLXNVCopyImage { + + protected GLXNVCopyImage() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXCopyImageSubDataNV + ); + } + + // --- [ glXCopyImageSubDataNV ] --- + + /** + * Behaves identically to the core function {@link #glXCopyImageSubDataNV CopyImageSubDataNV}, except that the {@code srcCtx} and {@code dstCtx} parameters specify + * the contexts in which to look up the source and destination objects, respectively. A value of {@code NULL} for either context indicates that the value which is + * returned by {@link GLX#glXGetCurrentContext GetCurrentContext} should be used instead. Both contexts must share the same address space. + * + * @param display the connection to the X server + * @param srcCtx the source context + * @param dstCtx the destination context + */ + public static void glXCopyImageSubDataNV(@NativeType("Display *") long display, @NativeType("GLXContext") long srcCtx, @NativeType("GLuint") int srcName, @NativeType("GLenum") int srcTarget, @NativeType("GLint") int srcLevel, @NativeType("GLint") int srcX, @NativeType("GLint") int srcY, @NativeType("GLint") int srcZ, @NativeType("GLXContext") long dstCtx, @NativeType("GLuint") int dstName, @NativeType("GLenum") int dstTarget, @NativeType("GLint") int dstLevel, @NativeType("GLint") int dstX, @NativeType("GLint") int dstY, @NativeType("GLint") int dstZ, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCopyImageSubDataNV; + if (CHECKS) { + check(__functionAddress); + check(display); + } + callPPPV(display, srcCtx, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstCtx, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVDelayBeforeSwap.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVDelayBeforeSwap.java new file mode 100644 index 00000000..72fca297 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVDelayBeforeSwap.java @@ -0,0 +1,71 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** + * Native bindings to the GLX_NV_delay_before_swap extension. + * + *For most interactive applications, the standard rendering loop responding to input events on a frame granularity is sufficient. Some more demanding + * applications may want to exchange performance for the ability to sample input closer to the final frame swap and adjust rendering accordingly. This + * extension adds functionality to allow the application to wait until a specified time before a swapbuffers command would be able to execute.
+ * + *Requires {@link GLX11 GLX11} and {@link GLXEXTSwapControl GLX_EXT_swap_control}.
+ */ +public class GLXNVDelayBeforeSwap { + + protected GLXNVDelayBeforeSwap() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXDelayBeforeSwapNV + ); + } + + // --- [ glXDelayBeforeSwapNV ] --- + + /** + * Blocks the CPU until {@code seconds} seconds before a synchronized swap would occur on a particular GLX window drawable. It also returns a boolean value + * equal to {@code True} when the implementation had to wait for the synchronized swap and {@code False} otherwise. + * + *The parameter {@code seconds} accepts positive floating point values not larger than the length in seconds of the swap period on the associated + * drawable. When buffer swaps are synchronized, the swap period is composed of one or multiple video frame periods. A video frame period is the time + * required by the monitor to display a full frame of video data. A swap interval set to a value of 2 means that the color buffers will be swapped at most + * every other video frame. If {@code seconds} is smaller than 0, {@code DelayBeforeSwapNV} will return False and will not wait for the end of the swap + * period. If {@code seconds} is greater than a swap period, {@code DelayBeforeSwapNV} will return immediately without generating any error and the return + * value will be False.
+ * + *The application should use a {@code seconds} delay large enough to have time to complete its work before the end of the swap period. If {@code seconds} + * is close to 0.0, the application may miss the end of the swap period and it will have to wait an additional swap period before it can swap.
+ * + *If {@code DelayBeforeSwapNV} detects that there is less than {@code seconds} seconds before the end of the swap period, it will return immediately and + * the return value will be False. The implementation will not wait an additional video frame period to have an exact delay of {@code seconds} seconds.
+ * + *If buffer swaps are unsynchronized, {@code DelayBeforeSwapNV} will return immediately and the return value will be False. It could happen for multiple + * reasons, for example if the swap interval is equal to 0, if the window is in a mode switch or if no monitors are active.
+ * + * @param display the connection to the X server + * @param drawable the window drawable + * @param seconds the delay, in seconds + */ + @NativeType("Bool") + public static boolean glXDelayBeforeSwapNV(@NativeType("Display *") long display, @NativeType("GLXDrawable") long drawable, @NativeType("GLfloat") float seconds) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXDelayBeforeSwapNV; + if (CHECKS) { + check(__functionAddress); + check(display); + check(drawable); + } + return callPPI(display, drawable, seconds, __functionAddress) != 0; + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVFloatBuffer.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVFloatBuffer.java new file mode 100644 index 00000000..7908823c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVFloatBuffer.java @@ -0,0 +1,20 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_NV_float_buffer extension. + * + *GLX functionality for {@link NVFloatBuffer NV_float_buffer}.
+ */ +public final class GLXNVFloatBuffer { + + /** Accepted in the {@code value} array of glXGetFBConfigAttrib (and glXGetFBConfigAttribSGIX). */ + public static final int GLX_FLOAT_COMPONENTS_NV = 0x20B0; + + private GLXNVFloatBuffer() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVMultisampleCoverage.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVMultisampleCoverage.java new file mode 100644 index 00000000..e7fcc2b7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVMultisampleCoverage.java @@ -0,0 +1,25 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_NV_multisample_coverage extension. + * + *GLX functionality for {@link NVMultisampleCoverage NV_multisample_coverage}.
+ */ +public final class GLXNVMultisampleCoverage { + + /** + * Accepted by the {@code attribList} parameter of glXChooseVisual, and by the {@code attrib} parameter of glXGetConfig, the + * {@code attrib_list} parameter of glXChooseFBConfig, and the {@code attribute} parameter of glXGetFBConfigAttrib. + */ + public static final int + GLX_COVERAGE_SAMPLES_NV = 100001, + GLX_COLOR_SAMPLES_NV = 0x20B3; + + private GLXNVMultisampleCoverage() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVRobustnessVideoMemoryPurge.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVRobustnessVideoMemoryPurge.java new file mode 100644 index 00000000..26118a3a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVRobustnessVideoMemoryPurge.java @@ -0,0 +1,20 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the GLX_NV_robustness_video_memory_purge extension. + * + *GLX functionality for {@link NVRobustnessVideoMemoryPurge NV_robustness_video_memory_purge}.
+ */ +public final class GLXNVRobustnessVideoMemoryPurge { + + /** Accepted as an attribute name in the {@code *attrib_list} argument of glXCreateContextAttribsARB. */ + public static final int GLX_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV = 0x20F7; + + private GLXNVRobustnessVideoMemoryPurge() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVSwapGroup.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVSwapGroup.java new file mode 100644 index 00000000..c664c74f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXNVSwapGroup.java @@ -0,0 +1,185 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the GLX_NV_swap_group extension. + * + *This extension provides the capability to synchronize the buffer swaps of a group of OpenGL windows. A swap group is created, and windows are added as + * members to the swap group. Buffer swaps to members of the swap group will then take place concurrently.
+ * + *This extension also provides the capability to sychronize the buffer swaps of different swap groups, which may reside on distributed systems on a + * network. For this purpose swap groups can be bound to a swap barrier.
+ * + *This extension extends the set of conditions that must be met before a buffer swap can take place.
+ */ +public class GLXNVSwapGroup { + + protected GLXNVSwapGroup() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXJoinSwapGroupNV, caps.glXBindSwapBarrierNV, caps.glXQuerySwapGroupNV, caps.glXQueryMaxSwapGroupsNV, caps.glXQueryFrameCountNV, + caps.glXResetFrameCountNV + ); + } + + // --- [ glXJoinSwapGroupNV ] --- + + /** @param display the connection to the X server */ + @NativeType("Bool") + public static boolean glXJoinSwapGroupNV(@NativeType("Display *") long display, @NativeType("GLXDrawable") long drawable, @NativeType("GLuint") int group) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXJoinSwapGroupNV; + if (CHECKS) { + check(__functionAddress); + check(display); + check(drawable); + } + return callPPI(display, drawable, group, __functionAddress) != 0; + } + + // --- [ glXBindSwapBarrierNV ] --- + + /** @param display the connection to the X server */ + @NativeType("Bool") + public static boolean glXBindSwapBarrierNV(@NativeType("Display *") long display, @NativeType("GLuint") int group, @NativeType("GLuint") int barrier) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXBindSwapBarrierNV; + if (CHECKS) { + check(__functionAddress); + check(display); + } + return callPI(display, group, barrier, __functionAddress) != 0; + } + + // --- [ glXQuerySwapGroupNV ] --- + + /** Unsafe version of: {@link #glXQuerySwapGroupNV QuerySwapGroupNV} */ + public static int nglXQuerySwapGroupNV(long display, long drawable, long group, long barrier) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQuerySwapGroupNV; + if (CHECKS) { + check(__functionAddress); + check(display); + check(drawable); + } + return callPPPPI(display, drawable, group, barrier, __functionAddress); + } + + /** @param display the connection to the X server */ + @NativeType("Bool") + public static boolean glXQuerySwapGroupNV(@NativeType("Display *") long display, @NativeType("GLXDrawable") long drawable, @NativeType("GLuint *") IntBuffer group, @NativeType("GLuint *") IntBuffer barrier) { + if (CHECKS) { + check(group, 1); + check(barrier, 1); + } + return nglXQuerySwapGroupNV(display, drawable, memAddress(group), memAddress(barrier)) != 0; + } + + // --- [ glXQueryMaxSwapGroupsNV ] --- + + /** Unsafe version of: {@link #glXQueryMaxSwapGroupsNV QueryMaxSwapGroupsNV} */ + public static int nglXQueryMaxSwapGroupsNV(long display, int screen, long maxGroups, long maxBarriers) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryMaxSwapGroupsNV; + if (CHECKS) { + check(__functionAddress); + check(display); + } + return callPPPI(display, screen, maxGroups, maxBarriers, __functionAddress); + } + + /** @param display the connection to the X server */ + @NativeType("Bool") + public static boolean glXQueryMaxSwapGroupsNV(@NativeType("Display *") long display, int screen, @NativeType("GLuint *") IntBuffer maxGroups, @NativeType("GLuint *") IntBuffer maxBarriers) { + if (CHECKS) { + check(maxGroups, 1); + check(maxBarriers, 1); + } + return nglXQueryMaxSwapGroupsNV(display, screen, memAddress(maxGroups), memAddress(maxBarriers)) != 0; + } + + // --- [ glXQueryFrameCountNV ] --- + + /** Unsafe version of: {@link #glXQueryFrameCountNV QueryFrameCountNV} */ + public static int nglXQueryFrameCountNV(long display, int screen, long count) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryFrameCountNV; + if (CHECKS) { + check(__functionAddress); + check(display); + } + return callPPI(display, screen, count, __functionAddress); + } + + /** @param display the connection to the X server */ + @NativeType("Bool") + public static boolean glXQueryFrameCountNV(@NativeType("Display *") long display, int screen, @NativeType("GLuint *") IntBuffer count) { + if (CHECKS) { + check(count, 1); + } + return nglXQueryFrameCountNV(display, screen, memAddress(count)) != 0; + } + + // --- [ glXResetFrameCountNV ] --- + + /** @param display the connection to the X server */ + @NativeType("Bool") + public static boolean glXResetFrameCountNV(@NativeType("Display *") long display, int screen) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXResetFrameCountNV; + if (CHECKS) { + check(__functionAddress); + check(display); + } + return callPI(display, screen, __functionAddress) != 0; + } + + /** Array version of: {@link #glXQuerySwapGroupNV QuerySwapGroupNV} */ + @NativeType("Bool") + public static boolean glXQuerySwapGroupNV(@NativeType("Display *") long display, @NativeType("GLXDrawable") long drawable, @NativeType("GLuint *") int[] group, @NativeType("GLuint *") int[] barrier) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQuerySwapGroupNV; + if (CHECKS) { + check(__functionAddress); + check(display); + check(drawable); + check(group, 1); + check(barrier, 1); + } + return callPPPPI(display, drawable, group, barrier, __functionAddress) != 0; + } + + /** Array version of: {@link #glXQueryMaxSwapGroupsNV QueryMaxSwapGroupsNV} */ + @NativeType("Bool") + public static boolean glXQueryMaxSwapGroupsNV(@NativeType("Display *") long display, int screen, @NativeType("GLuint *") int[] maxGroups, @NativeType("GLuint *") int[] maxBarriers) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryMaxSwapGroupsNV; + if (CHECKS) { + check(__functionAddress); + check(display); + check(maxGroups, 1); + check(maxBarriers, 1); + } + return callPPPI(display, screen, maxGroups, maxBarriers, __functionAddress) != 0; + } + + /** Array version of: {@link #glXQueryFrameCountNV QueryFrameCountNV} */ + @NativeType("Bool") + public static boolean glXQueryFrameCountNV(@NativeType("Display *") long display, int screen, @NativeType("GLuint *") int[] count) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryFrameCountNV; + if (CHECKS) { + check(__functionAddress); + check(display); + check(count, 1); + } + return callPPI(display, screen, count, __functionAddress) != 0; + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIMakeCurrentRead.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIMakeCurrentRead.java new file mode 100644 index 00000000..ca63fec2 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIMakeCurrentRead.java @@ -0,0 +1,64 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** + * Native bindings to the GLX_SGI_make_current_read extension. + * + *The association of the current context with a drawable is extended to allow separate write and read drawables. This paves the way for allowing + * preprocessing of image data in an "off screen" window which is then read into the visible window for final display. Similarly it sets the frame-work + * for direct transfer of video to the GL, by treating the video as a special kind of read drawable (a.k.a, readable).
+ */ +public class GLXSGIMakeCurrentRead { + + protected GLXSGIMakeCurrentRead() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXMakeCurrentReadSGI, caps.glXGetCurrentReadDrawableSGI + ); + } + + // --- [ glXMakeCurrentReadSGI ] --- + + /** + * Associates two {@code GLXDrawables} with the current rendering context. + * + * @param display the connection to the X server + * @param draw the draw drawable + * @param read the read drawable + * @param ctx the current context + */ + @NativeType("Bool") + public static boolean glXMakeCurrentReadSGI(@NativeType("Display *") long display, @NativeType("GLXDrawable") long draw, @NativeType("GLXDrawable") long read, @NativeType("GLXContext") long ctx) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXMakeCurrentReadSGI; + if (CHECKS) { + check(__functionAddress); + check(display); + } + return callPPPPI(display, draw, read, ctx, __functionAddress) != 0; + } + + // --- [ glXGetCurrentReadDrawableSGI ] --- + + /** Returns the name of the {@code GLXDrawable} currently being used as a pixel query source. */ + @NativeType("GLXDrawable") + public static long glXGetCurrentReadDrawableSGI() { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetCurrentReadDrawableSGI; + if (CHECKS) { + check(__functionAddress); + } + return callP(__functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGISwapControl.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGISwapControl.java new file mode 100644 index 00000000..ef31dd97 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGISwapControl.java @@ -0,0 +1,51 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** + * Native bindings to the GLX_SGI_swap_control extension. + * + *This extension allows an application to specify a minimum periodicity of color buffer swaps, measured in video frame periods.
+ */ +public class GLXSGISwapControl { + + protected GLXSGISwapControl() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXSwapIntervalSGI + ); + } + + // --- [ glXSwapIntervalSGI ] --- + + /** + * Specifies the minimum number of video frame periods per buffer swap. (e.g. a value of two means that the color buffers will be swapped at most every + * other video frame.) A return value of zero indicates success; otherwise an error occurred. The interval takes effect when {@link GLX#glXSwapBuffers SwapBuffers} + * is first called subsequent to the {@code glXSwapIntervalSGI} call. + * + *A video frame period is the time required by the monitor to display a full frame of video data. In the case of an interlaced monitor, this is typically + * the time required to display both the even and odd fields of a frame of video data.
+ * + * @param interval the swap interval + */ + @NativeType("GLint") + public static int glXSwapIntervalSGI(int interval) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXSwapIntervalSGI; + if (CHECKS) { + check(__functionAddress); + } + return callI(interval, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIVideoSync.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIVideoSync.java new file mode 100644 index 00000000..3585509b --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIVideoSync.java @@ -0,0 +1,111 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the GLX_SGI_video_sync extension. + * + *This extension provides a means for synchronization with the video frame rate of a monitor.
+ */ +public class GLXSGIVideoSync { + + protected GLXSGIVideoSync() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXGetVideoSyncSGI, caps.glXWaitVideoSyncSGI + ); + } + + // --- [ glXGetVideoSyncSGI ] --- + + /** Unsafe version of: {@link #glXGetVideoSyncSGI GetVideoSyncSGI} */ + public static int nglXGetVideoSyncSGI(long count) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetVideoSyncSGI; + if (CHECKS) { + check(__functionAddress); + } + return callPI(count, __functionAddress); + } + + /** + * Returns the value of the video sync counter in {@code count}. Zero is returned if the call is successful. + * + * @param count the video sync counter value + */ + @NativeType("GLint") + public static int glXGetVideoSyncSGI(@NativeType("unsigned int *") IntBuffer count) { + if (CHECKS) { + check(count, 1); + } + return nglXGetVideoSyncSGI(memAddress(count)); + } + + // --- [ glXWaitVideoSyncSGI ] --- + + /** Unsafe version of: {@link #glXWaitVideoSyncSGI WaitVideoSyncSGI} */ + public static int nglXWaitVideoSyncSGI(int divisor, int remainder, long count) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXWaitVideoSyncSGI; + if (CHECKS) { + check(__functionAddress); + } + return callPI(divisor, remainder, count, __functionAddress); + } + + /** + * Puts the calling process to sleep until + * + *{@code (C mod D) = R}
+ * + *where {@code C} is the video sync counter, {@code D} is specified by the {@code divisor} parameter of {@code glXWaitVideoSyncSGI}, and {@code R} is + * specified by the {@code remainder} parameter of {@code glXWaitVideoSyncSGI}. {@code glXWaitVideoSyncSGI} returns the current video sync counter value in + * {@code count}. Zero is returned by {@code glXWaitVideoSyncSGI} if it is successful.
+ * + * @param divisor the divisor value + * @param remainder the remainder value + * @param count the video sync counter value + */ + @NativeType("GLint") + public static int glXWaitVideoSyncSGI(int divisor, int remainder, @NativeType("unsigned int *") IntBuffer count) { + if (CHECKS) { + check(count, 1); + } + return nglXWaitVideoSyncSGI(divisor, remainder, memAddress(count)); + } + + /** Array version of: {@link #glXGetVideoSyncSGI GetVideoSyncSGI} */ + @NativeType("GLint") + public static int glXGetVideoSyncSGI(@NativeType("unsigned int *") int[] count) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetVideoSyncSGI; + if (CHECKS) { + check(__functionAddress); + check(count, 1); + } + return callPI(count, __functionAddress); + } + + /** Array version of: {@link #glXWaitVideoSyncSGI WaitVideoSyncSGI} */ + @NativeType("GLint") + public static int glXWaitVideoSyncSGI(int divisor, int remainder, @NativeType("unsigned int *") int[] count) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXWaitVideoSyncSGI; + if (CHECKS) { + check(__functionAddress); + check(count, 1); + } + return callPI(divisor, remainder, count, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIXFBConfig.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIXFBConfig.java new file mode 100644 index 00000000..62c587e6 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIXFBConfig.java @@ -0,0 +1,272 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +import org.lwjgl.system.linux.*; + +/** + * Native bindings to the GLX_SGIX_fbconfig extension. + * + *This extension introduces a new way to describe the capabilities of a GLX drawable (i.e., to describe the depth of color buffer components and the type + * and size of ancillary buffers), removes the "similarity" requirement when making a context current to a drawable, and supports RGBA rendering to + * one-and two-component Windows and GLX Pixmaps.
+ */ +public class GLXSGIXFBConfig { + + /** Accepted by the {@code attribute} parameter of {@link #glXGetFBConfigAttribSGIX GetFBConfigAttribSGIX}, and by the {@code attrib_list} parameter of {@link #glXChooseFBConfigSGIX ChooseFBConfigSGIX}. */ + public static final int + GLX_DRAWABLE_TYPE_SGIX = 0x8010, + GLX_RENDER_TYPE_SGIX = 0x8011, + GLX_X_RENDERABLE_SGIX = 0x8012; + + /** + * Accepted by the {@code attribute} parameter of {@link #glXGetFBConfigAttribSGIX GetFBConfigAttribSGIX}, the {@code attrib_list} parameter of {@link #glXChooseFBConfigSGIX ChooseFBConfigSGIX}, + * by the {@code attribute} parameter of {@link GLXSGIXPbuffer#glXQueryGLXPbufferSGIX QueryGLXPbufferSGIX} and by the {@code attribute} parameter of + * {@link GLXEXTImportContext#glXQueryContextInfoEXT QueryContextInfoEXT}. + */ + public static final int GLX_FBCONFIG_ID_SGIX = 0x8013; + + /** Accepted by the {@code attribute} parameter of {@link #glXGetFBConfigAttribSGIX GetFBConfigAttribSGIX}. */ + public static final int GLX_SCREEN_EXT = 0x800C; + + /** + * Returned by {@link #glXGetFBConfigAttribSGIX GetFBConfigAttribSGIX} (when {@code attribute} is set to {@link #GLX_DRAWABLE_TYPE_SGIX DRAWABLE_TYPE_SGIX}) and accepted by the {@code attrib_list} + * parameter of {@link #glXChooseFBConfigSGIX ChooseFBConfigSGIX} (following the {@link #GLX_DRAWABLE_TYPE_SGIX DRAWABLE_TYPE_SGIX} token). + */ + public static final int + GLX_WINDOW_BIT_SGIX = 0x1, + GLX_PIXMAP_BIT_SGIX = 0x2; + + /** + * Returned by {@link #glXGetFBConfigAttribSGIX GetFBConfigAttribSGIX} (when {@code attribute} is set to {@link #GLX_RENDER_TYPE_SGIX RENDER_TYPE_SGIX}) and accepted by the {@code attrib_list} + * parameter of {@link #glXChooseFBConfigSGIX ChooseFBConfigSGIX} (following the {@link #GLX_RENDER_TYPE_SGIX RENDER_TYPE_SGIX} token). + */ + public static final int + GLX_RGBA_BIT_SGIX = 0x1, + GLX_COLOR_INDEX_BIT_SGIX = 0x2; + + /** Accepted by the {@code render_type} parameter of {@link #glXCreateContextWithConfigSGIX CreateContextWithConfigSGIX}. */ + public static final int + GLX_RGBA_TYPE_SGIX = 0x8014, + GLX_COLOR_INDEX_TYPE_SGIX = 0x8015; + + protected GLXSGIXFBConfig() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXGetFBConfigAttribSGIX, caps.glXChooseFBConfigSGIX, caps.glXCreateGLXPixmapWithConfigSGIX, caps.glXCreateContextWithConfigSGIX, + caps.glXGetVisualFromFBConfigSGIX, caps.glXGetFBConfigFromVisualSGIX + ); + } + + // --- [ glXGetFBConfigAttribSGIX ] --- + + /** Unsafe version of: {@link #glXGetFBConfigAttribSGIX GetFBConfigAttribSGIX} */ + public static int nglXGetFBConfigAttribSGIX(long display, long config, int attribute, long value) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetFBConfigAttribSGIX; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + } + return callPPPI(display, config, attribute, value, __functionAddress); + } + + /** + * Gets the value of a GLX attribute for a {@code GLXFBConfigSGIX}. + * + * @param display the connection to the X server + * @param config the {@code GLXFBConfigSGIX} being queried + * @param attribute the attribute to query + * @param value returns the attribute value + */ + public static int glXGetFBConfigAttribSGIX(@NativeType("Display *") long display, @NativeType("GLXFBConfigSGIX") long config, int attribute, @NativeType("int *") IntBuffer value) { + if (CHECKS) { + check(value, 1); + } + return nglXGetFBConfigAttribSGIX(display, config, attribute, memAddress(value)); + } + + // --- [ glXChooseFBConfigSGIX ] --- + + /** + * Unsafe version of: {@link #glXChooseFBConfigSGIX ChooseFBConfigSGIX} + * + * @param nelements the number of {@code GLXFBConfigSGIX} returned + */ + public static long nglXChooseFBConfigSGIX(long display, int screen, long attrib_list, long nelements) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXChooseFBConfigSGIX; + if (CHECKS) { + check(__functionAddress); + check(display); + } + return callPPPP(display, screen, attrib_list, nelements, __functionAddress); + } + + /** + * Gets {@code GLXFBConfigSGIX}s that match a list of attributes or to get the list of GLXFBConfigSGIXs that are available on the specified screen. + * + * @param display the connection to the X server + * @param screen the screen number + * @param attrib_list an optional list of attributes, terminated with org.lwjgl.system.linux.{@code None} + */ + @Nullable + @NativeType("GLXFBConfigSGIX *") + public static PointerBuffer glXChooseFBConfigSGIX(@NativeType("Display *") long display, int screen, @Nullable @NativeType("int const *") IntBuffer attrib_list) { + if (CHECKS) { + checkNTSafe(attrib_list); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + IntBuffer nelements = stack.callocInt(1); + try { + long __result = nglXChooseFBConfigSGIX(display, screen, memAddressSafe(attrib_list), memAddress(nelements)); + return memPointerBufferSafe(__result, nelements.get(0)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glXCreateGLXPixmapWithConfigSGIX ] --- + + /** + * Creates a GLX pixmap using a {@code GLXFBConfigSGIX}. + * + * @param display the connection to the X server + * @param config the {@code GLXFBConfigSGIX} + * @param pixmap the pixmap + */ + @NativeType("GLXPixmap") + public static long glXCreateGLXPixmapWithConfigSGIX(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config, @NativeType("Pixmap") long pixmap) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCreateGLXPixmapWithConfigSGIX; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + } + return callPPNP(display, config, pixmap, __functionAddress); + } + + // --- [ glXCreateContextWithConfigSGIX ] --- + + /** + * Creates a GLX context using a {@code GLXFBConfigSGIX}. + * + * @param display the connection to the X server + * @param config the {@code GLXFBConfigSGIX} + * @param render_type the render type. One of:| {@link #GLX_RGBA_TYPE_SGIX RGBA_TYPE_SGIX} | {@link #GLX_COLOR_INDEX_TYPE_SGIX COLOR_INDEX_TYPE_SGIX} |
This extension defines pixel buffers (GLXPbuffers, or pbuffer for short). GLXPbuffers are additional non-visible rendering buffers for an OpenGL + * renderer.
+ */ +public class GLXSGIXPbuffer { + + /** Accepted by the {@code attribute} parameter of {@link GLXSGIXFBConfig#glXGetFBConfigAttribSGIX GetFBConfigAttribSGIX}. */ + public static final int + GLX_MAX_PBUFFER_WIDTH_SGIX = 0x8016, + GLX_MAX_PBUFFER_HEIGHT_SGIX = 0x8017, + GLX_MAX_PBUFFER_PIXELS_SGIX = 0x8018, + GLX_OPTIMAL_PBUFFER_WIDTH_SGIX = 0x8019, + GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX = 0x801A; + + /** + * Returned by {@link GLXSGIXFBConfig#glXGetFBConfigAttribSGIX GetFBConfigAttribSGIX} (when {@code attribute} is set to {@link GLXSGIXFBConfig#GLX_DRAWABLE_TYPE_SGIX DRAWABLE_TYPE_SGIX}) and + * accepted by the {@code attrib_list} parameter of {@link GLXSGIXFBConfig#glXChooseFBConfigSGIX ChooseFBConfigSGIX} (following the + * {@link GLXSGIXFBConfig#GLX_DRAWABLE_TYPE_SGIX DRAWABLE_TYPE_SGIX} token). + */ + public static final int GLX_PBUFFER_BIT_SGIX = 0x4; + + /** Accepted by the {@code attrib_list} parameter of {@link #glXCreateGLXPbufferSGIX CreateGLXPbufferSGIX} and by the {@code attribute} parameter of {@link #glXQueryGLXPbufferSGIX QueryGLXPbufferSGIX}. */ + public static final int + GLX_PRESERVED_CONTENTS_SGIX = 0x801B, + GLX_LARGEST_PBUFFER_SGIX = 0x801C; + + /** Accepted by the {@code attribute} parameter of {@link #glXQueryGLXPbufferSGIX QueryGLXPbufferSGIX}. */ + public static final int + GLX_WIDTH_SGIX = 0x801D, + GLX_HEIGHT_SGIX = 0x801E, + GLX_EVENT_MASK_SGIX = 0x801F; + + /** Accepted by the {@code mask} parameter of {@link #glXSelectEventSGIX SelectEventSGIX} and returned in the {@code mask} parameter of {@link #glXGetSelectedEventSGIX GetSelectedEventSGIX}. */ + public static final int GLX_BUFFER_CLOBBER_MASK_SGIX = 0x8000000; + + /** Returned in the {@code event_type} field of a "buffer clobber" event. */ + public static final int + GLX_DAMAGED_SGIX = 0x8020, + GLX_SAVED_SGIX = 0x8021; + + /** Returned in the {@code draw_type} field of a "buffer clobber" event. */ + public static final int + GLX_WINDOW_SGIX = 0x8022, + GLX_PBUFFER_SGIX = 0x8023; + + /** Returned in the {@code mask} field of a "buffer clobber" event. */ + public static final int + GLX_FRONT_LEFT_BUFFER_BIT_SGIX = 0x1, + GLX_FRONT_RIGHT_BUFFER_BIT_SGIX = 0x2, + GLX_BACK_LEFT_BUFFER_BIT_SGIX = 0x4, + GLX_BACK_RIGHT_BUFFER_BIT_SGIX = 0x8, + GLX_AUX_BUFFERS_BIT_SGIX = 0x10, + GLX_DEPTH_BUFFER_BIT_SGIX = 0x20, + GLX_STENCIL_BUFFER_BIT_SGIX = 0x40, + GLX_ACCUM_BUFFER_BIT_SGIX = 0x80, + GLX_SAMPLE_BUFFERS_BIT_SGIX = 0x100; + + protected GLXSGIXPbuffer() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXCreateGLXPbufferSGIX, caps.glXDestroyGLXPbufferSGIX, caps.glXQueryGLXPbufferSGIX, caps.glXSelectEventSGIX, caps.glXGetSelectedEventSGIX + ); + } + + // --- [ glXCreateGLXPbufferSGIX ] --- + + /** Unsafe version of: {@link #glXCreateGLXPbufferSGIX CreateGLXPbufferSGIX} */ + public static long nglXCreateGLXPbufferSGIX(long display, long config, int width, int height, long attrib_list) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCreateGLXPbufferSGIX; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + } + return callPPPP(display, config, width, height, attrib_list, __functionAddress); + } + + /** + * Creates a single GLXPbuffer and returns its XID. + * + * @param display the connection to the X server + * @param config the {@code GLXFBConfig} + * @param width the pbuffer width + * @param height the pbuffer height + * @param attrib_list an optional null-terminated list of attributes + */ + @NativeType("GLXPbuffer") + public static long glXCreateGLXPbufferSGIX(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config, @NativeType("unsigned int") int width, @NativeType("unsigned int") int height, @Nullable @NativeType("int *") IntBuffer attrib_list) { + if (CHECKS) { + checkNTSafe(attrib_list); + } + return nglXCreateGLXPbufferSGIX(display, config, width, height, memAddressSafe(attrib_list)); + } + + // --- [ glXDestroyGLXPbufferSGIX ] --- + + /** + * Destroys a GLXPbuffer. + * + * @param display the connection to the X server + * @param pbuf the pbuffer to destroy + */ + public static void glXDestroyGLXPbufferSGIX(@NativeType("Display *") long display, @NativeType("GLXPbuffer") long pbuf) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXDestroyGLXPbufferSGIX; + if (CHECKS) { + check(__functionAddress); + check(display); + check(pbuf); + } + callPPV(display, pbuf, __functionAddress); + } + + // --- [ glXQueryGLXPbufferSGIX ] --- + + /** Unsafe version of: {@link #glXQueryGLXPbufferSGIX QueryGLXPbufferSGIX} */ + public static void nglXQueryGLXPbufferSGIX(long display, long pbuf, int attribute, long value) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryGLXPbufferSGIX; + if (CHECKS) { + check(__functionAddress); + check(display); + check(pbuf); + } + callPPPV(display, pbuf, attribute, value, __functionAddress); + } + + /** + * Queries an attribute associated with a GLXPbuffer. + * + * @param display the connection to the X server + * @param pbuf the pbuffer being queried + * @param attribute the attribute to query + * @param value returns the attribute value + */ + public static void glXQueryGLXPbufferSGIX(@NativeType("Display *") long display, @NativeType("GLXPbuffer") long pbuf, int attribute, @NativeType("unsigned int *") IntBuffer value) { + if (CHECKS) { + check(value, 1); + } + nglXQueryGLXPbufferSGIX(display, pbuf, attribute, memAddress(value)); + } + + // --- [ glXSelectEventSGIX ] --- + + /** + * Selects which GLX events should be received on a GLXdrawable. + * + * @param display the connection to the X server + * @param drawable the GLXDrawable + * @param mask the selection mask + */ + public static void glXSelectEventSGIX(@NativeType("Display *") long display, @NativeType("GLXDrawable") long drawable, @NativeType("unsigned long") long mask) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXSelectEventSGIX; + if (CHECKS) { + check(__functionAddress); + check(display); + check(drawable); + } + callPPNV(display, drawable, mask, __functionAddress); + } + + // --- [ glXGetSelectedEventSGIX ] --- + + /** Unsafe version of: {@link #glXGetSelectedEventSGIX GetSelectedEventSGIX} */ + public static void nglXGetSelectedEventSGIX(long display, long drawable, long mask) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXGetSelectedEventSGIX; + if (CHECKS) { + check(__functionAddress); + check(display); + check(drawable); + } + callPPPV(display, drawable, mask, __functionAddress); + } + + /** + * Returns which GLX events are selected for a GLXdrawable. + * + * @param display the connection to the X server + * @param drawable the GLXDrawable + * @param mask returns the selection mask + */ + public static void glXGetSelectedEventSGIX(@NativeType("Display *") long display, @NativeType("GLXDrawable") long drawable, @NativeType("unsigned long *") CLongBuffer mask) { + if (CHECKS) { + check(mask, 1); + } + nglXGetSelectedEventSGIX(display, drawable, memAddress(mask)); + } + + /** Array version of: {@link #glXCreateGLXPbufferSGIX CreateGLXPbufferSGIX} */ + @NativeType("GLXPbuffer") + public static long glXCreateGLXPbufferSGIX(@NativeType("Display *") long display, @NativeType("GLXFBConfig") long config, @NativeType("unsigned int") int width, @NativeType("unsigned int") int height, @Nullable @NativeType("int *") int[] attrib_list) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXCreateGLXPbufferSGIX; + if (CHECKS) { + check(__functionAddress); + check(display); + check(config); + checkNTSafe(attrib_list); + } + return callPPPP(display, config, width, height, attrib_list, __functionAddress); + } + + /** Array version of: {@link #glXQueryGLXPbufferSGIX QueryGLXPbufferSGIX} */ + public static void glXQueryGLXPbufferSGIX(@NativeType("Display *") long display, @NativeType("GLXPbuffer") long pbuf, int attribute, @NativeType("unsigned int *") int[] value) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryGLXPbufferSGIX; + if (CHECKS) { + check(__functionAddress); + check(display); + check(pbuf); + check(value, 1); + } + callPPPV(display, pbuf, attribute, value, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIXSwapBarrier.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIXSwapBarrier.java new file mode 100644 index 00000000..6fd94473 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIXSwapBarrier.java @@ -0,0 +1,94 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the GLX_SGIX_swap_barrier extension. + * + *This extension provides the capability to sychronize the buffer swaps of different swap groups.
+ * + *Requires {@link GLXSGIXSwapGroup GLX_SGIX_swap_group}.
+ */ +public class GLXSGIXSwapBarrier { + + protected GLXSGIXSwapBarrier() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXBindSwapBarrierSGIX, caps.glXQueryMaxSwapBarriersSGIX + ); + } + + // --- [ glXBindSwapBarrierSGIX ] --- + + /** + * Binds the swap group that contains {@code drawable} to {@code barrier}. Subsequent buffer swaps for that group will be subject to this binding, until + * the group is unbound from {@code barrier}. If {@code barrier} is zero, the group is unbound from its current barrier, if any. + * + * @param display the connection to the X server + * @param drawable the swap group GLXDrawable + * @param barrier the swap barrier + */ + public static void glXBindSwapBarrierSGIX(@NativeType("Display *") long display, @NativeType("GLXDrawable") long drawable, int barrier) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXBindSwapBarrierSGIX; + if (CHECKS) { + check(__functionAddress); + check(display); + check(drawable); + } + callPPV(display, drawable, barrier, __functionAddress); + } + + // --- [ glXQueryMaxSwapBarriersSGIX ] --- + + /** Unsafe version of: {@link #glXQueryMaxSwapBarriersSGIX QueryMaxSwapBarriersSGIX} */ + public static int nglXQueryMaxSwapBarriersSGIX(long display, int screen, long max) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryMaxSwapBarriersSGIX; + if (CHECKS) { + check(__functionAddress); + check(display); + } + return callPPI(display, screen, max, __functionAddress); + } + + /** + * Returns in {@code max} the maximum number of barriers supported by an implementation on {@code screen}. + * + * @param display the connection to the X server + * @param screen the screen + * @param max returns the maximum number of barriers + */ + @NativeType("Bool") + public static boolean glXQueryMaxSwapBarriersSGIX(@NativeType("Display *") long display, int screen, @NativeType("int *") IntBuffer max) { + if (CHECKS) { + check(max, 1); + } + return nglXQueryMaxSwapBarriersSGIX(display, screen, memAddress(max)) != 0; + } + + /** Array version of: {@link #glXQueryMaxSwapBarriersSGIX QueryMaxSwapBarriersSGIX} */ + @NativeType("Bool") + public static boolean glXQueryMaxSwapBarriersSGIX(@NativeType("Display *") long display, int screen, @NativeType("int *") int[] max) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXQueryMaxSwapBarriersSGIX; + if (CHECKS) { + check(__functionAddress); + check(display); + check(max, 1); + } + return callPPI(display, screen, max, __functionAddress) != 0; + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIXSwapGroup.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIXSwapGroup.java new file mode 100644 index 00000000..b7978b51 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXSGIXSwapGroup.java @@ -0,0 +1,54 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** + * Native bindings to the GLX_SGIX_swap_group extension. + * + *This extension provides the capability to synchronize the buffer swaps of a group of GLX drawables. A swap group is created, and drawables are added as + * members to the swap group. Buffer swaps to members of the swap group will then take place concurrently.
+ * + *This extension extends the set of conditions that must be met before a buffer swap can take place.
+ */ +public class GLXSGIXSwapGroup { + + protected GLXSGIXSwapGroup() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLXCapabilities caps) { + return checkFunctions( + caps.glXJoinSwapGroupSGIX + ); + } + + // --- [ glXJoinSwapGroupSGIX ] --- + + /** + * Adds {@code drawable} to the swap group containing {@code member} as a member. If {@code drawable} is already a member of a different group, it is + * implicitly removed from that group first. If {@code member} is {@code None}, {@code drawable} is removed from the swap group that it belongs to, if + * any. + * + * @param display the connection to the X server + * @param drawable the GLXDrawable to add to the swap group + * @param member a member of the swap group or {@code None} + */ + public static void glXJoinSwapGroupSGIX(@NativeType("Display *") long display, @NativeType("GLXDrawable") long drawable, @NativeType("GLXDrawable") long member) { + long __functionAddress = GL.getCapabilitiesGLXClient().glXJoinSwapGroupSGIX; + if (CHECKS) { + check(__functionAddress); + check(display); + check(drawable); + } + callPPPV(display, drawable, member, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXStereoNotifyEventEXT.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXStereoNotifyEventEXT.java new file mode 100644 index 00000000..ef356e2b --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GLXStereoNotifyEventEXT.java @@ -0,0 +1,233 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; + +/** + *
+ * struct GLXStereoNotifyEventEXT {
+ * int type;
+ * unsigned long serial;
+ * Bool send_event;
+ * Display * display;
+ * int extension;
+ * int evtype;
+ * GLXDrawable window;
+ * Bool stereo_tree;
+ * }The created instance holds a strong reference to the container object.
+ */ + public GLXStereoNotifyEventEXT(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code type} field. */ + public int type() { return ntype(address()); } + /** Returns the value of the {@code serial} field. */ + @NativeType("unsigned long") + public long serial() { return nserial(address()); } + /** Returns the value of the {@code send_event} field. */ + @NativeType("Bool") + public boolean send_event() { return nsend_event(address()) != 0; } + /** Returns the value of the {@code display} field. */ + @NativeType("Display *") + public long display() { return ndisplay(address()); } + /** Returns the value of the {@code extension} field. */ + public int extension() { return nextension(address()); } + /** Returns the value of the {@code evtype} field. */ + public int evtype() { return nevtype(address()); } + /** Returns the value of the {@code window} field. */ + @NativeType("GLXDrawable") + public long window() { return nwindow(address()); } + /** Returns the value of the {@code stereo_tree} field. */ + @NativeType("Bool") + public boolean stereo_tree() { return nstereo_tree(address()) != 0; } + + // ----------------------------------- + + /** Returns a new {@code GLXStereoNotifyEventEXT} instance for the specified memory address. */ + public static GLXStereoNotifyEventEXT create(long address) { + return wrap(GLXStereoNotifyEventEXT.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static GLXStereoNotifyEventEXT createSafe(long address) { + return address == NULL ? null : wrap(GLXStereoNotifyEventEXT.class, address); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #type}. */ + public static int ntype(long struct) { return UNSAFE.getInt(null, struct + GLXStereoNotifyEventEXT.TYPE); } + /** Unsafe version of {@link #serial}. */ + public static long nserial(long struct) { return memGetCLong(struct + GLXStereoNotifyEventEXT.SERIAL); } + /** Unsafe version of {@link #send_event}. */ + public static int nsend_event(long struct) { return UNSAFE.getInt(null, struct + GLXStereoNotifyEventEXT.SEND_EVENT); } + /** Unsafe version of {@link #display}. */ + public static long ndisplay(long struct) { return memGetAddress(struct + GLXStereoNotifyEventEXT.DISPLAY); } + /** Unsafe version of {@link #extension}. */ + public static int nextension(long struct) { return UNSAFE.getInt(null, struct + GLXStereoNotifyEventEXT.EXTENSION); } + /** Unsafe version of {@link #evtype}. */ + public static int nevtype(long struct) { return UNSAFE.getInt(null, struct + GLXStereoNotifyEventEXT.EVTYPE); } + /** Unsafe version of {@link #window}. */ + public static long nwindow(long struct) { return memGetAddress(struct + GLXStereoNotifyEventEXT.WINDOW); } + /** Unsafe version of {@link #stereo_tree}. */ + public static int nstereo_tree(long struct) { return UNSAFE.getInt(null, struct + GLXStereoNotifyEventEXT.STEREO_TREE); } + + // ----------------------------------- + + /** An array of {@link GLXStereoNotifyEventEXT} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected GLXStereoNotifyEventEXT getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code type} field. */ + public int type() { return GLXStereoNotifyEventEXT.ntype(address()); } + /** Returns the value of the {@code serial} field. */ + @NativeType("unsigned long") + public long serial() { return GLXStereoNotifyEventEXT.nserial(address()); } + /** Returns the value of the {@code send_event} field. */ + @NativeType("Bool") + public boolean send_event() { return GLXStereoNotifyEventEXT.nsend_event(address()) != 0; } + /** Returns the value of the {@code display} field. */ + @NativeType("Display *") + public long display() { return GLXStereoNotifyEventEXT.ndisplay(address()); } + /** Returns the value of the {@code extension} field. */ + public int extension() { return GLXStereoNotifyEventEXT.nextension(address()); } + /** Returns the value of the {@code evtype} field. */ + public int evtype() { return GLXStereoNotifyEventEXT.nevtype(address()); } + /** Returns the value of the {@code window} field. */ + @NativeType("GLXDrawable") + public long window() { return GLXStereoNotifyEventEXT.nwindow(address()); } + /** Returns the value of the {@code stereo_tree} field. */ + @NativeType("Bool") + public boolean stereo_tree() { return GLXStereoNotifyEventEXT.nstereo_tree(address()) != 0; } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GPU_DEVICE.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GPU_DEVICE.java new file mode 100644 index 00000000..7f7e9f3d --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GPU_DEVICE.java @@ -0,0 +1,339 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.MemoryStack.*; + +import org.lwjgl.system.windows.*; + +/** + * Receives information about the display device specified by the {@code deviceIndex} parameter of the {@link WGLNVGPUAffinity#wglEnumGpuDevicesNV EnumGpuDevicesNV} function. + * + *
+ * struct GPU_DEVICE {
+ * DWORD cb;
+ * CHAR DeviceName[32];
+ * CHAR DeviceString[128];
+ * DWORD Flags;
+ * {@link RECT RECT} rcVirtualScreen;
+ * }The created instance holds a strong reference to the container object.
+ */ + public GPU_DEVICE(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code cb} field. */ + @NativeType("DWORD") + public int cb() { return ncb(address()); } + /** Returns a {@link ByteBuffer} view of the {@code DeviceName} field. */ + @NativeType("CHAR[32]") + public ByteBuffer DeviceName() { return nDeviceName(address()); } + /** Decodes the null-terminated string stored in the {@code DeviceName} field. */ + @NativeType("CHAR[32]") + public String DeviceNameString() { return nDeviceNameString(address()); } + /** Returns a {@link ByteBuffer} view of the {@code DeviceString} field. */ + @NativeType("CHAR[128]") + public ByteBuffer DeviceString() { return nDeviceString(address()); } + /** Decodes the null-terminated string stored in the {@code DeviceString} field. */ + @NativeType("CHAR[128]") + public String DeviceStringString() { return nDeviceStringString(address()); } + /** Returns the value of the {@code Flags} field. */ + @NativeType("DWORD") + public int Flags() { return nFlags(address()); } + /** Returns a {@link RECT} view of the {@code rcVirtualScreen} field. */ + public RECT rcVirtualScreen() { return nrcVirtualScreen(address()); } + + // ----------------------------------- + + /** Returns a new {@code GPU_DEVICE} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static GPU_DEVICE malloc() { + return wrap(GPU_DEVICE.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code GPU_DEVICE} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static GPU_DEVICE calloc() { + return wrap(GPU_DEVICE.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code GPU_DEVICE} instance allocated with {@link BufferUtils}. */ + public static GPU_DEVICE create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(GPU_DEVICE.class, memAddress(container), container); + } + + /** Returns a new {@code GPU_DEVICE} instance for the specified memory address. */ + public static GPU_DEVICE create(long address) { + return wrap(GPU_DEVICE.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static GPU_DEVICE createSafe(long address) { + return address == NULL ? null : wrap(GPU_DEVICE.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code GPU_DEVICE} instance allocated on the thread-local {@link MemoryStack}. */ + public static GPU_DEVICE mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code GPU_DEVICE} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static GPU_DEVICE callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code GPU_DEVICE} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static GPU_DEVICE mallocStack(MemoryStack stack) { + return wrap(GPU_DEVICE.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code GPU_DEVICE} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static GPU_DEVICE callocStack(MemoryStack stack) { + return wrap(GPU_DEVICE.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #cb}. */ + public static int ncb(long struct) { return UNSAFE.getInt(null, struct + GPU_DEVICE.CB); } + /** Unsafe version of {@link #DeviceName}. */ + public static ByteBuffer nDeviceName(long struct) { return memByteBuffer(struct + GPU_DEVICE.DEVICENAME, 32); } + /** Unsafe version of {@link #DeviceNameString}. */ + public static String nDeviceNameString(long struct) { return memASCII(struct + GPU_DEVICE.DEVICENAME); } + /** Unsafe version of {@link #DeviceString}. */ + public static ByteBuffer nDeviceString(long struct) { return memByteBuffer(struct + GPU_DEVICE.DEVICESTRING, 128); } + /** Unsafe version of {@link #DeviceStringString}. */ + public static String nDeviceStringString(long struct) { return memASCII(struct + GPU_DEVICE.DEVICESTRING); } + /** Unsafe version of {@link #Flags}. */ + public static int nFlags(long struct) { return UNSAFE.getInt(null, struct + GPU_DEVICE.FLAGS); } + /** Unsafe version of {@link #rcVirtualScreen}. */ + public static RECT nrcVirtualScreen(long struct) { return RECT.create(struct + GPU_DEVICE.RCVIRTUALSCREEN); } + + // ----------------------------------- + + /** An array of {@link GPU_DEVICE} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected GPU_DEVICE getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code cb} field. */ + @NativeType("DWORD") + public int cb() { return GPU_DEVICE.ncb(address()); } + /** Returns a {@link ByteBuffer} view of the {@code DeviceName} field. */ + @NativeType("CHAR[32]") + public ByteBuffer DeviceName() { return GPU_DEVICE.nDeviceName(address()); } + /** Decodes the null-terminated string stored in the {@code DeviceName} field. */ + @NativeType("CHAR[32]") + public String DeviceNameString() { return GPU_DEVICE.nDeviceNameString(address()); } + /** Returns a {@link ByteBuffer} view of the {@code DeviceString} field. */ + @NativeType("CHAR[128]") + public ByteBuffer DeviceString() { return GPU_DEVICE.nDeviceString(address()); } + /** Decodes the null-terminated string stored in the {@code DeviceString} field. */ + @NativeType("CHAR[128]") + public String DeviceStringString() { return GPU_DEVICE.nDeviceStringString(address()); } + /** Returns the value of the {@code Flags} field. */ + @NativeType("DWORD") + public int Flags() { return GPU_DEVICE.nFlags(address()); } + /** Returns a {@link RECT} view of the {@code rcVirtualScreen} field. */ + public RECT rcVirtualScreen() { return GPU_DEVICE.nrcVirtualScreen(address()); } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GREMEDYFrameTerminator.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GREMEDYFrameTerminator.java new file mode 100644 index 00000000..14bd4001 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GREMEDYFrameTerminator.java @@ -0,0 +1,51 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the GREMEDY_frame_terminator extension. + * + *This extension defines a mechanism that enables marking the end of render frames within the OpenGL stream.
+ * + *When debugging or profiling an OpenGL application, the debuggers and profilers needs to know when a render frame is ended. This is important for frame + * per second measurements, statistical analysis, marking and clearing stream loggers logs, performance counters sampling and more.
+ * + *When an application uses off screen buffers, the debugger / profiler cannot be guaranteed that the application will call a certain function at the end + * of each off-screen frame (e.g: SwapBuffers / glClear / etc). This extension enables the application to notify the debugger / profiler whenever a render + * frame is ended.
+ * + *This extension is mainly useful for debuggers and profilers. It is not expected that standard drivers would implement this extension. The main point of + * having this extension is to allow applications to have a clean way of accessing this functionality only when they are run under the control of a + * debugger / profiler, without having to recompile or change the application source code.
+ */ +public class GREMEDYFrameTerminator { + + static { GL.initialize(); } + + protected GREMEDYFrameTerminator() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glFrameTerminatorGREMEDY + ); + } + + // --- [ glFrameTerminatorGREMEDY ] --- + + /** + * Can be used to insert a frame terminator marker into the command stream. This frame terminator marker can be used by appropriate debugging tools / + * profiling tools / profiling drivers for frame per second measurements, statistical analysis, marking and clearing stream loggers logs, performance + * counters sampling and more. This command has no influence on the rendered image or the OpenGL state. + */ + public static native void glFrameTerminatorGREMEDY(); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GREMEDYStringMarker.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GREMEDYStringMarker.java new file mode 100644 index 00000000..38c4d9ee --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/GREMEDYStringMarker.java @@ -0,0 +1,83 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the GREMEDY_string_marker extension. + * + *This extension defines a mechanism to insert textual markers into the OpenGL stream.
+ * + *When debugging or profiling an OpenGL application some of the most important tools are stream loggers, which just output a list of the called OpenGL + * commands, and profilers, which show at which points the pipeline is bottlenecked for a given part of the frame. The problem in using these is that + * there is a definite loss of information between the application and the used debugger/profiler. The application generally has a pretty good idea what + * is rendered when (e.g. rendering background, landscape, building, players, particle effects, bullets etc.), but the debugger/profiler only sees the + * OpenGL stream. To analyze the stream developers have to guess what is done when by following the program code and the log output in parallel, which can + * get difficult for systems that restructure their internal pipeline or do lazy changes.
+ * + *This extension is really only useful for these debuggers and profilers, and not for actual drivers. In fact, it is not expected that any standard + * driver would ever implement this extension. The main point of having this extension is to allow applications to have a clean way of accessing this + * functionality only when they are run under the control of a debugger/profiler, without having to recompile or change the application source code.
+ */ +public class GREMEDYStringMarker { + + static { GL.initialize(); } + + protected GREMEDYStringMarker() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glStringMarkerGREMEDY + ); + } + + // --- [ glStringMarkerGREMEDY ] --- + + /** + * Unsafe version of: {@link #glStringMarkerGREMEDY StringMarkerGREMEDY} + * + * @param len the length of the array. If {@code string} is null-terminated, {@code len} should not include the terminator. If {@code len} is 0, then the string + * is assumed to be null-terminated. + */ + public static native void nglStringMarkerGREMEDY(int len, long string); + + /** + * Can be used to insert arbitrary marker strings into the command stream that can be recorded by appropriate debugging tools / profiling tools / drivers. + * They have no influence on the rendered image or the OpenGL state. + * + * @param string a pointer to the array of bytes representing the marker being inserted, which need not be null-terminated + */ + public static void glStringMarkerGREMEDY(@NativeType("GLchar const *") ByteBuffer string) { + nglStringMarkerGREMEDY(string.remaining(), memAddress(string)); + } + + /** + * Can be used to insert arbitrary marker strings into the command stream that can be recorded by appropriate debugging tools / profiling tools / drivers. + * They have no influence on the rendered image or the OpenGL state. + * + * @param string a pointer to the array of bytes representing the marker being inserted, which need not be null-terminated + */ + public static void glStringMarkerGREMEDY(@NativeType("GLchar const *") CharSequence string) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + int stringEncodedLength = stack.nUTF8(string, false); + long stringEncoded = stack.getPointerAddress(); + nglStringMarkerGREMEDY(stringEncodedLength, stringEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/INTELBlackholeRender.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/INTELBlackholeRender.java new file mode 100644 index 00000000..963fb2e5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/INTELBlackholeRender.java @@ -0,0 +1,28 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the INTEL_blackhole_render extension. + * + *The purpose of this extension is to allow an application to disable all rendering operations emitted to the GPU through the OpenGL rendering commands + * ({@code Draw*}, {@code DispatchCompute*}, {@code BlitFramebuffer}, etc...). Changes to the OpenGL pipeline are not affected.
+ * + *New preprocessor {@code #defines} are added to the OpenGL Shading Language:
+ * + *
+ * #define GL_INTEL_blackhole_render 1Requires {@link GL30 OpenGL 3.0}.
+ */ +public final class INTELBlackholeRender { + + /** Accepted by the {@code target} parameter of Enable, Disable, IsEnabled. */ + public static final int GL_BLACKHOLE_RENDER_INTEL = 0x83FC; + + private INTELBlackholeRender() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/INTELConservativeRasterization.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/INTELConservativeRasterization.java new file mode 100644 index 00000000..467e757c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/INTELConservativeRasterization.java @@ -0,0 +1,31 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the INTEL_conservative_rasterization extension. + * + *Regular rasterization includes fragments with at least one sample covered by a polygon. Conservative rasterization includes all fragments that are at + * least partially covered by the polygon.
+ * + *In some use cases, it is also important to know if a fragment is fully covered by a polygon, i.e. if all parts of the fragment are within the polygon. + * An application may, for example, want to process fully covered fragments different from the "edge" pixels. This extension adds an option for the + * fragment shader to receive this information via {@code gl_SampleMaskIn[]}.
+ * + *This extension affects only polygons in {@link GL11#GL_FILL FILL} mode and specifically does not imply any changes in processing of lines or points.
+ * + *Conservative rasterization automatically disables polygon antialiasing rasterization if enabled by {@link GL11#GL_POLYGON_SMOOTH POLYGON_SMOOTH}.
+ * + *Requires {@link GL42 OpenGL 4.2}.
+ */ +public final class INTELConservativeRasterization { + + /** Accepted by the {@code target} parameter of {@link GL11#glEnable Enable}, {@link GL11#glDisable Disable}, {@link GL11#glIsEnabled IsEnabled}. */ + public static final int GL_CONSERVATIVE_RASTERIZATION_INTEL = 0x83FE; + + private INTELConservativeRasterization() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/INTELFramebufferCMAA.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/INTELFramebufferCMAA.java new file mode 100644 index 00000000..f4c3558c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/INTELFramebufferCMAA.java @@ -0,0 +1,51 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the INTEL_framebuffer_CMAA extension. + * + *Multisampling is a mechanism to antialias all GL primitives and is part of the GL specification.
+ * + *Better visual quality can be achieved by applying multisampling. However, on certain platforms it comes at a high performance cost. In general, the + * greater number of samples per pixel, the bigger the cost.
+ * + *Conservative Morphological Anti-Aliasing (CMAA) is an alternative approach to antialiasing, which operates on the final image. This post processing + * technique results in image quality comparable to multisampling at much lower cost and better performance.
+ * + *This extension incorporates an optimized CMAA algorithm implementation into the GL implementation.
+ * + *For more information on CMAA refer to software.intel.com.
+ * + *Requires {@link GL30 OpenGL 3.0}.
+ */ +public class INTELFramebufferCMAA { + + static { GL.initialize(); } + + protected INTELFramebufferCMAA() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glApplyFramebufferAttachmentCMAAINTEL + ); + } + + // --- [ glApplyFramebufferAttachmentCMAAINTEL ] --- + + /** + * Requests the post processing of current draw buffers pertaining to the framebuffer bound to the {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} target according to the + * Conservative Morphological Anti-Aliasing algorithm. + */ + public static native void glApplyFramebufferAttachmentCMAAINTEL(); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/INTELMapTexture.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/INTELMapTexture.java new file mode 100644 index 00000000..e74f02a6 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/INTELMapTexture.java @@ -0,0 +1,209 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.APIUtil.*; +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the INTEL_map_texture extension. + * + *Systems with integrated GPUs can share the same physical memory between CPU and GPU. This feature, if exposed by API, can bring significant performance + * benefits for graphics applications by reducing the complexity of uploading/accessing texture contents. This extension enables CPU direct access to the + * GPU memory holding textures.
+ * + *The problem with texture memory directly exposed to clients is that textures are often 'tiled'. Texels are kept in specific layout to improve locality + * of reference and thus performance of texturing. This 'tiling' is specific to particular hardware and would be thus difficult to use.
+ * + *This extension allows to create textures with 'linear' layout which allows for simplified access on user side (potentially sacrificing some performance + * during texture sampling).
+ * + *Requires {@link GL30 OpenGL 3.0}.
+ */ +public class INTELMapTexture { + + /** Accepted by the {@code pname} parameter of TexParameteri, for target TEXTURE_2D. */ + public static final int GL_TEXTURE_MEMORY_LAYOUT_INTEL = 0x83FF; + + /** Accepted by the {@code params} when {@code pname} is set to {@code TEXTURE_MEMORY_LAYOUT_INTEL}. */ + public static final int + GL_LAYOUT_DEFAULT_INTEL = 0, + GL_LAYOUT_LINEAR_INTEL = 1, + GL_LAYOUT_LINEAR_CPU_CACHED_INTEL = 2; + + static { GL.initialize(); } + + protected INTELMapTexture() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glSyncTextureINTEL, caps.glUnmapTexture2DINTEL, caps.glMapTexture2DINTEL + ); + } + + // --- [ glSyncTextureINTEL ] --- + + /** + * Makes sure that changes made by CPU are visible to GPU by flushing texture cache in GPU. The GL implementation tracks the cache usage and ignores the + * command if such flush is not needed. + * + *It is worth noting that this extension does not address automatic synchronization between CPU and GPU when both entities operate on the same texture at + * the same time. This is up to the application to assure such synchronization. Otherwise, the results may not be deterministic (writes from different + * entities may interleave in a non-deterministic way).
+ * + * @param texture the texture to synchronize + */ + public static native void glSyncTextureINTEL(@NativeType("GLuint") int texture); + + // --- [ glUnmapTexture2DINTEL ] --- + + /** + * Releases the pointer obtained previously via {@link #glMapTexture2DINTEL MapTexture2DINTEL}. This means that virtual memory space dedicated to make the texture available via a + * pointer is released and an application can no longer assume this memory is accessible from CPU. Successful execution of this command has an additional + * effect as if {@link #glSyncTextureINTEL SyncTextureINTEL} was called with {@code texture} parameter. + * + * @param texture the texture to unmap + * @param level the mipmap level-of-detail of the texture + */ + public static native void glUnmapTexture2DINTEL(@NativeType("GLuint") int texture, @NativeType("GLint") int level); + + // --- [ glMapTexture2DINTEL ] --- + + /** Unsafe version of: {@link #glMapTexture2DINTEL MapTexture2DINTEL} */ + public static native long nglMapTexture2DINTEL(int texture, int level, int access, long stride, long layout); + + /** + * Attempts to return a direct pointer to the graphics storage for 2D texture indicated by the {@code texture} parameter. + * + *LWJGL note: If glMapTexture2DINTEL without an explicit length argument is used and direct-state-access functionality is not available in the + * current context, the texture object must currently be bound to the GL_TEXTURE_2D target.
+ * + * @param texture the texture to map + * @param level the mipmap level-of-detail of the texture + * @param access the type of access that will be performed by the application. One of:| {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} | {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT} |
LWJGL note: If glMapTexture2DINTEL without an explicit length argument is used and direct-state-access functionality is not available in the + * current context, the texture object must currently be bound to the GL_TEXTURE_2D target.
+ * + * @param texture the texture to map + * @param level the mipmap level-of-detail of the texture + * @param access the type of access that will be performed by the application. One of:| {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} | {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT} |
LWJGL note: If glMapTexture2DINTEL without an explicit length argument is used and direct-state-access functionality is not available in the + * current context, the texture object must currently be bound to the GL_TEXTURE_2D target.
+ * + * @param texture the texture to map + * @param level the mipmap level-of-detail of the texture + * @param access the type of access that will be performed by the application. One of:| {@link GL30#GL_MAP_READ_BIT MAP_READ_BIT} | {@link GL30#GL_MAP_WRITE_BIT MAP_WRITE_BIT} |
The purpose of this extension is to expose Intel proprietary hardware performance counters to the OpenGL applications. Performance counters may count:
+ * + *This extension specifies universal API to manage performance counters on different Intel hardware platforms. Performance counters are grouped together + * into proprietary, hardware-specific, fixed sets of counters that are measured together by the GPU.
+ * + *It is assumed that performance counters are started and ended on any arbitrary boundaries during rendering.
+ * + *A set of performance counters is represented by a unique query type. Each query type is identified by assigned name and ID. Multiple query types (sets + * of performance counters) are supported by the Intel hardware. However each Intel hardware generation supports different sets of performance counters. + * Therefore the query types between hardware generations can be different. The definition of query types and their results structures can be learned + * through the API. It is also documented in a separate document of Intel OGL Performance Counters Specification issued per each new hardware generation.
+ * + *The API allows to create multiple instances of any query type and to sample different fragments of 3D rendering with such instances. Query instances + * are identified with handles.
+ * + *Requires {@link GL30 OpenGL 3.0}.
+ */ +public class INTELPerformanceQuery { + + /** Returned by the capsMask parameter of GetPerfQueryInfoINTEL. */ + public static final int + GL_PERFQUERY_SINGLE_CONTEXT_INTEL = 0x0, + GL_PERFQUERY_GLOBAL_CONTEXT_INTEL = 0x1; + + /** Accepted by the flags parameter of GetPerfQueryDataINTEL. */ + public static final int + GL_PERFQUERY_WAIT_INTEL = 0x83FB, + GL_PERFQUERY_FLUSH_INTEL = 0x83FA, + GL_PERFQUERY_DONOT_FLUSH_INTEL = 0x83F9; + + /** Returned by GetPerfCounterInfoINTEL function as counter type enumeration in location pointed by counterTypeEnum. */ + public static final int + GL_PERFQUERY_COUNTER_EVENT_INTEL = 0x94F0, + GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL = 0x94F1, + GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL = 0x94F2, + GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL = 0x94F3, + GL_PERFQUERY_COUNTER_RAW_INTEL = 0x94F4, + GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL = 0x94F5; + + /** Returned by glGetPerfCounterInfoINTEL function as counter data type enumeration in location pointed by counterDataTypeEnum. */ + public static final int + GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL = 0x94F8, + GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL = 0x94F9, + GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL = 0x94FA, + GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL = 0x94FB, + GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL = 0x94FC; + + /** Accepted by the {@code pname} parameter of GetIntegerv. */ + public static final int + GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL = 0x94FD, + GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL = 0x94FE, + GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL = 0x94FF; + + /** Accepted by the {@code pname} parameter of GetBooleanv. */ + public static final int GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL = 0x9500; + + static { GL.initialize(); } + + protected INTELPerformanceQuery() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBeginPerfQueryINTEL, caps.glCreatePerfQueryINTEL, caps.glDeletePerfQueryINTEL, caps.glEndPerfQueryINTEL, caps.glGetFirstPerfQueryIdINTEL, + caps.glGetNextPerfQueryIdINTEL, caps.glGetPerfCounterInfoINTEL, caps.glGetPerfQueryDataINTEL, caps.glGetPerfQueryIdByNameINTEL, + caps.glGetPerfQueryInfoINTEL + ); + } + + // --- [ glBeginPerfQueryINTEL ] --- + + public static native void glBeginPerfQueryINTEL(@NativeType("GLuint") int queryHandle); + + // --- [ glCreatePerfQueryINTEL ] --- + + public static native void nglCreatePerfQueryINTEL(int queryId, long queryHandle); + + public static void glCreatePerfQueryINTEL(@NativeType("GLuint") int queryId, @NativeType("GLuint *") IntBuffer queryHandle) { + if (CHECKS) { + check(queryHandle, 1); + } + nglCreatePerfQueryINTEL(queryId, memAddress(queryHandle)); + } + + @NativeType("void") + public static int glCreatePerfQueryINTEL(@NativeType("GLuint") int queryId) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer queryHandle = stack.callocInt(1); + nglCreatePerfQueryINTEL(queryId, memAddress(queryHandle)); + return queryHandle.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glDeletePerfQueryINTEL ] --- + + public static native void glDeletePerfQueryINTEL(@NativeType("GLuint") int queryHandle); + + // --- [ glEndPerfQueryINTEL ] --- + + public static native void glEndPerfQueryINTEL(@NativeType("GLuint") int queryHandle); + + // --- [ glGetFirstPerfQueryIdINTEL ] --- + + public static native void nglGetFirstPerfQueryIdINTEL(long queryId); + + public static void glGetFirstPerfQueryIdINTEL(@NativeType("GLuint *") IntBuffer queryId) { + if (CHECKS) { + check(queryId, 1); + } + nglGetFirstPerfQueryIdINTEL(memAddress(queryId)); + } + + @NativeType("void") + public static int glGetFirstPerfQueryIdINTEL() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer queryId = stack.callocInt(1); + nglGetFirstPerfQueryIdINTEL(memAddress(queryId)); + return queryId.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetNextPerfQueryIdINTEL ] --- + + public static native void nglGetNextPerfQueryIdINTEL(int queryId, long nextQueryId); + + public static void glGetNextPerfQueryIdINTEL(@NativeType("GLuint") int queryId, @NativeType("GLuint *") IntBuffer nextQueryId) { + if (CHECKS) { + check(nextQueryId, 1); + } + nglGetNextPerfQueryIdINTEL(queryId, memAddress(nextQueryId)); + } + + @NativeType("void") + public static int glGetNextPerfQueryIdINTEL(@NativeType("GLuint") int queryId) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer nextQueryId = stack.callocInt(1); + nglGetNextPerfQueryIdINTEL(queryId, memAddress(nextQueryId)); + return nextQueryId.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetPerfCounterInfoINTEL ] --- + + public static native void nglGetPerfCounterInfoINTEL(int queryId, int counterId, int counterNameLength, long counterName, int counterDescLength, long counterDesc, long counterOffset, long counterDataSize, long counterTypeEnum, long counterDataTypeEnum, long rawCounterMaxValue); + + public static void glGetPerfCounterInfoINTEL(@NativeType("GLuint") int queryId, @NativeType("GLuint") int counterId, @NativeType("GLchar *") ByteBuffer counterName, @NativeType("GLchar *") ByteBuffer counterDesc, @NativeType("GLuint *") IntBuffer counterOffset, @NativeType("GLuint *") IntBuffer counterDataSize, @NativeType("GLuint *") IntBuffer counterTypeEnum, @NativeType("GLuint *") IntBuffer counterDataTypeEnum, @NativeType("GLuint64 *") LongBuffer rawCounterMaxValue) { + if (CHECKS) { + check(counterOffset, 1); + check(counterDataSize, 1); + check(counterTypeEnum, 1); + check(counterDataTypeEnum, 1); + check(rawCounterMaxValue, 1); + } + nglGetPerfCounterInfoINTEL(queryId, counterId, counterName.remaining(), memAddress(counterName), counterDesc.remaining(), memAddress(counterDesc), memAddress(counterOffset), memAddress(counterDataSize), memAddress(counterTypeEnum), memAddress(counterDataTypeEnum), memAddress(rawCounterMaxValue)); + } + + // --- [ glGetPerfQueryDataINTEL ] --- + + public static native void nglGetPerfQueryDataINTEL(int queryHandle, int flags, int dataSize, long data, long bytesWritten); + + public static void glGetPerfQueryDataINTEL(@NativeType("GLuint") int queryHandle, @NativeType("GLuint") int flags, @NativeType("void *") ByteBuffer data, @NativeType("GLuint *") IntBuffer bytesWritten) { + if (CHECKS) { + check(bytesWritten, 1); + } + nglGetPerfQueryDataINTEL(queryHandle, flags, data.remaining(), memAddress(data), memAddress(bytesWritten)); + } + + // --- [ glGetPerfQueryIdByNameINTEL ] --- + + public static native void nglGetPerfQueryIdByNameINTEL(long queryName, long queryId); + + public static void glGetPerfQueryIdByNameINTEL(@NativeType("GLchar *") ByteBuffer queryName, @NativeType("GLuint *") IntBuffer queryId) { + if (CHECKS) { + checkNT1(queryName); + check(queryId, 1); + } + nglGetPerfQueryIdByNameINTEL(memAddress(queryName), memAddress(queryId)); + } + + public static void glGetPerfQueryIdByNameINTEL(@NativeType("GLchar *") CharSequence queryName, @NativeType("GLuint *") IntBuffer queryId) { + if (CHECKS) { + check(queryId, 1); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nASCII(queryName, true); + long queryNameEncoded = stack.getPointerAddress(); + nglGetPerfQueryIdByNameINTEL(queryNameEncoded, memAddress(queryId)); + } finally { + stack.setPointer(stackPointer); + } + } + + @NativeType("void") + public static int glGetPerfQueryIdByNameINTEL(@NativeType("GLchar *") CharSequence queryName) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nASCII(queryName, true); + long queryNameEncoded = stack.getPointerAddress(); + IntBuffer queryId = stack.callocInt(1); + nglGetPerfQueryIdByNameINTEL(queryNameEncoded, memAddress(queryId)); + return queryId.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetPerfQueryInfoINTEL ] --- + + public static native void nglGetPerfQueryInfoINTEL(int queryId, int queryNameLength, long queryName, long dataSize, long noCounters, long noInstances, long capsMask); + + public static void glGetPerfQueryInfoINTEL(@NativeType("GLuint") int queryId, @NativeType("GLchar *") ByteBuffer queryName, @NativeType("GLuint *") IntBuffer dataSize, @NativeType("GLuint *") IntBuffer noCounters, @NativeType("GLuint *") IntBuffer noInstances, @NativeType("GLuint *") IntBuffer capsMask) { + if (CHECKS) { + check(dataSize, 1); + check(noCounters, 1); + check(noInstances, 1); + check(capsMask, 1); + } + nglGetPerfQueryInfoINTEL(queryId, queryName.remaining(), memAddress(queryName), memAddress(dataSize), memAddress(noCounters), memAddress(noInstances), memAddress(capsMask)); + } + + /** Array version of: {@link #glCreatePerfQueryINTEL CreatePerfQueryINTEL} */ + public static void glCreatePerfQueryINTEL(@NativeType("GLuint") int queryId, @NativeType("GLuint *") int[] queryHandle) { + long __functionAddress = GL.getICD().glCreatePerfQueryINTEL; + if (CHECKS) { + check(__functionAddress); + check(queryHandle, 1); + } + callPV(queryId, queryHandle, __functionAddress); + } + + /** Array version of: {@link #glGetFirstPerfQueryIdINTEL GetFirstPerfQueryIdINTEL} */ + public static void glGetFirstPerfQueryIdINTEL(@NativeType("GLuint *") int[] queryId) { + long __functionAddress = GL.getICD().glGetFirstPerfQueryIdINTEL; + if (CHECKS) { + check(__functionAddress); + check(queryId, 1); + } + callPV(queryId, __functionAddress); + } + + /** Array version of: {@link #glGetNextPerfQueryIdINTEL GetNextPerfQueryIdINTEL} */ + public static void glGetNextPerfQueryIdINTEL(@NativeType("GLuint") int queryId, @NativeType("GLuint *") int[] nextQueryId) { + long __functionAddress = GL.getICD().glGetNextPerfQueryIdINTEL; + if (CHECKS) { + check(__functionAddress); + check(nextQueryId, 1); + } + callPV(queryId, nextQueryId, __functionAddress); + } + + /** Array version of: {@link #glGetPerfCounterInfoINTEL GetPerfCounterInfoINTEL} */ + public static void glGetPerfCounterInfoINTEL(@NativeType("GLuint") int queryId, @NativeType("GLuint") int counterId, @NativeType("GLchar *") ByteBuffer counterName, @NativeType("GLchar *") ByteBuffer counterDesc, @NativeType("GLuint *") int[] counterOffset, @NativeType("GLuint *") int[] counterDataSize, @NativeType("GLuint *") int[] counterTypeEnum, @NativeType("GLuint *") int[] counterDataTypeEnum, @NativeType("GLuint64 *") long[] rawCounterMaxValue) { + long __functionAddress = GL.getICD().glGetPerfCounterInfoINTEL; + if (CHECKS) { + check(__functionAddress); + check(counterOffset, 1); + check(counterDataSize, 1); + check(counterTypeEnum, 1); + check(counterDataTypeEnum, 1); + check(rawCounterMaxValue, 1); + } + callPPPPPPPV(queryId, counterId, counterName.remaining(), memAddress(counterName), counterDesc.remaining(), memAddress(counterDesc), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue, __functionAddress); + } + + /** Array version of: {@link #glGetPerfQueryDataINTEL GetPerfQueryDataINTEL} */ + public static void glGetPerfQueryDataINTEL(@NativeType("GLuint") int queryHandle, @NativeType("GLuint") int flags, @NativeType("void *") ByteBuffer data, @NativeType("GLuint *") int[] bytesWritten) { + long __functionAddress = GL.getICD().glGetPerfQueryDataINTEL; + if (CHECKS) { + check(__functionAddress); + check(bytesWritten, 1); + } + callPPV(queryHandle, flags, data.remaining(), memAddress(data), bytesWritten, __functionAddress); + } + + /** Array version of: {@link #glGetPerfQueryIdByNameINTEL GetPerfQueryIdByNameINTEL} */ + public static void glGetPerfQueryIdByNameINTEL(@NativeType("GLchar *") ByteBuffer queryName, @NativeType("GLuint *") int[] queryId) { + long __functionAddress = GL.getICD().glGetPerfQueryIdByNameINTEL; + if (CHECKS) { + check(__functionAddress); + checkNT1(queryName); + check(queryId, 1); + } + callPPV(memAddress(queryName), queryId, __functionAddress); + } + + /** Array version of: {@link #glGetPerfQueryIdByNameINTEL GetPerfQueryIdByNameINTEL} */ + public static void glGetPerfQueryIdByNameINTEL(@NativeType("GLchar *") CharSequence queryName, @NativeType("GLuint *") int[] queryId) { + long __functionAddress = GL.getICD().glGetPerfQueryIdByNameINTEL; + if (CHECKS) { + check(__functionAddress); + check(queryId, 1); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nASCII(queryName, true); + long queryNameEncoded = stack.getPointerAddress(); + callPPV(queryNameEncoded, queryId, __functionAddress); + } finally { + stack.setPointer(stackPointer); + } + } + + /** Array version of: {@link #glGetPerfQueryInfoINTEL GetPerfQueryInfoINTEL} */ + public static void glGetPerfQueryInfoINTEL(@NativeType("GLuint") int queryId, @NativeType("GLchar *") ByteBuffer queryName, @NativeType("GLuint *") int[] dataSize, @NativeType("GLuint *") int[] noCounters, @NativeType("GLuint *") int[] noInstances, @NativeType("GLuint *") int[] capsMask) { + long __functionAddress = GL.getICD().glGetPerfQueryInfoINTEL; + if (CHECKS) { + check(__functionAddress); + check(dataSize, 1); + check(noCounters, 1); + check(noInstances, 1); + check(capsMask, 1); + } + callPPPPPV(queryId, queryName.remaining(), memAddress(queryName), dataSize, noCounters, noInstances, capsMask, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRBlendEquationAdvanced.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRBlendEquationAdvanced.java new file mode 100644 index 00000000..e4f4a814 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRBlendEquationAdvanced.java @@ -0,0 +1,97 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the KHR_blend_equation_advanced extension. + * + *This extension adds a number of "advanced" blending equations that can be used to perform new color blending operations, many of which are more complex + * than the standard blend modes provided by unextended OpenGL. This extension provides two different extension string entries:
+ * + *Some implementations may support KHR_blend_equation_advanced without supporting KHR_blend_equation_advanced_coherent.
+ * + *In unextended OpenGL, the set of blending equations is limited, and can be expressed very simply. The {@link GL14#GL_MIN MIN} and {@link GL14#GL_MAX MAX} blend equations + * simply compute component-wise minimums or maximums of source and destination color components. The {@link GL14#GL_FUNC_ADD FUNC_ADD}, {@link GL14#GL_FUNC_SUBTRACT FUNC_SUBTRACT}, and + * {@link GL14#GL_FUNC_REVERSE_SUBTRACT FUNC_REVERSE_SUBTRACT} multiply the source and destination colors by source and destination factors and either add the two products together + * or subtract one from the other. This limited set of operations supports many common blending operations but precludes the use of more sophisticated + * transparency and blending operations commonly available in many dedicated imaging APIs.
+ * + *This extension provides a number of new "advanced" blending equations. Unlike traditional blending operations using the {@link GL14#GL_FUNC_ADD FUNC_ADD} equation, + * these blending equations do not use source and destination factors specified by {@link GL11C#glBlendFunc BlendFunc}. Instead, each blend equation specifies a complete + * equation based on the source and destination colors. These new blend equations are used for both RGB and alpha components; they may not be used to + * perform separate RGB and alpha blending (via functions like {@link GL20C#glBlendEquationSeparate BlendEquationSeparate}).
+ * + *These blending operations are performed using premultiplied source and destination colors, where RGB colors produced by the fragment shader and stored + * in the framebuffer are considered to be multiplied by alpha (coverage). Many of these advanced blending equations are formulated where the result of + * blending source and destination colors with partial coverage have three separate contributions: from the portions covered by both the source and the + * destination, from the portion covered only by the source, and from the portion covered only by the destination. Such equations are defined assuming that + * the source and destination coverage have no spatial correlation within the pixel.
+ * + *In addition to the coherency issues on implementations not supporting KHR_blend_equation_advanced_coherent, this extension has several limitations worth + * noting. First, the new blend equations are not supported while rendering to more than one color buffer at once; an {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} will be + * generated if an application attempts to render any primitives in this unsupported configuration. Additionally, blending precision may be limited to + * 16-bit floating-point, which could result in a loss of precision and dynamic range for framebuffer formats with 32-bit floating-point components, and in + * a loss of precision for formats with 12- and 16-bit signed or unsigned normalized integer components.
+ * + *Requires {@link GL20 OpenGL 2.0}.
+ */ +public class KHRBlendEquationAdvanced { + + /** Accepted by the {@code mode} parameter of BlendEquation and BlendEquationi. */ + public static final int + GL_MULTIPLY_KHR = 0x9294, + GL_SCREEN_KHR = 0x9295, + GL_OVERLAY_KHR = 0x9296, + GL_DARKEN_KHR = 0x9297, + GL_LIGHTEN_KHR = 0x9298, + GL_COLORDODGE_KHR = 0x9299, + GL_COLORBURN_KHR = 0x929A, + GL_HARDLIGHT_KHR = 0x929B, + GL_SOFTLIGHT_KHR = 0x929C, + GL_DIFFERENCE_KHR = 0x929E, + GL_EXCLUSION_KHR = 0x92A0, + GL_HSL_HUE_KHR = 0x92AD, + GL_HSL_SATURATION_KHR = 0x92AE, + GL_HSL_COLOR_KHR = 0x92AF, + GL_HSL_LUMINOSITY_KHR = 0x92B0; + + static { GL.initialize(); } + + protected KHRBlendEquationAdvanced() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBlendBarrierKHR + ); + } + + // --- [ glBlendBarrierKHR ] --- + + /** + * Specifies a boundary between passes when using advanced blend equations. + * + *When using advanced blending equations, applications should split their rendering into a collection of blending passes, none of which touch an + * individual sample in the framebuffer more than once. The results of blending are undefined if the sample being blended has been touched previously in + * the same pass. Any command that causes the value of a sample to be modified using the framebuffer is considered to touch the sample, including clears, + * blended or unblended primitives, and {@link GL30C#glBlitFramebuffer BlitFramebuffer} copies.
+ */ + public static native void glBlendBarrierKHR(); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRBlendEquationAdvancedCoherent.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRBlendEquationAdvancedCoherent.java new file mode 100644 index 00000000..28fb2cfd --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRBlendEquationAdvancedCoherent.java @@ -0,0 +1,26 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the KHR_blend_equation_advanced_coherent extension. + * + *This extension guarantees that blending is done coherently and in API primitive order. An enable is provided to allow implementations to opt out of + * fully coherent blending and instead behave as though only {@link KHRBlendEquationAdvanced KHR_blend_equation_advanced} were supported.
+ * + *Requires {@link GL20 OpenGL 2.0}.
+ */ +public final class KHRBlendEquationAdvancedCoherent { + + /** + * Accepted by the {@code cap} parameter of Disable, Enable, and IsEnabled, and by the {@code pname} parameter of GetIntegerv, GetBooleanv, GetFloatv, + * GetDoublev and GetInteger64v. + */ + public static final int GL_BLEND_ADVANCED_COHERENT_KHR = 0x9285; + + private KHRBlendEquationAdvancedCoherent() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRContextFlushControl.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRContextFlushControl.java new file mode 100644 index 00000000..c5dddc90 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRContextFlushControl.java @@ -0,0 +1,37 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the KHR_context_flush_control extension. + * + *OpenGL and OpenGL ES have long supported multiple contexts. The semantics of switching contexts is generally left to window system binding APIs such as + * WGL, GLX and EGL. Most of these APIs (if not all) specify that when the current context for a thread is changed, the outgoing context performs an + * implicit flush of any commands that have been issued to that point. OpenGL and OpenGL ES define a flush as sending any pending commands for execution + * and that this action will result in their completion in finite time.
+ * + *This behavior has subtle consequences. For example, if an application is rendering to the front buffer and switches contexts, it may assume that any + * rendering performed thus far will eventually be visible to the user. With recent introduction of shared memory buffers, there become inumerable ways in + * which applications may observe side effects of an implicit flush (or lack thereof).
+ * + *In general, a full flush is not the desired behavior of the application. Nonetheless, applications that switch contexts frequently suffer the + * performance consequences of this unless implementations make special considerations for them, which is generally untenable.
+ * + *This extension allows querying the context flush behavior.
+ * + *Promoted to core in {@link GL45 OpenGL 4.5}.
+ */ +public final class KHRContextFlushControl { + + /** Accepted by the {@code pname} parameter of GetIntegerv, GetFloatv, GetBooleanv GetDoublev and GetInteger64v. */ + public static final int GL_CONTEXT_RELEASE_BEHAVIOR = 0x82FB; + + /** Returned in {@code data} by GetIntegerv, GetFloatv, GetBooleanv GetDoublev and GetInteger64v when {@code pname} is {@link #GL_CONTEXT_RELEASE_BEHAVIOR CONTEXT_RELEASE_BEHAVIOR}. */ + public static final int GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH = 0x82FC; + + private KHRContextFlushControl() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRDebug.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRDebug.java new file mode 100644 index 00000000..bffce506 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRDebug.java @@ -0,0 +1,641 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the KHR_debug extension. + * + *This extension allows the GL to notify applications when various events occur that may be useful during application development, debugging and + * profiling.
+ * + *These events are represented in the form of enumerable messages with a human-readable string representation. Examples of debug events include incorrect + * use of the GL, warnings of undefined behavior, and performance warnings.
+ * + *A message is uniquely identified by a source, a type and an implementation-dependent ID within the source and type pair.
+ * + *A message's source identifies the origin of the message and can either describe components of the GL, the window system, third-party external sources + * such as external debuggers, or even the application itself.
+ * + *The type of the message roughly identifies the nature of the event that caused the message. Examples include errors, performance warnings, warnings + * about undefined behavior or notifications identifying that the application is within a specific section of the application code.
+ * + *A message's ID for a given source and type further distinguishes messages within namespaces. For example, an error caused by a negative parameter value + * or an invalid internal texture format are both errors generated by the API, but would likely have different message IDs.
+ * + *Each message is also assigned to a severity level that denotes roughly how "important" that message is in comparison to other messages across all + * sources and types. For example, notification of a GL error would likely have a higher severity than a performance warning due to redundant state changes.
+ * + *Furthermore, every message contains an implementation-dependent string representation that provides a useful description of the event.
+ * + *Messages are communicated to the application through an application-defined callback function that is called by the GL implementation on each debug + * message. The motivation for the callback routine is to free application developers from actively having to query whether a GL error, or any other + * debuggable event has happened after each call to a GL function. With a callback, developers can keep their code free of debug checks, set breakpoints in + * the callback function, and only have to react to messages as they occur. In situations where using a callback is not possible, a message log is also + * provided that stores only copies of recent messages until they are actively queried.
+ * + *To control the volume of debug output, messages can be disabled either individually by ID, or entire sets of messages can be turned off based on + * combination of source and type, through the entire application code or only section of the code encapsulated in debug groups. A debug group may also be + * used to annotate the command stream using descriptive texts.
+ * + *This extension also defines debug markers, a mechanism for the OpenGL application to annotate the command stream with markers for discrete events.
+ * + *When profiling or debugging an OpenGL application with a built-in or an external debugger or profiler, it is difficult to relate the commands within the + * command stream to the elements of the scene or parts of the program code to which they correspond. Debug markers and debug groups help obviate this by + * allowing applications to specify this link. For example, a debug marker can be used to identify the beginning of a frame in the command stream and a + * debug group can encapsulate a specific command stream to identify a rendering pass. Debug groups also allow control of the debug outputs volume per + * section of an application code providing an effective way to handle the massive amount of debug outputs that drivers can generate.
+ * + *Some existing implementations of {@link ARBDebugOutput ARB_debug_output} only expose the ARB_debug_output extension string if the context was created with the debug + * flag {GLX|WGL}_CONTEXT_DEBUG_BIT_ARB as specified in {GLX|WGL}_ARB_create_context. The behavior is not obvious when the functionality is brought into + * the OpenGL core specification because the extension string and function entry points must always exist.
+ * + *This extension modifies the existing ARB_debug_output extension to allow implementations to always have an empty message log. The specific messages + * written to the message log or callback routines are already implementation defined, so this specification simply makes it explicit that it's fine for + * there to be zero messages generated, even when a GL error occurs, which is useful if the context is non-debug.
+ * + *Debug output can be enabled and disabled by changing the {@link #GL_DEBUG_OUTPUT DEBUG_OUTPUT} state. It is implementation defined how much debug output is generated if the + * context was created without the {@link #GL_CONTEXT_FLAG_DEBUG_BIT CONTEXT_FLAG_DEBUG_BIT} set. This is a new query bit added to the existing {@link GL30#GL_CONTEXT_FLAGS CONTEXT_FLAGS} state to specify whether the + * context was created with debug enabled.
+ * + *Finally, this extension defines a mechanism for OpenGL applications to label their objects (textures, buffers, shaders, etc.) with a descriptive string.
+ * + *When profiling or debugging an OpenGL application within an external or built-in (debut output API) debugger or profiler it is difficult to identify + * objects from their object names (integers).
+ * + *Even when the object itself is viewed it can be problematic to differentiate between similar objects. Attaching a descriptive string, a label, to an + * object obviates this difficulty.
+ * + *The intended purpose of this extension is purely to improve the user experience within OpenGL development tools and application built-in profilers and + * debuggers. This extension typically improves OpenGL programmers efficiency by allowing them to instantly detect issues and the reason for these issues + * giving him more time to focus on adding new features to an OpenGL application.
+ * + *Promoted to core in {@link GL43 OpenGL 4.3}.
+ */ +public class KHRDebug { + + /** Tokens accepted by the {@code target} parameters of Enable, Disable, and IsEnabled. */ + public static final int + GL_DEBUG_OUTPUT = 0x92E0, + GL_DEBUG_OUTPUT_SYNCHRONOUS = 0x8242; + + /** Returned by GetIntegerv when {@code pname} is CONTEXT_FLAGS. */ + public static final int GL_CONTEXT_FLAG_DEBUG_BIT = 0x2; + + /** Tokens accepted by the {@code value} parameters of GetBooleanv, GetIntegerv, GetFloatv, GetDoublev and GetInteger64v. */ + public static final int + GL_MAX_DEBUG_MESSAGE_LENGTH = 0x9143, + GL_MAX_DEBUG_LOGGED_MESSAGES = 0x9144, + GL_DEBUG_LOGGED_MESSAGES = 0x9145, + GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243, + GL_MAX_DEBUG_GROUP_STACK_DEPTH = 0x826C, + GL_DEBUG_GROUP_STACK_DEPTH = 0x826D, + GL_MAX_LABEL_LENGTH = 0x82E8; + + /** Tokens accepted by the {@code pname} parameter of GetPointerv. */ + public static final int + GL_DEBUG_CALLBACK_FUNCTION = 0x8244, + GL_DEBUG_CALLBACK_USER_PARAM = 0x8245; + + /** + * Tokens accepted or provided by the {@code source} parameters of DebugMessageControl, DebugMessageInsert and DEBUGPROC, and the {@code sources} parameter + * of GetDebugMessageLog (some commands restrict {@code source} to a subset of these parameters; see the specification body for details). + */ + public static final int + GL_DEBUG_SOURCE_API = 0x8246, + GL_DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247, + GL_DEBUG_SOURCE_SHADER_COMPILER = 0x8248, + GL_DEBUG_SOURCE_THIRD_PARTY = 0x8249, + GL_DEBUG_SOURCE_APPLICATION = 0x824A, + GL_DEBUG_SOURCE_OTHER = 0x824B; + + /** + * Tokens accepted or provided by the {@code type} parameters of DebugMessageControl, DebugMessageInsert and DEBUGPROC, and the {@code types} parameter of + * GetDebugMessageLog. + */ + public static final int + GL_DEBUG_TYPE_ERROR = 0x824C, + GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D, + GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E, + GL_DEBUG_TYPE_PORTABILITY = 0x824F, + GL_DEBUG_TYPE_PERFORMANCE = 0x8250, + GL_DEBUG_TYPE_OTHER = 0x8251, + GL_DEBUG_TYPE_MARKER = 0x8268; + + /** Tokens accepted or provided by the {@code type} parameters of DebugMessageControl and DEBUGPROC, and the {@code types} parameter of GetDebugMessageLog. */ + public static final int + GL_DEBUG_TYPE_PUSH_GROUP = 0x8269, + GL_DEBUG_TYPE_POP_GROUP = 0x826A; + + /** + * Tokens accepted or provided by the {@code severity} parameters of DebugMessageControl, DebugMessageInsert and DEBUGPROC callback functions, and the + * {@code severities} parameter of GetDebugMessageLog. + */ + public static final int + GL_DEBUG_SEVERITY_HIGH = 0x9146, + GL_DEBUG_SEVERITY_MEDIUM = 0x9147, + GL_DEBUG_SEVERITY_LOW = 0x9148, + GL_DEBUG_SEVERITY_NOTIFICATION = 0x826B; + + /** Tokens accepted or provided by the {@code identifier} parameters of ObjectLabel and GetObjectLabel. */ + public static final int + GL_BUFFER = 0x82E0, + GL_SHADER = 0x82E1, + GL_PROGRAM = 0x82E2, + GL_QUERY = 0x82E3, + GL_PROGRAM_PIPELINE = 0x82E4, + GL_SAMPLER = 0x82E6, + GL_DISPLAY_LIST = 0x82E7; + + static { GL.initialize(); } + + protected KHRDebug() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDebugMessageControl, caps.glDebugMessageInsert, caps.glDebugMessageCallback, caps.glGetDebugMessageLog, caps.glPushDebugGroup, + caps.glPopDebugGroup, caps.glObjectLabel, caps.glGetObjectLabel, caps.glObjectPtrLabel, caps.glGetObjectPtrLabel + ); + } + + // --- [ glDebugMessageControl ] --- + + /** + * Unsafe version of: {@link #glDebugMessageControl DebugMessageControl} + * + * @param count the length of the array {@code ids} + */ + public static void nglDebugMessageControl(int source, int type, int severity, int count, long ids, boolean enabled) { + GL43C.nglDebugMessageControl(source, type, severity, count, ids, enabled); + } + + /** + * Controls the volume of debug output in the active debug group, by disabling specific or groups of messages. + * + *If {@code enabled} is {@link GL11#GL_TRUE TRUE}, the referenced subset of messages will be enabled. If {@link GL11#GL_FALSE FALSE}, then those messages will be disabled.
+ * + *This command can reference different subsets of messages by first considering the set of all messages, and filtering out messages based on the following + * ways:
+ * + *Unrecognized message IDs in {@code ids} are ignored. If {@code count} is zero, the value if {@code ids} is ignored.
+ * + *Although messages are grouped into an implicit hierarchy by their sources and types, there is no explicit per-source, per-type or per-severity enabled + * state. Instead, the enabled state is stored individually for each message. There is no difference between disabling all messages from one source in a + * single call, and individually disabling all messages from that source using their types and IDs.
+ * + *If the {@link GL43C#GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled the GL operates the same as if messages of every {@code source}, {@code type} or {@code severity} are disabled.
+ * + * @param source the source of debug messages to enable or disable. One of:| {@link GL43C#GL_DEBUG_SOURCE_API DEBUG_SOURCE_API} | {@link GL43C#GL_DEBUG_SOURCE_WINDOW_SYSTEM DEBUG_SOURCE_WINDOW_SYSTEM} | {@link GL43C#GL_DEBUG_SOURCE_SHADER_COMPILER DEBUG_SOURCE_SHADER_COMPILER} |
| {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} | {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link GL43C#GL_DEBUG_SOURCE_OTHER DEBUG_SOURCE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_ERROR DEBUG_TYPE_ERROR} | {@link GL43C#GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR DEBUG_TYPE_DEPRECATED_BEHAVIOR} | {@link GL43C#GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR DEBUG_TYPE_UNDEFINED_BEHAVIOR} |
| {@link GL43C#GL_DEBUG_TYPE_PORTABILITY DEBUG_TYPE_PORTABILITY} | {@link GL43C#GL_DEBUG_TYPE_PERFORMANCE DEBUG_TYPE_PERFORMANCE} | {@link GL43C#GL_DEBUG_TYPE_OTHER DEBUG_TYPE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_MARKER DEBUG_TYPE_MARKER} |
| {@link GL43C#GL_DEBUG_SEVERITY_HIGH DEBUG_SEVERITY_HIGH} | {@link GL43C#GL_DEBUG_SEVERITY_MEDIUM DEBUG_SEVERITY_MEDIUM} | {@link GL43C#GL_DEBUG_SEVERITY_LOW DEBUG_SEVERITY_LOW} |
| {@link GL43C#GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION} |
If {@code enabled} is {@link GL11#GL_TRUE TRUE}, the referenced subset of messages will be enabled. If {@link GL11#GL_FALSE FALSE}, then those messages will be disabled.
+ * + *This command can reference different subsets of messages by first considering the set of all messages, and filtering out messages based on the following + * ways:
+ * + *Unrecognized message IDs in {@code ids} are ignored. If {@code count} is zero, the value if {@code ids} is ignored.
+ * + *Although messages are grouped into an implicit hierarchy by their sources and types, there is no explicit per-source, per-type or per-severity enabled + * state. Instead, the enabled state is stored individually for each message. There is no difference between disabling all messages from one source in a + * single call, and individually disabling all messages from that source using their types and IDs.
+ * + *If the {@link GL43C#GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled the GL operates the same as if messages of every {@code source}, {@code type} or {@code severity} are disabled.
+ * + * @param source the source of debug messages to enable or disable. One of:| {@link GL43C#GL_DEBUG_SOURCE_API DEBUG_SOURCE_API} | {@link GL43C#GL_DEBUG_SOURCE_WINDOW_SYSTEM DEBUG_SOURCE_WINDOW_SYSTEM} | {@link GL43C#GL_DEBUG_SOURCE_SHADER_COMPILER DEBUG_SOURCE_SHADER_COMPILER} |
| {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} | {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link GL43C#GL_DEBUG_SOURCE_OTHER DEBUG_SOURCE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_ERROR DEBUG_TYPE_ERROR} | {@link GL43C#GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR DEBUG_TYPE_DEPRECATED_BEHAVIOR} | {@link GL43C#GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR DEBUG_TYPE_UNDEFINED_BEHAVIOR} |
| {@link GL43C#GL_DEBUG_TYPE_PORTABILITY DEBUG_TYPE_PORTABILITY} | {@link GL43C#GL_DEBUG_TYPE_PERFORMANCE DEBUG_TYPE_PERFORMANCE} | {@link GL43C#GL_DEBUG_TYPE_OTHER DEBUG_TYPE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_MARKER DEBUG_TYPE_MARKER} |
| {@link GL43C#GL_DEBUG_SEVERITY_HIGH DEBUG_SEVERITY_HIGH} | {@link GL43C#GL_DEBUG_SEVERITY_MEDIUM DEBUG_SEVERITY_MEDIUM} | {@link GL43C#GL_DEBUG_SEVERITY_LOW DEBUG_SEVERITY_LOW} |
| {@link GL43C#GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION} |
The value of {@code id} specifies the ID for the message and {@code severity} indicates its severity level as defined by the caller. The string + * {@code buf} contains the string representation of the message. The parameter {@code length} contains the number of characters in {@code buf}. If + * {@code length} is negative, it is implied that {@code buf} contains a null terminated string. The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} will be generated if the + * number of characters in {@code buf}, excluding the null terminator when {@code length} is negative, is not less than the value of + * {@link GL43C#GL_MAX_DEBUG_MESSAGE_LENGTH MAX_DEBUG_MESSAGE_LENGTH}.
+ * + *If the {@link GL43C#GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled calls to DebugMessageInsert are discarded and do not generate an error.
+ * + * @param source the source of the debug message to insert. One of:| {@link GL43C#GL_DEBUG_SOURCE_API DEBUG_SOURCE_API} | {@link GL43C#GL_DEBUG_SOURCE_WINDOW_SYSTEM DEBUG_SOURCE_WINDOW_SYSTEM} | {@link GL43C#GL_DEBUG_SOURCE_SHADER_COMPILER DEBUG_SOURCE_SHADER_COMPILER} |
| {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} | {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link GL43C#GL_DEBUG_SOURCE_OTHER DEBUG_SOURCE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_ERROR DEBUG_TYPE_ERROR} | {@link GL43C#GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR DEBUG_TYPE_DEPRECATED_BEHAVIOR} | {@link GL43C#GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR DEBUG_TYPE_UNDEFINED_BEHAVIOR} |
| {@link GL43C#GL_DEBUG_TYPE_PORTABILITY DEBUG_TYPE_PORTABILITY} | {@link GL43C#GL_DEBUG_TYPE_PERFORMANCE DEBUG_TYPE_PERFORMANCE} | {@link GL43C#GL_DEBUG_TYPE_OTHER DEBUG_TYPE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_MARKER DEBUG_TYPE_MARKER} |
| {@link GL43C#GL_DEBUG_SEVERITY_HIGH DEBUG_SEVERITY_HIGH} | {@link GL43C#GL_DEBUG_SEVERITY_MEDIUM DEBUG_SEVERITY_MEDIUM} | {@link GL43C#GL_DEBUG_SEVERITY_LOW DEBUG_SEVERITY_LOW} |
| {@link GL43C#GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION} |
The value of {@code id} specifies the ID for the message and {@code severity} indicates its severity level as defined by the caller. The string + * {@code buf} contains the string representation of the message. The parameter {@code length} contains the number of characters in {@code buf}. If + * {@code length} is negative, it is implied that {@code buf} contains a null terminated string. The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} will be generated if the + * number of characters in {@code buf}, excluding the null terminator when {@code length} is negative, is not less than the value of + * {@link GL43C#GL_MAX_DEBUG_MESSAGE_LENGTH MAX_DEBUG_MESSAGE_LENGTH}.
+ * + *If the {@link GL43C#GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled calls to DebugMessageInsert are discarded and do not generate an error.
+ * + * @param source the source of the debug message to insert. One of:| {@link GL43C#GL_DEBUG_SOURCE_API DEBUG_SOURCE_API} | {@link GL43C#GL_DEBUG_SOURCE_WINDOW_SYSTEM DEBUG_SOURCE_WINDOW_SYSTEM} | {@link GL43C#GL_DEBUG_SOURCE_SHADER_COMPILER DEBUG_SOURCE_SHADER_COMPILER} |
| {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} | {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link GL43C#GL_DEBUG_SOURCE_OTHER DEBUG_SOURCE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_ERROR DEBUG_TYPE_ERROR} | {@link GL43C#GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR DEBUG_TYPE_DEPRECATED_BEHAVIOR} | {@link GL43C#GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR DEBUG_TYPE_UNDEFINED_BEHAVIOR} |
| {@link GL43C#GL_DEBUG_TYPE_PORTABILITY DEBUG_TYPE_PORTABILITY} | {@link GL43C#GL_DEBUG_TYPE_PERFORMANCE DEBUG_TYPE_PERFORMANCE} | {@link GL43C#GL_DEBUG_TYPE_OTHER DEBUG_TYPE_OTHER} |
| {@link GL43C#GL_DEBUG_TYPE_MARKER DEBUG_TYPE_MARKER} |
| {@link GL43C#GL_DEBUG_SEVERITY_HIGH DEBUG_SEVERITY_HIGH} | {@link GL43C#GL_DEBUG_SEVERITY_MEDIUM DEBUG_SEVERITY_MEDIUM} | {@link GL43C#GL_DEBUG_SEVERITY_LOW DEBUG_SEVERITY_LOW} |
| {@link GL43C#GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION} |
The function's prototype must follow the type definition of DEBUGPROC including its platform-dependent calling convention. Anything else will result in + * undefined behavior. Only one debug callback can be specified for the current context, and further calls overwrite the previous callback. Specifying + * {@code NULL} as the value of {@code callback} clears the current callback and disables message output through callbacks. Applications can provide + * user-specified data through the pointer {@code userParam}. The context will store this pointer and will include it as one of the parameters in each call + * to the callback function.
+ * + *If the application has specified a callback function for receiving debug output, the implementation will call that function whenever any enabled message + * is generated. The source, type, ID, and severity of the message are specified by the DEBUGPROC parameters {@code source}, {@code type}, {@code id}, and + * {@code severity}, respectively. The string representation of the message is stored in {@code message} and its length (excluding the null-terminator) is + * stored in {@code length}. The parameter {@code userParam} is the user-specified parameter that was given when calling DebugMessageCallback.
+ * + *Applications can query the current callback function and the current user-specified parameter by obtaining the values of {@link GL43C#GL_DEBUG_CALLBACK_FUNCTION DEBUG_CALLBACK_FUNCTION} and + * {@link GL43C#GL_DEBUG_CALLBACK_USER_PARAM DEBUG_CALLBACK_USER_PARAM}, respectively.
+ * + *Applications that specify a callback function must be aware of certain special conditions when executing code inside a callback when it is called by the + * GL, regardless of the debug source.
+ * + *The memory for {@code message} is owned and managed by the GL, and should only be considered valid for the duration of the function call.
+ * + *The behavior of calling any GL or window system function from within the callback function is undefined and may lead to program termination.
+ * + *Care must also be taken in securing debug callbacks for use with asynchronous debug output by multi-threaded GL implementations.
+ * + *If the {@link GL43C#GL_DEBUG_OUTPUT DEBUG_OUTPUT} state is disabled then the GL will not call the callback function.
+ * + * @param callback a callback function that will be called when a debug message is generated + * @param userParam a user supplied pointer that will be passed on each invocation of {@code callback} + */ + public static void glDebugMessageCallback(@Nullable @NativeType("GLDEBUGPROC") GLDebugMessageCallbackI callback, @NativeType("void const *") long userParam) { + GL43C.glDebugMessageCallback(callback, userParam); + } + + // --- [ glGetDebugMessageLog ] --- + + /** + * Unsafe version of: {@link #glGetDebugMessageLog GetDebugMessageLog} + * + * @param bufsize the size of the buffer whose address is given by {@code messageLog} + */ + public static int nglGetDebugMessageLog(int count, int bufsize, long sources, long types, long ids, long severities, long lengths, long messageLog) { + return GL43C.nglGetDebugMessageLog(count, bufsize, sources, types, ids, severities, lengths, messageLog); + } + + /** + * Retrieves messages from the debug message log. + * + *This function fetches a maximum of {@code count} messages from the message log, and will return the number of messages successfully fetched.
+ * + *Messages will be fetched from the log in order of oldest to newest. Those messages that were fetched will be removed from the log.
+ * + *The sources, types, severities, IDs, and string lengths of fetched messages will be stored in the application-provided arrays {@code sources}, + * {@code types}, {@code severities}, {@code ids}, and {@code lengths}, respectively. The application is responsible for allocating enough space for each + * array to hold up to {@code count} elements. The string representations of all fetched messages are stored in the {@code messageLog} array. If multiple + * messages are fetched, their strings are concatenated into the same {@code messageLog} array and will be separated by single null terminators. The last + * string in the array will also be null-terminated. The maximum size of {@code messageLog}, including the space used by all null terminators, is given by + * {@code bufSize}. If {@code bufSize} is less than zero and {@code messageLog} is not {@code NULL}, an {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error will be generated. If a message's + * string, including its null terminator, can not fully fit within the {@code messageLog} array's remaining space, then that message and any subsequent + * messages will not be fetched and will remain in the log. The string lengths stored in the array {@code lengths} include the space for the null + * terminator of each string.
+ * + *Any or all of the arrays {@code sources}, {@code types}, {@code ids}, {@code severities}, {@code lengths} and {@code messageLog} can also be null + * pointers, which causes the attributes for such arrays to be discarded when messages are fetched, however those messages will still be removed from the + * log. Thus to simply delete up to {@code count} messages from the message log while ignoring their attributes, the application can call the function + * with null pointers for all attribute arrays.
+ * + *If the context was created without the {@link GL43C#GL_CONTEXT_FLAG_DEBUG_BIT CONTEXT_FLAG_DEBUG_BIT} in the {@link GL30#GL_CONTEXT_FLAGS CONTEXT_FLAGS} state, then the GL can opt to never add messages to the + * message log so GetDebugMessageLog will always return zero.
+ * + * @param count the number of debug messages to retrieve from the log + * @param sources an array of variables to receive the sources of the retrieved messages + * @param types an array of variables to receive the types of the retrieved messages + * @param ids an array of unsigned integers to receive the ids of the retrieved messages + * @param severities an array of variables to receive the severites of the retrieved messages + * @param lengths an array of variables to receive the lengths of the received messages + * @param messageLog an array of characters that will receive the messages + */ + @NativeType("GLuint") + public static int glGetDebugMessageLog(@NativeType("GLuint") int count, @Nullable @NativeType("GLenum *") IntBuffer sources, @Nullable @NativeType("GLenum *") IntBuffer types, @Nullable @NativeType("GLuint *") IntBuffer ids, @Nullable @NativeType("GLenum *") IntBuffer severities, @Nullable @NativeType("GLsizei *") IntBuffer lengths, @Nullable @NativeType("GLchar *") ByteBuffer messageLog) { + return GL43C.glGetDebugMessageLog(count, sources, types, ids, severities, lengths, messageLog); + } + + // --- [ glPushDebugGroup ] --- + + /** + * Unsafe version of: {@link #glPushDebugGroup PushDebugGroup} + * + * @param length the length of the message to be sent to the debug output stream + */ + public static void nglPushDebugGroup(int source, int id, int length, long message) { + GL43C.nglPushDebugGroup(source, id, length, message); + } + + /** + * Pushes a debug group described by the string {@code message} into the command stream. The value of {@code id} specifies the ID of messages generated. + * The parameter {@code length} contains the number of characters in {@code message}. If {@code length} is negative, it is implied that {@code message} + * contains a null terminated string. The message has the specified {@code source} and {@code id}, {@code type} {@link GL43C#GL_DEBUG_TYPE_PUSH_GROUP DEBUG_TYPE_PUSH_GROUP}, and + * {@code severity} {@link GL43C#GL_DEBUG_SEVERITY_NOTIFICATION DEBUG_SEVERITY_NOTIFICATION}. The GL will put a new debug group on top of the debug group stack which inherits the control of the + * volume of debug output of the debug group previously residing on the top of the debug group stack. Because debug groups are strictly hierarchical, any + * additional control of the debug output volume will only apply within the active debug group and the debug groups pushed on top of the active debug group. + * + *An {@link GL11#GL_INVALID_ENUM INVALID_ENUM} error is generated if the value of {@code source} is neither {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} nor {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY}. An + * {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if {@code length} is negative and the number of characters in {@code message}, excluding the null-terminator, is + * not less than the value of {@link GL43C#GL_MAX_DEBUG_MESSAGE_LENGTH MAX_DEBUG_MESSAGE_LENGTH}.
+ * + * @param source the source of the debug message. One of:| {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} |
An {@link GL11#GL_INVALID_ENUM INVALID_ENUM} error is generated if the value of {@code source} is neither {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} nor {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY}. An + * {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if {@code length} is negative and the number of characters in {@code message}, excluding the null-terminator, is + * not less than the value of {@link GL43C#GL_MAX_DEBUG_MESSAGE_LENGTH MAX_DEBUG_MESSAGE_LENGTH}.
+ * + * @param source the source of the debug message. One of:| {@link GL43C#GL_DEBUG_SOURCE_APPLICATION DEBUG_SOURCE_APPLICATION} | {@link GL43C#GL_DEBUG_SOURCE_THIRD_PARTY DEBUG_SOURCE_THIRD_PARTY} |
Attempting to pop the default debug group off the stack generates a {@link GL11#GL_STACK_UNDERFLOW STACK_UNDERFLOW} error; pushing a debug group onto a stack containing + * {@link GL43C#GL_MAX_DEBUG_GROUP_STACK_DEPTH MAX_DEBUG_GROUP_STACK_DEPTH} minus one elements will generate a {@link GL11#GL_STACK_OVERFLOW STACK_OVERFLOW} error.
+ */ + public static void glPopDebugGroup() { + GL43C.glPopDebugGroup(); + } + + // --- [ glObjectLabel ] --- + + /** + * Unsafe version of: {@link #glObjectLabel ObjectLabel} + * + * @param length the length of the label to be used for the object + */ + public static void nglObjectLabel(int identifier, int name, int length, long label) { + GL43C.nglObjectLabel(identifier, name, length, label); + } + + /** + * Labels a named object identified within a namespace. + * + * @param identifier the namespace from which the name of the object is allocated. One of:| {@link GL43C#GL_BUFFER BUFFER} | {@link GL43C#GL_SHADER SHADER} | {@link GL43C#GL_PROGRAM PROGRAM} | {@link GL43C#GL_QUERY QUERY} | {@link GL43C#GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link GL43C#GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
| {@link GL43C#GL_BUFFER BUFFER} | {@link GL43C#GL_SHADER SHADER} | {@link GL43C#GL_PROGRAM PROGRAM} | {@link GL43C#GL_QUERY QUERY} | {@link GL43C#GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link GL43C#GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
| {@link GL43C#GL_BUFFER BUFFER} | {@link GL43C#GL_SHADER SHADER} | {@link GL43C#GL_PROGRAM PROGRAM} | {@link GL43C#GL_QUERY QUERY} | {@link GL43C#GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link GL43C#GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
| {@link GL43C#GL_BUFFER BUFFER} | {@link GL43C#GL_SHADER SHADER} | {@link GL43C#GL_PROGRAM PROGRAM} | {@link GL43C#GL_QUERY QUERY} | {@link GL43C#GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link GL43C#GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
| {@link GL43C#GL_BUFFER BUFFER} | {@link GL43C#GL_SHADER SHADER} | {@link GL43C#GL_PROGRAM PROGRAM} | {@link GL43C#GL_QUERY QUERY} | {@link GL43C#GL_PROGRAM_PIPELINE PROGRAM_PIPELINE} | {@link GL43C#GL_SAMPLER SAMPLER} | {@link GL11#GL_VERTEX_ARRAY VERTEX_ARRAY} | {@link GL11#GL_TEXTURE TEXTURE} |
| {@link GL30#GL_RENDERBUFFER RENDERBUFFER} | {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL40#GL_TRANSFORM_FEEDBACK TRANSFORM_FEEDBACK} |
With this extension enabled any behavior that generates a GL error will have undefined behavior. The reason this extension exists is performance can be + * increased and power usage decreased. When this mode is used, a GL driver can have undefined behavior where it would have generated a GL error without + * this extension. This could include application termination. In general this extension should be used after you have verified all the GL errors are + * removed, and an application is not the kind that would check for GL errors and adjust behavior based on those errors.
+ * + *Requires {@link GL20 OpenGL 2.0}.
+ */ +public final class KHRNoError { + + /** If set in {@link GL30#GL_CONTEXT_FLAGS CONTEXT_FLAGS}, then no error behavior is enabled for this context. */ + public static final int GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR = 0x8; + + private KHRNoError() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRParallelShaderCompile.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRParallelShaderCompile.java new file mode 100644 index 00000000..c5bea233 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRParallelShaderCompile.java @@ -0,0 +1,55 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the KHR_parallel_shader_compile extension. + * + *Compiling GLSL into implementation-specific code can be a time consuming process, so a GL implementation may wish to perform the compilation in a + * separate CPU thread. This extension provides a mechanism for the application to provide a hint to limit the number of threads it wants to be used to + * compile shaders, as well as a query to determine if the compilation process is complete.
+ */ +public class KHRParallelShaderCompile { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int GL_MAX_SHADER_COMPILER_THREADS_KHR = 0x91B0; + + /** Accepted as part of the {@code pname} parameter to {@link GL20C#glGetShaderiv GetShaderiv} and accepted as part of the {@code pname} parameter to {@link GL20C#glGetProgramiv GetProgramiv}. */ + public static final int GL_COMPLETION_STATUS_KHR = 0x91B1; + + static { GL.initialize(); } + + protected KHRParallelShaderCompile() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glMaxShaderCompilerThreadsKHR + ); + } + + // --- [ glMaxShaderCompilerThreadsKHR ] --- + + /** + * Applications may use this function to hint to the driver the maximum number background threads it would like to be used in the process of compiling + * shaders or linking programs, + * + *An implementation may combine the maximum compiler thread request from multiple contexts in a share group in an implementation-specific way.
+ * + *An application can query the current {@code MaxShaderCompilerThreadsKHR} {@code count} by calling {@link GL11C#glGetIntegerv GetIntegerv} with {@code pname} set to + * {@link #GL_MAX_SHADER_COMPILER_THREADS_KHR MAX_SHADER_COMPILER_THREADS_KHR}, which returns the value of the current state.
+ * + * @param count the number of background threads. A {@code count} of zero specifies a request for no parallel compiling or linking and a {@code count} of + * {@code 0xFFFFFFFF} requests an implementation-specific maximum. + */ + public static native void glMaxShaderCompilerThreadsKHR(@NativeType("GLuint") int count); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRRobustness.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRRobustness.java new file mode 100644 index 00000000..c07d5658 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRRobustness.java @@ -0,0 +1,343 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the KHR_robustness extension. + * + *Several recent trends in how OpenGL ES integrates into modern computer systems have created new requirements for robustness and security for GL + * rendering contexts.
+ * + *Additionally GPU architectures now support hardware fault detection; for example, video memory supporting ECC (error correcting codes) and error + * detection. GL contexts should be capable of recovering from hardware faults such as uncorrectable memory errors. Along with recovery from such hardware + * faults, the recovery mechanism can also allow recovery from video memory access exceptions and system software failures. System software failures can + * be due to device changes or driver failures.
+ * + *GL queries that return (write) some number of bytes to a buffer indicated by a pointer parameter introduce risk of buffer overflows that might be + * exploitable by malware. To address this, queries with return value sizes that are not expressed directly by the parameters to the query itself are + * given additional API functions with an additional parameter that specifies the number of bytes in the buffer and never writing bytes beyond that limit. + * This is particularly useful for multi-threaded usage of GL contexts in a "share group" where one context can change objects in ways that can cause + * buffer overflows for another context's GL queries.
+ * + *The original ARB_vertex_buffer_object extension includes an issue that explicitly states program termination is allowed when out-of-bounds vertex + * buffer object fetches occur. Modern graphics hardware is capable of well-defined behavior in the case of out-of- bounds vertex buffer object fetches. + * Older hardware may require extra checks to enforce well-defined (and termination free) behavior, but this expense is warranted when processing + * potentially untrusted content.
+ * + *The intent of this extension is to address some specific robustness goals:
+ * + *Requires {@link GL32 OpenGL 3.2}.
+ */ +public class KHRRobustness { + + /** Returned by {@link #glGetGraphicsResetStatus GetGraphicsResetStatus}. */ + public static final int + GL_NO_ERROR = 0x0, + GL_GUILTY_CONTEXT_RESET = 0x8253, + GL_INNOCENT_CONTEXT_RESET = 0x8254, + GL_UNKNOWN_CONTEXT_RESET = 0x8255; + + /** Accepted by the {@code value} parameter of GetBooleanv, GetIntegerv, and GetFloatv. */ + public static final int + GL_CONTEXT_ROBUST_ACCESS = 0x90F3, + GL_RESET_NOTIFICATION_STRATEGY = 0x8256; + + /** Returned by GetIntegerv and related simple queries when {@code value} is {@link #GL_RESET_NOTIFICATION_STRATEGY RESET_NOTIFICATION_STRATEGY}. */ + public static final int + GL_LOSE_CONTEXT_ON_RESET = 0x8252, + GL_NO_RESET_NOTIFICATION = 0x8261; + + /** Returned by {@link GL11C#glGetError GetError}. */ + public static final int GL_CONTEXT_LOST = 0x507; + + static { GL.initialize(); } + + protected KHRRobustness() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetGraphicsResetStatus, caps.glReadnPixels, caps.glGetnUniformfv, caps.glGetnUniformiv, caps.glGetnUniformuiv + ); + } + + // --- [ glGetGraphicsResetStatus ] --- + + /** + * Indicates if the GL context has been in a reset state at any point since the last call to GetGraphicsResetStatus: + * + *If a reset status other than NO_ERROR is returned and subsequent calls return NO_ERROR, the context reset was encountered and completed. If a reset + * status is repeatedly returned, the context may be in the process of resetting.
+ * + *Reset notification behavior is determined at context creation time, and may be queried by calling GetIntegerv with the symbolic constant + * {@link GL45C#GL_RESET_NOTIFICATION_STRATEGY RESET_NOTIFICATION_STRATEGY}.
+ * + *If the reset notification behavior is {@link GL45C#GL_NO_RESET_NOTIFICATION NO_RESET_NOTIFICATION}, then the implementation will never deliver notification of reset events, and + * GetGraphicsResetStatus will always return NO_ERROR.
+ * + *If the behavior is {@link GL45C#GL_LOSE_CONTEXT_ON_RESET LOSE_CONTEXT_ON_RESET}, a graphics reset will result in a lost context and require creating a new context as described + * above. In this case GetGraphicsResetStatus will return an appropriate value from those described above.
+ * + *If a graphics reset notification occurs in a context, a notification must also occur in all other contexts which share objects with that context.
+ * + *After a graphics reset has occurred on a context, subsequent GL commands on that context (or any context which shares with that context) will generate a + * {@link GL45C#GL_CONTEXT_LOST CONTEXT_LOST} error. Such commands will not have side effects (in particular, they will not modify memory passed by pointer for query results, + * and may not block indefinitely or cause termination of the application. Exceptions to this behavior include:
+ * + *| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
| {@link GL11#GL_RED RED} | {@link GL11#GL_GREEN GREEN} | {@link GL11#GL_BLUE BLUE} | {@link GL11#GL_ALPHA ALPHA} | {@link GL30#GL_RG RG} | {@link GL11#GL_RGB RGB} | {@link GL11C#GL_RGBA RGBA} | {@link GL12#GL_BGR BGR} |
| {@link GL12#GL_BGRA BGRA} | {@link GL30#GL_RED_INTEGER RED_INTEGER} | {@link GL30#GL_GREEN_INTEGER GREEN_INTEGER} | {@link GL30#GL_BLUE_INTEGER BLUE_INTEGER} | {@link GL30#GL_ALPHA_INTEGER ALPHA_INTEGER} | {@link GL30#GL_RG_INTEGER RG_INTEGER} | {@link GL30#GL_RGB_INTEGER RGB_INTEGER} | {@link GL30#GL_RGBA_INTEGER RGBA_INTEGER} |
| {@link GL30#GL_BGR_INTEGER BGR_INTEGER} | {@link GL30#GL_BGRA_INTEGER BGRA_INTEGER} | {@link GL11#GL_STENCIL_INDEX STENCIL_INDEX} | {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} | {@link GL30#GL_DEPTH_STENCIL DEPTH_STENCIL} | {@link GL11#GL_LUMINANCE LUMINANCE} | {@link GL11#GL_LUMINANCE_ALPHA LUMINANCE_ALPHA} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_SHORT SHORT} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL30#GL_HALF_FLOAT HALF_FLOAT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL12#GL_UNSIGNED_BYTE_3_3_2 UNSIGNED_BYTE_3_3_2} | {@link GL12#GL_UNSIGNED_BYTE_2_3_3_REV UNSIGNED_BYTE_2_3_3_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5 UNSIGNED_SHORT_5_6_5} | {@link GL12#GL_UNSIGNED_SHORT_5_6_5_REV UNSIGNED_SHORT_5_6_5_REV} |
| {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4 UNSIGNED_SHORT_4_4_4_4} | {@link GL12#GL_UNSIGNED_SHORT_4_4_4_4_REV UNSIGNED_SHORT_4_4_4_4_REV} | {@link GL12#GL_UNSIGNED_SHORT_5_5_5_1 UNSIGNED_SHORT_5_5_5_1} | {@link GL12#GL_UNSIGNED_SHORT_1_5_5_5_REV UNSIGNED_SHORT_1_5_5_5_REV} |
| {@link GL12#GL_UNSIGNED_INT_8_8_8_8 UNSIGNED_INT_8_8_8_8} | {@link GL12#GL_UNSIGNED_INT_8_8_8_8_REV UNSIGNED_INT_8_8_8_8_REV} | {@link GL12#GL_UNSIGNED_INT_10_10_10_2 UNSIGNED_INT_10_10_10_2} | {@link GL12#GL_UNSIGNED_INT_2_10_10_10_REV UNSIGNED_INT_2_10_10_10_REV} |
| {@link GL30#GL_UNSIGNED_INT_24_8 UNSIGNED_INT_24_8} | {@link GL30#GL_UNSIGNED_INT_10F_11F_11F_REV UNSIGNED_INT_10F_11F_11F_REV} | {@link GL30#GL_UNSIGNED_INT_5_9_9_9_REV UNSIGNED_INT_5_9_9_9_REV} | {@link GL30#GL_FLOAT_32_UNSIGNED_INT_24_8_REV FLOAT_32_UNSIGNED_INT_24_8_REV} |
| {@link GL11#GL_BITMAP BITMAP} |
This extension enables support for the {@code KHR_shader_subgroup} shading language extension in OpenGL.
+ * + *The extension adds API queries to be able to query
+ * + *In OpenGL implementations supporting SPIR-V, this extension enables the minimal subset of SPIR-V 1.3 which is required to support the subgroup features + * that are supported by the implementation.
+ * + *Requires {@link GL43 OpenGL 4.3}.
+ */ +public final class KHRShaderSubgroup { + + /** Accepted as the {@code pname} argument for {@link GL11C#glGetIntegerv GetIntegerv} and {@link GL32C#glGetInteger64v GetInteger64v}. */ + public static final int + GL_SUBGROUP_SIZE_KHR = 0x9532, + GL_SUBGROUP_SUPPORTED_STAGES_KHR = 0x9533, + GL_SUBGROUP_SUPPORTED_FEATURES_KHR = 0x9534; + + /** Accepted as the {@code pname} argument for {@link GL11C#glGetBooleanv GetBooleanv}. */ + public static final int GL_SUBGROUP_QUAD_ALL_STAGES_KHR = 0x9535; + + /** Returned as bitfield in the {@code data} argument when {@link GL11C#glGetIntegerv GetIntegerv} is queried with a {@code pname} of {@link #GL_SUBGROUP_SUPPORTED_FEATURES_KHR SUBGROUP_SUPPORTED_FEATURES_KHR}. */ + public static final int + GL_SUBGROUP_FEATURE_BASIC_BIT_KHR = 0x1, + GL_SUBGROUP_FEATURE_VOTE_BIT_KHR = 0x2, + GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR = 0x4, + GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR = 0x8, + GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR = 0x10, + GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR = 0x20, + GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR = 0x40, + GL_SUBGROUP_FEATURE_QUAD_BIT_KHR = 0x80; + + private KHRShaderSubgroup() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRTextureCompressionASTCLDR.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRTextureCompressionASTCLDR.java new file mode 100644 index 00000000..a5191b11 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/KHRTextureCompressionASTCLDR.java @@ -0,0 +1,80 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the KHR_texture_compression_astc_ldr extension. + * + *Adaptive Scalable Texture Compression (ASTC) is a new texture compression technology that offers unprecendented flexibility, while producing better or + * comparable results than existing texture compressions at all bit rates. It includes support for 2D and slice-based 3D textures, with low and high + * dynamic range, at bitrates from below 1 bit/pixel up to 8 bits/pixel in fine steps.
+ * + *The goal of this extension is to support the full 2D profile of the ASTC texture compression specification, and allow construction of 3D textures from + * multiple 2D slices.
+ * + *ASTC-compressed textures are handled in OpenGL by adding new supported formats to the existing mechanisms for handling compressed textures.
+ * + *ASTC stands for Adaptive Scalable Texture Compression. The ASTC formats form a family of related compressed texture image formats. They are all derived + * from a common set of definitions.
+ * + *ASTC textures may be either 2D or 3D.
+ * + *ASTC textures may be encoded using either high or low dynamic range. Low dynamic range images may optionally be specified using the sRGB color space.
+ * + *A sub-profile ("HDR Profile") is defined, which supports only 2D images (and 3D images made up of multiple 2D slices) at low or high dynamic range.
+ * + *Support for this profile is indicated by the presence of the extension string "GL_KHR_texture_compression_astc_hdr". If, in future, the full profile is + * supported, "GL_KHR_texture_compression_astc_hdr" must still be published, in order to ensure backward compatibility.
+ * + *A lower sub-profile ("LDR Profile") may be implemented, which supports only 2D images at low dynamic range. This is indicated by the presence of the + * extension string "GL_KHR_texture_compression_astc_ldr". If either the HDR or full profile are implemented, then both name strings + * "GL_KHR_texture_compression_astc_ldr" and "GL_KHR_texture_compression_astc_hdr" must be published.
+ * + *ASTC textures may be encoded as 1, 2, 3 or 4 components, but they are all decoded into RGBA.
+ * + *ASTC has a variable block size, and this is specified as part of the name of the token passed to CompressedImage2D and its related functions.
+ */ +public final class KHRTextureCompressionASTCLDR { + + /** + * Accepted by the {@code internalformat} parameter of CompressedTexImage2D, CompressedTexSubImage2D, TexStorage2D, TextureStorage2D, TexStorage3D, and + * TextureStorage3D. + */ + public static final int + GL_COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93B0, + GL_COMPRESSED_RGBA_ASTC_5x4_KHR = 0x93B1, + GL_COMPRESSED_RGBA_ASTC_5x5_KHR = 0x93B2, + GL_COMPRESSED_RGBA_ASTC_6x5_KHR = 0x93B3, + GL_COMPRESSED_RGBA_ASTC_6x6_KHR = 0x93B4, + GL_COMPRESSED_RGBA_ASTC_8x5_KHR = 0x93B5, + GL_COMPRESSED_RGBA_ASTC_8x6_KHR = 0x93B6, + GL_COMPRESSED_RGBA_ASTC_8x8_KHR = 0x93B7, + GL_COMPRESSED_RGBA_ASTC_10x5_KHR = 0x93B8, + GL_COMPRESSED_RGBA_ASTC_10x6_KHR = 0x93B9, + GL_COMPRESSED_RGBA_ASTC_10x8_KHR = 0x93BA, + GL_COMPRESSED_RGBA_ASTC_10x10_KHR = 0x93BB, + GL_COMPRESSED_RGBA_ASTC_12x10_KHR = 0x93BC, + GL_COMPRESSED_RGBA_ASTC_12x12_KHR = 0x93BD, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = 0x93D0, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = 0x93D1, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = 0x93D2, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = 0x93D3, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = 0x93D4, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = 0x93D5, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = 0x93D6, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = 0x93D7, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = 0x93D8, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = 0x93D9, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = 0x93DA, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = 0x93DB, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = 0x93DC, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = 0x93DD; + + private KHRTextureCompressionASTCLDR() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVAlphaToCoverageDitherControl.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVAlphaToCoverageDitherControl.java new file mode 100644 index 00000000..ec304f07 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVAlphaToCoverageDitherControl.java @@ -0,0 +1,45 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the NV_alpha_to_coverage_dither_control extension. + * + *{@code NV_alpha_to_coverage_dither_control} provides a new mechanism to control whether dithering is applied when the existing alpha to coverage + * functionality is used.
+ */ +public class NVAlphaToCoverageDitherControl { + + /** Accepted by the {@code param} parameter of {@link #glAlphaToCoverageDitherControlNV AlphaToCoverageDitherControlNV}. */ + public static final int + GL_ALPHA_TO_COVERAGE_DITHER_DEFAULT_NV = 0x934D, + GL_ALPHA_TO_COVERAGE_DITHER_ENABLE_NV = 0x934E, + GL_ALPHA_TO_COVERAGE_DITHER_DISABLE_NV = 0x934F; + + /** Accepted by the {@code param} of {@link GL11C#glGetIntegerv GetIntegerv}. */ + public static final int GL_ALPHA_TO_COVERAGE_DITHER_MODE_NV = 0x92BF; + + static { GL.initialize(); } + + protected NVAlphaToCoverageDitherControl() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glAlphaToCoverageDitherControlNV + ); + } + + // --- [ glAlphaToCoverageDitherControlNV ] --- + + public static native void glAlphaToCoverageDitherControlNV(@NativeType("GLenum") int mode); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVBindlessMultiDrawIndirect.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVBindlessMultiDrawIndirect.java new file mode 100644 index 00000000..e21b1c41 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVBindlessMultiDrawIndirect.java @@ -0,0 +1,175 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_bindless_multi_draw_indirect extension. + * + *This extension combines {@code NV_vertex_buffer_unified_memory} and {@code ARB_multi_draw_indirect} to allow the processing of multiple drawing + * commands, whose vertex and index data can be sourced from arbitrary buffer locations, by a single function call.
+ * + *The {@code NV_vertex_buffer_unified_memory} extension provided a mechanism to specify vertex attrib and element array locations using GPU addresses. + * Prior to this extension, these addresses had to be set through explicit function calls. Now the ability to set the pointer addresses indirectly by + * extending the {@link ARBDrawIndirect ARB_draw_indirect} mechanism has been added.
+ * + *Combined with other "bindless" extensions, such as {@link NVBindlessTexture NV_bindless_texture} and {@link NVShaderBufferLoad NV_shader_buffer_load}, it is now possible for the GPU to + * create draw commands that source all resource inputs, which are common to change frequently between draw calls from the GPU: vertex and index buffers, + * samplers, images and other shader input data stored in buffers.
+ * + *Requires {@link GL43 OpenGL 4.3} or {@link ARBMultiDrawIndirect ARB_multi_draw_indirect}, and {@link NVVertexBufferUnifiedMemory NV_vertex_buffer_unified_memory}.
+ */ +public class NVBindlessMultiDrawIndirect { + + static { GL.initialize(); } + + protected NVBindlessMultiDrawIndirect() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glMultiDrawArraysIndirectBindlessNV, caps.glMultiDrawElementsIndirectBindlessNV + ); + } + + // --- [ glMultiDrawArraysIndirectBindlessNV ] --- + + /** Unsafe version of: {@link #glMultiDrawArraysIndirectBindlessNV MultiDrawArraysIndirectBindlessNV} */ + public static native void nglMultiDrawArraysIndirectBindlessNV(int mode, long indirect, int drawCount, int stride, int vertexBufferCount); + + /** + * Behaves similar to {@link GL43C#glMultiDrawArraysIndirect MultiDrawArraysIndirect}, except that {@code indirect} is treated as an array of {@code drawCount} + * {@code DrawArraysIndirectBindlessCommandNV} structures: + * + *
+ * typedef struct {
+ * GLuint index;
+ * GLuint reserved;
+ * GLuint64 address;
+ * GLuint64 length;
+ * } BindlessPtrNV;
+ *
+ * typedef struct {
+ * DrawArraysIndirectCommand cmd;
+ * BindlessPtrNV vertexBuffers[];
+ * } DrawArraysIndirectBindlessCommandNV;| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
+ * typedef struct {
+ * GLuint index;
+ * GLuint reserved;
+ * GLuint64 address;
+ * GLuint64 length;
+ * } BindlessPtrNV;
+ *
+ * typedef struct {
+ * DrawArraysIndirectCommand cmd;
+ * BindlessPtrNV vertexBuffers[];
+ * } DrawArraysIndirectBindlessCommandNV;| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
+ * typedef struct {
+ * GLuint index;
+ * GLuint reserved;
+ * GLuint64 address;
+ * GLuint64 length;
+ * } BindlessPtrNV;
+ *
+ * typedef struct {
+ * DrawElementsIndirectCommand cmd;
+ * GLuint reserved;
+ * BindlessPtrNV indexBuffer;
+ * BindlessPtrNV vertexBuffers[];
+ * } DrawElementsIndirectBindlessCommandNV;| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
+ * typedef struct {
+ * GLuint index;
+ * GLuint reserved;
+ * GLuint64 address;
+ * GLuint64 length;
+ * } BindlessPtrNV;
+ *
+ * typedef struct {
+ * DrawElementsIndirectCommand cmd;
+ * GLuint reserved;
+ * BindlessPtrNV indexBuffer;
+ * BindlessPtrNV vertexBuffers[];
+ * } DrawElementsIndirectBindlessCommandNV;| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
This extension adds the possibility to define the number of drawcalls within a multi-draw-indirect call from the GPU, as provided by + * {@code ARB_indirect_parameters}, for the functions added in {@code NV_bindless_multi_draw_indirect}.
+ * + *Requires {@link NVBindlessMultiDrawIndirect NV_bindless_multi_draw_indirect}, {@link ARBIndirectParameters ARB_indirect_parameters}.
+ */ +public class NVBindlessMultiDrawIndirectCount { + + static { GL.initialize(); } + + protected NVBindlessMultiDrawIndirectCount() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glMultiDrawArraysIndirectBindlessCountNV, caps.glMultiDrawElementsIndirectBindlessCountNV + ); + } + + // --- [ glMultiDrawArraysIndirectBindlessCountNV ] --- + + /** Unsafe version of: {@link #glMultiDrawArraysIndirectBindlessCountNV MultiDrawArraysIndirectBindlessCountNV} */ + public static native void nglMultiDrawArraysIndirectBindlessCountNV(int mode, long indirect, long drawCount, int maxDrawCount, int stride, int vertexBufferCount); + + /** + * Behaves similarly to {@link NVBindlessMultiDrawIndirect#glMultiDrawArraysIndirectBindlessNV MultiDrawArraysIndirectBindlessNV}, except that {@code drawCount} defines an offset (in bytes) into + * the buffer object bound to the PARAMETER_BUFFER_ARB binding point at which a single {@code sizei} typed value is stored, which contains the draw count. + * If the value stored at {@code drawCount} into the buffer is greater than {@code maxDrawCount}, an implementation may stop processing draws after + * {@code maxDrawCount} parameter sets. + * + * @param mode the primitive mode. One of:| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINE_STRIP LINE_STRIP} | {@link GL11#GL_LINE_LOOP LINE_LOOP} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLE_STRIP TRIANGLE_STRIP} | {@link GL11#GL_TRIANGLE_FAN TRIANGLE_FAN} | {@link GL11#GL_TRIANGLES TRIANGLES} |
| {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_LINE_STRIP_ADJACENCY LINE_STRIP_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL32#GL_TRIANGLE_STRIP_ADJACENCY TRIANGLE_STRIP_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} | {@link GL11#GL_POLYGON POLYGON} | {@link GL11#GL_QUADS QUADS} |
| {@link GL11#GL_QUAD_STRIP QUAD_STRIP} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} |
This extension allows OpenGL applications to access texture objects in + * shaders without first binding each texture to one of a limited number of + * texture image units. Using this extension, an application can query a + * 64-bit unsigned integer texture handle for each texture that it wants to + * access and then use that handle directly in GLSL or assembly-based + * shaders. The ability to access textures without having to bind and/or + * re-bind them is similar to the capability provided by the + * NV_shader_buffer_load extension that allows shaders to access buffer + * objects without binding them. In both cases, these extensions + * significantly reduce the amount of API and internal GL driver overhead + * needed to manage resource bindings.
+ * + *This extension also provides similar capability for the image load, store, + * and atomic functionality provided by OpenGL 4.2, OpenGL ES 3.1 and the + * ARB_shader_image_load_store and EXT_shader_image_load_store extensions, + * where a texture can be accessed without first binding it to an image unit. + * An image handle can be extracted from a texture object using an API with a + * set of parameters similar to those for BindImageTextureEXT.
+ * + *This extension adds no new data types to GLSL. Instead, it uses existing + * sampler and image data types and allows them to be populated with texture + * and image handles. This extension does permit sampler and image data + * types to be used in more contexts than in unextended GLSL 4.00. In + * particular, sampler and image types may be used as shader inputs/outputs, + * temporary variables, and uniform block members, and may be assigned to by + * shader code. Constructors are provided to convert 64-bit unsigned integer + * values to and from sampler and image data types. Additionally, new APIs + * are provided to load values for sampler and image uniforms with 64-bit + * handle inputs. The use of existing integer-based Uniform* APIs is still + * permitted, in which case the integer specified will identify a texture + * image or image unit. For samplers and images with values specified as + * texture image or image units, the GL implemenation will translate the unit + * number to an internal handle as required.
+ * + *To access texture or image resources using handles, the handles must first + * be made resident. Accessing a texture or image by handle without first + * making it resident can result in undefined results, including program + * termination. Since the amount of texture memory required by an + * application may exceed the amount of memory available to the system, this + * extension provides API calls allowing applications to manage overall + * texture memory consumption by making a texture resident and non-resident + * as required.
+ * + *Requires {@link GL40 OpenGL 4.0}.
+ */ +public class NVBindlessTexture { + + static { GL.initialize(); } + + protected NVBindlessTexture() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetTextureHandleNV, caps.glGetTextureSamplerHandleNV, caps.glMakeTextureHandleResidentNV, caps.glMakeTextureHandleNonResidentNV, + caps.glGetImageHandleNV, caps.glMakeImageHandleResidentNV, caps.glMakeImageHandleNonResidentNV, caps.glUniformHandleui64NV, + caps.glUniformHandleui64vNV, caps.glProgramUniformHandleui64NV, caps.glProgramUniformHandleui64vNV, caps.glIsTextureHandleResidentNV, + caps.glIsImageHandleResidentNV + ); + } + + // --- [ glGetTextureHandleNV ] --- + + /** + * Creates a texture handle using the current state of the texture named {@code texture}, including any embedded sampler state. See + * {@link #glGetTextureSamplerHandleNV GetTextureSamplerHandleNV} for details. + * + * @param texture the texture object + */ + @NativeType("GLuint64") + public static native long glGetTextureHandleNV(@NativeType("GLuint") int texture); + + // --- [ glGetTextureSamplerHandleNV ] --- + + /** + * Creates a texture handle using the current non-sampler state from the texture named {@code texture} and the sampler state from the sampler object + * {@code sampler}. In both cases, a 64-bit unsigned integer handle is returned. The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated if {@code texture} is zero or is + * not the name of an existing texture object or if {@code sampler} is zero or is not the name of an existing sampler object. The error + * {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if the texture object {@code texture} is not complete. If an error occurs, a handle of zero is returned. + * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if the border color (taken from the embedded sampler for GetTextureHandleNV or from the {@code sampler} + * for GetTextureSamplerHandleNV) is not one of the following allowed values. If the texture's base internal format is signed or unsigned integer, allowed + * values are (0,0,0,0), (0,0,0,1), (1,1,1,0), and (1,1,1,1). If the base internal format is not integer, allowed values are (0.0,0.0,0.0,0.0), + * (0.0,0.0,0.0,1.0), (1.0,1.0,1.0,0.0), and (1.0,1.0,1.0,1.0).
+ * + *The handle for each texture or texture/sampler pair is unique; the same handle will be returned if GetTextureHandleNV is called multiple times for the + * same texture or if GetTextureSamplerHandleNV is called multiple times for the same texture/sampler pair.
+ * + *When a texture object is referenced by one or more texture handles, the texture parameters of the object may not be changed, and the size and format of + * the images in the texture object may not be re-specified. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if the functions TexImage*, CopyTexImage*, + * CompressedTexImage*, TexBuffer*, or TexParameter* are called to modify a texture object referenced by one or more texture handles. The contents of the + * images in a texture object may still be updated via commands such as TexSubImage*, CopyTexSubImage*, and CompressedTexSubImage*, and by rendering to a + * framebuffer object, even if the texture object is referenced by one or more texture handles.
+ * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated by {@link GL15C#glBufferData BufferData} if it is called to modify a buffer object bound to a buffer texture while that + * texture object is referenced by one or more texture handles. The contents of the buffer object may still be updated via buffer update commands such as + * {@link GL15C#glBufferSubData BufferSubData} and MapBuffer*, or via the texture update commands, even if the buffer is bound to a texture while that buffer texture object is + * referenced by one or more texture handles.
+ * + *When a sampler object is referenced by one or more texture handles, the sampler parameters of the object may not be changed. The error + * {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated when calling SamplerParameter* functions to modify a sampler object referenced by one or more texture handles.
+ * + * @param texture the texture object + * @param sampler the sampler object + */ + @NativeType("GLuint64") + public static native long glGetTextureSamplerHandleNV(@NativeType("GLuint") int texture, @NativeType("GLuint") int sampler); + + // --- [ glMakeTextureHandleResidentNV ] --- + + /** + * Make a texture handle resident, so that it is accessible to shaders for texture mapping operations. + * + *While the texture handle is resident, it may be used in texture mapping operations. If a shader attempts to perform a texture mapping operation using a + * handle that is not resident, the results of that operation are undefined and may lead to application termination. When a texture handle is resident, the + * texture it references is also considered resident for the purposes of the {@link GL11#glAreTexturesResident AreTexturesResident} command. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is + * generated if {@code handle} is not a valid texture handle, or if {@code handle} is already resident in the current GL context.
+ * + * @param handle the texture handle + */ + public static native void glMakeTextureHandleResidentNV(@NativeType("GLuint64") long handle); + + // --- [ glMakeTextureHandleNonResidentNV ] --- + + /** + * Makes a texture handle inaccessible to shaders. + * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if {@code handle} is not a valid texture handle, or if {@code handle} is not resident in the current GL + * context.
+ * + * @param handle the texture handle + */ + public static native void glMakeTextureHandleNonResidentNV(@NativeType("GLuint64") long handle); + + // --- [ glGetImageHandleNV ] --- + + /** + * Creates and returns an image handle for level {@code level} of the texture named {@code texture}. If {@code layered} is {@link GL11#GL_TRUE TRUE}, a handle is created + * for the entire texture level. If {@code layered} is {@link GL11#GL_FALSE FALSE}, a handle is created for only the layer {@code layer} of the texture level. + * {@code format} specifies a format used to interpret the texels of the image when used for image loads, stores, and atomics, and has the same meaning as + * the {@code format} parameter of BindImageTextureEXT(). A 64-bit unsigned integer handle is returned if the command succeeds; otherwise, zero is returned. + * + *The error {@link GL11#GL_INVALID_VALUE INVALID_VALUE} is generated by GetImageHandleNV if:
+ * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated by GetImageHandleNV if:
+ * + *When a texture object is referenced by one or more image handles, the texture parameters of the object may not be changed, and the size and format of + * the images in the texture object may not be re-specified. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated when calling TexImage*, CopyTexImage*, + * CompressedTexImage*, TexBuffer*, or TexParameter* functions while a texture object is referenced by one or more image handles. The contents of the + * images in a texture object may still be updated via commands such as TexSubImage*, CopyTexSubImage*, and CompressedTexSubImage*, and by rendering to a + * framebuffer object, even if the texture object is referenced by one or more image handles.
+ * + *The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated by {@link GL15C#glBufferData BufferData} if it is called to modify a buffer object bound to a buffer texture while that texture + * object is referenced by one or more image handles. The contents of the buffer object may still be updated via buffer update commands such as + * {@link GL15C#glBufferSubData BufferSubData} and MapBuffer*, or via the texture update commands, even if the buffer is bound to a texture while that buffer texture object is + * referenced by one or more image handles.
+ * + *The handle returned for each combination of {@code texture}, {@code level}, {@code layered}, {@code layer}, and {@code format} is unique; the same + * handle will be returned if GetImageHandleNV is called multiple times with the same parameters.
+ * + * @param texture the texture object + * @param level the texture level + * @param layered the layered flag + * @param layer the texture layer + * @param format the texture format + */ + @NativeType("GLuint64") + public static native long glGetImageHandleNV(@NativeType("GLuint") int texture, @NativeType("GLint") int level, @NativeType("GLboolean") boolean layered, @NativeType("GLint") int layer, @NativeType("GLenum") int format); + + // --- [ glMakeImageHandleResidentNV ] --- + + /** + * Makes an image handle resident, so that it is accessible to shaders for image loads, stores, and atomic operations. + * + *{@code access} specifies whether the texture bound to the image handle will be treated as {@link GL15#GL_READ_ONLY READ_ONLY}, {@link GL15#GL_WRITE_ONLY WRITE_ONLY}, or {@link GL15#GL_READ_WRITE READ_WRITE}. If a + * shader reads from an image handle made resident as {@link GL15#GL_WRITE_ONLY WRITE_ONLY}, or writes to an image handle made resident as {@link GL15#GL_READ_ONLY READ_ONLY}, the results of that + * shader operation are undefined and may lead to application termination. The error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} is generated if {@code handle} is not a valid + * image handle, or if {@code handle} is already resident in the current GL context.
+ * + *While the image handle is resident, it may be used in image load, store, and atomic operations. If a shader attempts to perform an image operation using + * a handle that is not resident, the results of that operation are undefined and may lead to application termination. When an image handle is resident, + * the texture it references is not necessarily considered resident for the purposes of the {@link GL11#glAreTexturesResident AreTexturesResident} command.
+ * + * @param handle the image handle + * @param access the access type. One of:| {@link GL15#GL_READ_ONLY READ_ONLY} | {@link GL15#GL_WRITE_ONLY WRITE_ONLY} | {@link GL15#GL_READ_WRITE READ_WRITE} |
This extension adds a number of "advanced" blending equations that can be used to perform new color blending operations, many of which are more complex + * than the standard blend modes provided by unextended OpenGL.
+ * + *Provides the new blending equations, but guarantees defined results only if each sample is touched no more than once in any single rendering pass. The + * command {@link #glBlendBarrierNV BlendBarrierNV} is provided to indicate a boundary between passes.
+ * + *Requires {@link GL20 OpenGL 2.0}.
+ */ +public class NVBlendEquationAdvanced { + + /** Accepted by the {@code pname} parameter of BlendParameteriNV, GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int + GL_BLEND_PREMULTIPLIED_SRC_NV = 0x9280, + GL_BLEND_OVERLAP_NV = 0x9281; + + /** Accepted by the {@code value} parameter of BlendParameteriNV when {@code pname} is BLEND_OVERLAP_NV. */ + public static final int + GL_UNCORRELATED_NV = 0x8521, + GL_DISJOINT_NV = 0x9283, + GL_CONJOINT_NV = 0x9284; + + /** Accepted by the {@code mode} parameter of BlendEquation and BlendEquationi. */ + public static final int + GL_SRC_NV = 0x9286, + GL_DST_NV = 0x9287, + GL_SRC_OVER_NV = 0x9288, + GL_DST_OVER_NV = 0x9289, + GL_SRC_IN_NV = 0x928A, + GL_DST_IN_NV = 0x928B, + GL_SRC_OUT_NV = 0x928C, + GL_DST_OUT_NV = 0x928D, + GL_SRC_ATOP_NV = 0x928E, + GL_DST_ATOP_NV = 0x928F, + GL_XOR_NV = 0x1506, + GL_MULTIPLY_NV = 0x9294, + GL_SCREEN_NV = 0x9295, + GL_OVERLAY_NV = 0x9296, + GL_DARKEN_NV = 0x9297, + GL_LIGHTEN_NV = 0x9298, + GL_COLORDODGE_NV = 0x9299, + GL_COLORBURN_NV = 0x929A, + GL_HARDLIGHT_NV = 0x929B, + GL_SOFTLIGHT_NV = 0x929C, + GL_DIFFERENCE_NV = 0x929E, + GL_EXCLUSION_NV = 0x92A0, + GL_INVERT_RGB_NV = 0x92A3, + GL_LINEARDODGE_NV = 0x92A4, + GL_LINEARBURN_NV = 0x92A5, + GL_VIVIDLIGHT_NV = 0x92A6, + GL_LINEARLIGHT_NV = 0x92A7, + GL_PINLIGHT_NV = 0x92A8, + GL_HARDMIX_NV = 0x92A9, + GL_HSL_HUE_NV = 0x92AD, + GL_HSL_SATURATION_NV = 0x92AE, + GL_HSL_COLOR_NV = 0x92AF, + GL_HSL_LUMINOSITY_NV = 0x92B0, + GL_PLUS_NV = 0x9291, + GL_PLUS_CLAMPED_NV = 0x92B1, + GL_PLUS_CLAMPED_ALPHA_NV = 0x92B2, + GL_PLUS_DARKER_NV = 0x9292, + GL_MINUS_NV = 0x929F, + GL_MINUS_CLAMPED_NV = 0x92B3, + GL_CONTRAST_NV = 0x92A1, + GL_INVERT_OVG_NV = 0x92B4, + GL_RED_NV = 0x1903, + GL_GREEN_NV = 0x1904, + GL_BLUE_NV = 0x1905; + + static { GL.initialize(); } + + protected NVBlendEquationAdvanced() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBlendParameteriNV, caps.glBlendBarrierNV + ); + } + + // --- [ glBlendParameteriNV ] --- + + public static native void glBlendParameteriNV(@NativeType("GLenum") int pname, @NativeType("GLint") int value); + + // --- [ glBlendBarrierNV ] --- + + public static native void glBlendBarrierNV(); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVBlendEquationAdvancedCoherent.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVBlendEquationAdvancedCoherent.java new file mode 100644 index 00000000..92975b8f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVBlendEquationAdvancedCoherent.java @@ -0,0 +1,26 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_blend_equation_advanced_coherent extension. + * + *Similar to NV_blend_equation_advanced, but guarantees that blending is done coherently and in API primitive ordering. An enable is provided to allow + * implementations to opt out of fully coherent blending and instead behave as though only NV_blend_equation_advanced were supported.
+ * + *Requires {@link GL20 OpenGL 2.0} and {@link NVBlendEquationAdvanced NV_blend_equation_advanced}.
+ */ +public final class NVBlendEquationAdvancedCoherent { + + /** + * Accepted by the {@code cap} parameter of Disable, Enable, and IsEnabled, and by the {@code pname} parameter of GetIntegerv, GetBooleanv, GetFloatv, GetDoublev + * and GetInteger64v. + */ + public static final int GL_BLEND_ADVANCED_COHERENT_NV = 0x9285; + + private NVBlendEquationAdvancedCoherent() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVBlendMinmaxFactor.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVBlendMinmaxFactor.java new file mode 100644 index 00000000..60e80a73 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVBlendMinmaxFactor.java @@ -0,0 +1,31 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_blend_minmax_factor extension. + * + *The {@link EXTBlendMinmax EXT_blend_minmax} extension extended the GL's blending functionality to allow the blending equation to be specified by the application. That + * extension introduced the {@link EXTBlendMinmax#GL_MIN_EXT MIN_EXT} and {@link EXTBlendMinmax#GL_MAX_EXT MAX_EXT} blend equations, which caused the result of the blend equation to become the minimum or maximum of the + * source color and destination color, respectively.
+ * + *The {@code MIN_EXT} and {@code MAX_EXT} blend equations, however, do not include the source or destination blend factors in the arguments to the min + * and max functions. This extension provides two new blend equations that produce the minimum or maximum of the products of the source color and source + * factor, and the destination color and destination factor.
+ */ +public final class NVBlendMinmaxFactor { + + /** + * Accepted by the {@code mode} parameter of BlendEquation and BlendEquationi, and by the {@code modeRGB} and {@code modeAlpha} parameters of + * BlendEquationSeparate and BlendEquationSeparatei. + */ + public static final int + GL_FACTOR_MIN_AMD = 0x901C, + GL_FACTOR_MAX_AMD = 0x901D; + + private NVBlendMinmaxFactor() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVClipSpaceWScaling.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVClipSpaceWScaling.java new file mode 100644 index 00000000..933cede7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVClipSpaceWScaling.java @@ -0,0 +1,84 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Virtual Reality (VR) applications often involve a post-processing step to apply a "barrel" distortion to the rendered image to correct the "pincushion" + * distortion introduced by the optics in a VR device. The barrel distorted image has lower resolution along the edges compared to the center. Since the + * original image is rendered at high resolution, which is uniform across the complete image, a lot of pixels towards the edges do not make it to the + * final post-processed image. + * + *This extension also provides a mechanism to render VR scenes at a non-uniform resolution, in particular a resolution that falls linearly from the + * center towards the edges. This is achieved by scaling the "w" coordinate of the vertices in the clip space before perspective divide. The clip space + * "w" coordinate of the vertices may be offset as of a function of "x" and "y" coordinates as follows:
+ * + *
+ * w' = w + Ax + ByIn the intended use case for viewport position scaling, an application should use a set of 4 viewports, one for each of the 4 quadrants of a Cartesian + * coordinate system. Each viewport is set to the dimension of the image, but is scissored to the quadrant it represents. The application should specify A + * and B coefficients of the w-scaling equation above, that have the same value, but different signs, for each of the viewports. The signs of A and B + * should match the signs of X and Y for the quadrant that they represent such that the value of "w'" will always be greater than or equal to the original + * "w" value for the entire image. Since the offset to "w", (Ax + By), is always positive and increases with the absolute values of "x" and "y", the + * effective resolution will fall off linearly from the center of the image to its edges.
+ */ +public class NVClipSpaceWScaling { + + /** Accepted by the {@code cap} parameter of Enable, Disable, IsEnabled. */ + public static final int GL_VIEWPORT_POSITION_W_SCALE_NV = 0x937C; + + /** Accepted by the {@code pname} parameter of GetBooleani_v, GetDoublei_v, GetIntegeri_v, GetFloati_v, and GetInteger64i_v. */ + public static final int + GL_VIEWPORT_POSITION_W_SCALE_X_COEFF = 0x937D, + GL_VIEWPORT_POSITION_W_SCALE_Y_COEFF = 0x937E; + + static { GL.initialize(); } + + protected NVClipSpaceWScaling() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glViewportPositionWScaleNV + ); + } + + // --- [ glViewportPositionWScaleNV ] --- + + /** + * If {@link #GL_VIEWPORT_POSITION_W_SCALE_NV VIEWPORT_POSITION_W_SCALE_NV} is enabled, the w coordinates for each primitive sent to a given viewport will be scaled as a function of its x and y + * coordinates using the following equation: + * + *
+ * w' = xcoeff * x + ycoeff * y + w;The coefficients for "x" and "y" used in the above equation depend on the viewport index, and are controlled by this command.
+ * + *The viewport specified by {@code index} has its coefficients for "x" and "y" set to the {@code xcoeff} and {@code ycoeff} values. Specifying these + * coefficients enables rendering images at a non-uniform resolution, in particular a resolution that falls off linearly from the center towards the + * edges, which is useful for VR applications. VR applications often involve a post-processing step to apply a "barrel" distortion to the rendered image + * to correct the "pincushion" distortion introduced by the optics in a VR device. The barrel distorted image, has lower resolution along the edges + * compared to the center. Since the original image is rendered at high resolution, which is uniform across the complete image, a lot of pixels towards + * the edges do not make it to the final post-processed image. VR applications may use the w-scaling to minimize the processing of unused fragments. To + * achieve the intended effect, applications should use a set of 4 viewports one for each of the 4 quadrants of a Cartesian coordinate system. Each + * viewport is set to the dimension of the image, but is scissored to the quadrant it represents. The application should specify the x and y coefficients + * of the w-scaling equation above, that have the same value, but different signs, for each of the viewports. The signs of {@code xcoeff} and + * {@code ycoeff} should match the signs of X and Y for the quadrant that they represent such that the value of "w'" will always be greater than or equal + * to the original "w" value for the entire image. Since the offset to "w", (Ax + By), is always positive and increases with the absolute values of "x" + * and "y", the effective resolution will fall off linearly from the center of the image to its edges.
+ * + * @param index the viewport index + * @param xcoeff the x coefficient + * @param ycoeff the y coefficient + */ + public static native void glViewportPositionWScaleNV(@NativeType("GLuint") int index, @NativeType("GLfloat") float xcoeff, @NativeType("GLfloat") float ycoeff); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVCommandList.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVCommandList.java new file mode 100644 index 00000000..648ea035 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVCommandList.java @@ -0,0 +1,668 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_command_list extension. + * + *This extension adds a few new features designed to provide very low overhead batching and replay of rendering commands and state changes:
+ * + *Because state objects reflect the state of the entire pipeline, it is expected that they can be pre-validated and executed efficiently. It is also + * expected that when state objects are combined into a command list, the command list can diff consecutive state objects to produce a reduced/ optimized + * set of state changes specific to that transition.
+ * + *The token-based command stream can also be stored in regular buffer objects and therefore be modified by the server itself. This allows more complex + * work creation than the original MDI approach, which was limited to emitting draw calls only.
+ * + *
+ * typedef struct {
+ * uint header;
+ * } TerminateSequenceCommandNV;
+ *
+ * typedef struct {
+ * uint header;
+ * } NOPCommandNV;
+ *
+ * typedef struct {
+ * uint header;
+ * uint count;
+ * uint firstIndex;
+ * uint baseVertex;
+ * } DrawElementsCommandNV;
+ *
+ * typedef struct {
+ * uint header;
+ * uint count;
+ * uint first;
+ * } DrawArraysCommandNV;
+ *
+ * typedef struct {
+ * uint header;
+ * uint mode;
+ * uint count;
+ * uint instanceCount;
+ * uint firstIndex;
+ * uint baseVertex;
+ * uint baseInstance;
+ * } DrawElementsInstancedCommandNV;
+ *
+ * typedef struct {
+ * uint header;
+ * uint mode;
+ * uint count;
+ * uint instanceCount;
+ * uint first;
+ * uint baseInstance;
+ * } DrawArraysInstancedCommandNV;
+ *
+ * typedef struct {
+ * uint header;
+ * uint addressLo;
+ * uint addressHi;
+ * uint typeSizeInByte;
+ * } ElementAddressCommandNV;
+ *
+ * typedef struct {
+ * uint header;
+ * uint index;
+ * uint addressLo;
+ * uint addressHi;
+ * } AttributeAddressCommandNV;
+ *
+ * typedef struct {
+ * uint header;
+ * ushort index;
+ * ushort stage;
+ * uint addressLo;
+ * uint addressHi;
+ * } UniformAddressCommandNV;
+ *
+ * typedef struct {
+ * uint header;
+ * float red;
+ * float green;
+ * float blue;
+ * float alpha;
+ * } BlendColorCommandNV;
+ *
+ * typedef struct {
+ * uint header;
+ * uint frontStencilRef;
+ * uint backStencilRef;
+ * } StencilRefCommandNV;
+ *
+ * typedef struct {
+ * uint header;
+ * float lineWidth;
+ * } LineWidthCommandNV;
+ *
+ * typedef struct {
+ * uint header;
+ * float scale;
+ * float bias;
+ * } PolygonOffsetCommandNV;
+ *
+ * typedef struct {
+ * uint header;
+ * float alphaRef;
+ * } AlphaRefCommandNV;
+ *
+ * typedef struct {
+ * uint header;
+ * uint x;
+ * uint y;
+ * uint width;
+ * uint height;
+ * } ViewportCommandNV; // only ViewportIndex 0
+ *
+ * typedef struct {
+ * uint header;
+ * uint x;
+ * uint y;
+ * uint width;
+ * uint height;
+ * } ScissorCommandNV; // only ViewportIndex 0
+ *
+ * typedef struct {
+ * uint header;
+ * uint frontFace; // 0 for CW, 1 for CCW
+ * } FrontFaceCommandNV;Tight packing is used for all structures.
+ */ +public class NVCommandList { + + /** Used in DrawCommandsStates buffer formats, in GetCommandHeaderNV to return the header. */ + public static final int + GL_TERMINATE_SEQUENCE_COMMAND_NV = 0x0, + GL_NOP_COMMAND_NV = 0x1, + GL_DRAW_ELEMENTS_COMMAND_NV = 0x2, + GL_DRAW_ARRAYS_COMMAND_NV = 0x3, + GL_DRAW_ELEMENTS_STRIP_COMMAND_NV = 0x4, + GL_DRAW_ARRAYS_STRIP_COMMAND_NV = 0x5, + GL_DRAW_ELEMENTS_INSTANCED_COMMAND_NV = 0x6, + GL_DRAW_ARRAYS_INSTANCED_COMMAND_NV = 0x7, + GL_ELEMENT_ADDRESS_COMMAND_NV = 0x8, + GL_ATTRIBUTE_ADDRESS_COMMAND_NV = 0x9, + GL_UNIFORM_ADDRESS_COMMAND_NV = 0xA, + GL_BLEND_COLOR_COMMAND_NV = 0xB, + GL_STENCIL_REF_COMMAND_NV = 0xC, + GL_LINE_WIDTH_COMMAND_NV = 0xD, + GL_POLYGON_OFFSET_COMMAND_NV = 0xE, + GL_ALPHA_REF_COMMAND_NV = 0xF, + GL_VIEWPORT_COMMAND_NV = 0x10, + GL_SCISSOR_COMMAND_NV = 0x11, + GL_FRONT_FACE_COMMAND_NV = 0x12; + + static { GL.initialize(); } + + protected NVCommandList() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glCreateStatesNV, caps.glDeleteStatesNV, caps.glIsStateNV, caps.glStateCaptureNV, caps.glGetCommandHeaderNV, caps.glGetStageIndexNV, + caps.glDrawCommandsNV, caps.glDrawCommandsAddressNV, caps.glDrawCommandsStatesNV, caps.glDrawCommandsStatesAddressNV, caps.glCreateCommandListsNV, + caps.glDeleteCommandListsNV, caps.glIsCommandListNV, caps.glListDrawCommandsStatesClientNV, caps.glCommandListSegmentsNV, + caps.glCompileCommandListNV, caps.glCallCommandListNV + ); + } + + // --- [ glCreateStatesNV ] --- + + /** + * Unsafe version of: {@link #glCreateStatesNV CreateStatesNV} + * + * @param n the number of state object names to create + */ + public static native void nglCreateStatesNV(int n, long states); + + /** + * Returns {@code n} previously unused state object names in {@code states}, and creates a state object in the initial state for each name. + * + * @param states the buffer in which to write the created state object names + */ + public static void glCreateStatesNV(@NativeType("GLuint *") IntBuffer states) { + nglCreateStatesNV(states.remaining(), memAddress(states)); + } + + /** Returns {@code n} previously unused state object names in {@code states}, and creates a state object in the initial state for each name. */ + @NativeType("void") + public static int glCreateStatesNV() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer states = stack.callocInt(1); + nglCreateStatesNV(1, memAddress(states)); + return states.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glDeleteStatesNV ] --- + + /** + * Unsafe version of: {@link #glDeleteStatesNV DeleteStatesNV} + * + * @param n the number of state object names to delete + */ + public static native void nglDeleteStatesNV(int n, long states); + + /** + * Deletes {@code n} names of state objects given by {@code states}. Once a state object is deleted it has no contents and its name is again unused. + * Unused names in {@code states} are silently ignored, as is the value zero. + * + * @param states the buffer from which to read the state object names to delete + */ + public static void glDeleteStatesNV(@NativeType("GLuint const *") IntBuffer states) { + nglDeleteStatesNV(states.remaining(), memAddress(states)); + } + + /** + * Deletes {@code n} names of state objects given by {@code states}. Once a state object is deleted it has no contents and its name is again unused. + * Unused names in {@code states} are silently ignored, as is the value zero. + */ + public static void glDeleteStatesNV(@NativeType("GLuint const *") int state) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer states = stack.ints(state); + nglDeleteStatesNV(1, memAddress(states)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glIsStateNV ] --- + + /** + * Returns true if the specified name corresponds to a state object. + * + * @param state the object name to test + */ + @NativeType("GLboolean") + public static native boolean glIsStateNV(@NativeType("GLuint") int state); + + // --- [ glStateCaptureNV ] --- + + /** + * Captures the current state of the rendering pipeline into the object indicated by {@code state}. + * + *The captured rendering state includes:
+ * + *| {@link GL11#GL_POINTS POINTS} | {@link GL11#GL_LINES LINES} | {@link GL11#GL_TRIANGLES TRIANGLES} | {@link GL11#GL_QUADS QUADS} | {@link GL32#GL_LINES_ADJACENCY LINES_ADJACENCY} | {@link GL32#GL_TRIANGLES_ADJACENCY TRIANGLES_ADJACENCY} | {@link GL40#GL_PATCHES PATCHES} |
| {@link #GL_TERMINATE_SEQUENCE_COMMAND_NV TERMINATE_SEQUENCE_COMMAND_NV} | {@link #GL_NOP_COMMAND_NV NOP_COMMAND_NV} | {@link #GL_DRAW_ELEMENTS_COMMAND_NV DRAW_ELEMENTS_COMMAND_NV} |
| {@link #GL_DRAW_ARRAYS_COMMAND_NV DRAW_ARRAYS_COMMAND_NV} | {@link #GL_DRAW_ELEMENTS_STRIP_COMMAND_NV DRAW_ELEMENTS_STRIP_COMMAND_NV} | {@link #GL_DRAW_ARRAYS_STRIP_COMMAND_NV DRAW_ARRAYS_STRIP_COMMAND_NV} |
| {@link #GL_DRAW_ELEMENTS_INSTANCED_COMMAND_NV DRAW_ELEMENTS_INSTANCED_COMMAND_NV} | {@link #GL_DRAW_ARRAYS_INSTANCED_COMMAND_NV DRAW_ARRAYS_INSTANCED_COMMAND_NV} | {@link #GL_ELEMENT_ADDRESS_COMMAND_NV ELEMENT_ADDRESS_COMMAND_NV} |
| {@link #GL_ATTRIBUTE_ADDRESS_COMMAND_NV ATTRIBUTE_ADDRESS_COMMAND_NV} | {@link #GL_UNIFORM_ADDRESS_COMMAND_NV UNIFORM_ADDRESS_COMMAND_NV} | {@link #GL_BLEND_COLOR_COMMAND_NV BLEND_COLOR_COMMAND_NV} |
| {@link #GL_STENCIL_REF_COMMAND_NV STENCIL_REF_COMMAND_NV} | {@link #GL_LINE_WIDTH_COMMAND_NV LINE_WIDTH_COMMAND_NV} | {@link #GL_POLYGON_OFFSET_COMMAND_NV POLYGON_OFFSET_COMMAND_NV} |
| {@link #GL_ALPHA_REF_COMMAND_NV ALPHA_REF_COMMAND_NV} | {@link #GL_VIEWPORT_COMMAND_NV VIEWPORT_COMMAND_NV} | {@link #GL_SCISSOR_COMMAND_NV SCISSOR_COMMAND_NV} |
| {@link #GL_FRONT_FACE_COMMAND_NV FRONT_FACE_COMMAND_NV} |
A list has multiple segments and each segment enqueues an ordered list of command sequences. This command enqueues the equivalent of the + * DrawCommandsStatesNV commands into the list indicated by {@code list} on the segment indicated by {@code segment} except that the sequence data is + * copied from the sequences pointed to by the {@code indirects} pointer. The {@code indirects} pointer should point to a list of size {@code count} of + * pointers, each of which should point to a command sequence.
+ * + *The pre-validated state from {@code states} is saved into the command list, rather than a reference to the state object (i.e. the state objects or fbos + * could be deleted and the command list would be unaffected). This includes native GPU addresses for all textures indirectly referenced through the fbos + * passed or state objects' fbos attachments, therefore a recompile of the command list is required if such referenced textures change their allocation + * (for example due to resizing), as well as explicit management of the residency of the textures prior {@link #glCallCommandListNV CallCommandListNV}.
+ * + *ListDrawCommandsStatesClientNV performs a by-value copy of the indirect data based on the provided client-side pointers. In this case the content is + * fully immutable, while the buffer-based versions can change the content of the buffers at any later time.
+ * + * @param list the command list + * @param segment the segment + * @param indirects the array of GPU addresses + * @param sizes the array of command lengths + * @param states the array of state object names + * @param fbos the array of framebuffer object names + */ + public static void glListDrawCommandsStatesClientNV(@NativeType("GLuint") int list, @NativeType("GLuint") int segment, @NativeType("void const **") PointerBuffer indirects, @NativeType("size_t const *") PointerBuffer sizes, @NativeType("GLuint const *") IntBuffer states, @NativeType("GLuint const *") IntBuffer fbos) { + if (CHECKS) { + check(sizes, indirects.remaining()); + check(states, indirects.remaining()); + check(fbos, indirects.remaining()); + } + nglListDrawCommandsStatesClientNV(list, segment, memAddress(indirects), memAddress(sizes), memAddress(states), memAddress(fbos), indirects.remaining()); + } + + // --- [ glCommandListSegmentsNV ] --- + + /** + * Indicates that {@code list} will have {@code segments} number of segments, each of which is a list of command sequences that it enqueues. This must be + * called before any commands are enqueued. In the initial state, a command list has a single segment. + * + * @param list the command list + * @param segments the number of ordered sequences of commands + */ + public static native void glCommandListSegmentsNV(@NativeType("GLuint") int list, @NativeType("GLuint") int segments); + + // --- [ glCompileCommandListNV ] --- + + /** + * Makes the list indicated by {@code list} switch from allowing collection of commands to allowing its execution. At this time, the implementation may + * generate optimized commands to transition between states as efficiently as possible. + * + * @param list the command list to compile + */ + public static native void glCompileCommandListNV(@NativeType("GLuint") int list); + + // --- [ glCallCommandListNV ] --- + + /** + * Executes the command list indicated by {@code list}, which operates as if the DrawCommandsStates* commands were replayed in the order they were + * enqueued on each segment, starting from segment zero and proceeding to the maximum segment. All buffer or texture resources' residency must be managed + * explicitly, including texture attachments of the effective fbos during list enqueuing. + * + * @param list the command list to call + */ + public static native void glCallCommandListNV(@NativeType("GLuint") int list); + + /** Array version of: {@link #glCreateStatesNV CreateStatesNV} */ + public static void glCreateStatesNV(@NativeType("GLuint *") int[] states) { + long __functionAddress = GL.getICD().glCreateStatesNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(states.length, states, __functionAddress); + } + + /** Array version of: {@link #glDeleteStatesNV DeleteStatesNV} */ + public static void glDeleteStatesNV(@NativeType("GLuint const *") int[] states) { + long __functionAddress = GL.getICD().glDeleteStatesNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(states.length, states, __functionAddress); + } + + /** Array version of: {@link #glDrawCommandsNV DrawCommandsNV} */ + public static void glDrawCommandsNV(@NativeType("GLenum") int primitiveMode, @NativeType("GLuint") int buffer, @NativeType("GLintptr const *") PointerBuffer indirects, @NativeType("GLsizei const *") int[] sizes) { + long __functionAddress = GL.getICD().glDrawCommandsNV; + if (CHECKS) { + check(__functionAddress); + check(sizes, indirects.remaining()); + } + callPPV(primitiveMode, buffer, memAddress(indirects), sizes, indirects.remaining(), __functionAddress); + } + + /** Array version of: {@link #glDrawCommandsAddressNV DrawCommandsAddressNV} */ + public static void glDrawCommandsAddressNV(@NativeType("GLenum") int primitiveMode, @NativeType("GLuint64 const *") long[] indirects, @NativeType("GLsizei const *") int[] sizes) { + long __functionAddress = GL.getICD().glDrawCommandsAddressNV; + if (CHECKS) { + check(__functionAddress); + check(sizes, indirects.length); + } + callPPV(primitiveMode, indirects, sizes, indirects.length, __functionAddress); + } + + /** Array version of: {@link #glDrawCommandsStatesNV DrawCommandsStatesNV} */ + public static void glDrawCommandsStatesNV(@NativeType("GLuint") int buffer, @NativeType("GLintptr const *") PointerBuffer indirects, @NativeType("GLsizei const *") int[] sizes, @NativeType("GLuint const *") int[] states, @NativeType("GLuint const *") int[] fbos) { + long __functionAddress = GL.getICD().glDrawCommandsStatesNV; + if (CHECKS) { + check(__functionAddress); + check(sizes, indirects.remaining()); + check(states, indirects.remaining()); + check(fbos, indirects.remaining()); + } + callPPPPV(buffer, memAddress(indirects), sizes, states, fbos, indirects.remaining(), __functionAddress); + } + + /** Array version of: {@link #glDrawCommandsStatesAddressNV DrawCommandsStatesAddressNV} */ + public static void glDrawCommandsStatesAddressNV(@NativeType("GLuint64 const *") long[] indirects, @NativeType("GLsizei const *") int[] sizes, @NativeType("GLuint const *") int[] states, @NativeType("GLuint const *") int[] fbos) { + long __functionAddress = GL.getICD().glDrawCommandsStatesAddressNV; + if (CHECKS) { + check(__functionAddress); + check(sizes, indirects.length); + check(states, indirects.length); + check(fbos, indirects.length); + } + callPPPPV(indirects, sizes, states, fbos, indirects.length, __functionAddress); + } + + /** Array version of: {@link #glCreateCommandListsNV CreateCommandListsNV} */ + public static void glCreateCommandListsNV(@NativeType("GLuint *") int[] lists) { + long __functionAddress = GL.getICD().glCreateCommandListsNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(lists.length, lists, __functionAddress); + } + + /** Array version of: {@link #glDeleteCommandListsNV DeleteCommandListsNV} */ + public static void glDeleteCommandListsNV(@NativeType("GLuint const *") int[] lists) { + long __functionAddress = GL.getICD().glDeleteCommandListsNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(lists.length, lists, __functionAddress); + } + + /** Array version of: {@link #glListDrawCommandsStatesClientNV ListDrawCommandsStatesClientNV} */ + public static void glListDrawCommandsStatesClientNV(@NativeType("GLuint") int list, @NativeType("GLuint") int segment, @NativeType("void const **") PointerBuffer indirects, @NativeType("size_t const *") PointerBuffer sizes, @NativeType("GLuint const *") int[] states, @NativeType("GLuint const *") int[] fbos) { + long __functionAddress = GL.getICD().glListDrawCommandsStatesClientNV; + if (CHECKS) { + check(__functionAddress); + check(sizes, indirects.remaining()); + check(states, indirects.remaining()); + check(fbos, indirects.remaining()); + } + callPPPPV(list, segment, memAddress(indirects), memAddress(sizes), states, fbos, indirects.remaining(), __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConditionalRender.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConditionalRender.java new file mode 100644 index 00000000..e617f694 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConditionalRender.java @@ -0,0 +1,59 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the NV_conditional_render extension. + * + *This extension provides support for conditional rendering based on the results of an occlusion query. This mechanism allows an application to + * potentially reduce the latency between the completion of an occlusion query and the rendering commands depending on its result. It additionally allows + * the decision of whether to render to be made without application intervention.
+ * + *This extension defines two new functions, {@link #glBeginConditionalRenderNV BeginConditionalRenderNV} and {@link #glEndConditionalRenderNV EndConditionalRenderNV}, between which rendering commands may be discarded + * based on the results of an occlusion query. If the specified occlusion query returns a non-zero value, rendering commands between these calls are + * executed. If the occlusion query returns a value of zero, all rendering commands between the calls are discarded.
+ * + *If the occlusion query results are not available when {@link #glBeginConditionalRenderNV BeginConditionalRenderNV} is executed, the {@code mode} parameter specifies whether the GL + * should wait for the query to complete or should simply render the subsequent geometry unconditionally.
+ * + *Additionally, the extension provides a set of "by region" modes, allowing for implementations that divide rendering work by screen regions to perform + * the conditional query test on a region-by-region basis without checking the query results from other regions. Such a mode is useful for cases like + * split-frame SLI, where a frame is divided between multiple GPUs, each of which has its own occlusion query hardware.
+ */ +public class NVConditionalRender { + + /** Accepted by the {@code mode} parameter of BeginConditionalRenderNV. */ + public static final int + GL_QUERY_WAIT_NV = 0x8E13, + GL_QUERY_NO_WAIT_NV = 0x8E14, + GL_QUERY_BY_REGION_WAIT_NV = 0x8E15, + GL_QUERY_BY_REGION_NO_WAIT_NV = 0x8E16; + + static { GL.initialize(); } + + protected NVConditionalRender() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBeginConditionalRenderNV, caps.glEndConditionalRenderNV + ); + } + + // --- [ glBeginConditionalRenderNV ] --- + + public static native void glBeginConditionalRenderNV(@NativeType("GLuint") int id, @NativeType("GLenum") int mode); + + // --- [ glEndConditionalRenderNV ] --- + + public static native void glEndConditionalRenderNV(); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConservativeRaster.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConservativeRaster.java new file mode 100644 index 00000000..f89a571b --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConservativeRaster.java @@ -0,0 +1,65 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the NV_conservative_raster extension. + * + *This extension adds a "conservative" rasterization mode where any pixel that is partially covered, even if no sample location is covered, is treated as + * fully covered and a corresponding fragment will be shaded.
+ * + *A new control is also added to modify window coordinate snapping precision.
+ * + *These controls can be used to implement "binning" to a low-resolution render target, for example to determine which tiles of a sparse texture need to + * be populated. An app can construct a framebuffer where there is one pixel per tile in the sparse texture, and adjust the number of subpixel bits such + * that snapping occurs to the same effective grid as when rendering to the sparse texture. Then triangles should cover (at least) the same pixels in the + * low-res framebuffer as they do tiles in the sparse texture.
+ */ +public class NVConservativeRaster { + + /** Accepted by the {@code cap} parameter of Enable, Disable, IsEnabled. */ + public static final int GL_CONSERVATIVE_RASTERIZATION_NV = 0x9346; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int + GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV = 0x9347, + GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV = 0x9348, + GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV = 0x9349; + + static { GL.initialize(); } + + protected NVConservativeRaster() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glSubpixelPrecisionBiasNV + ); + } + + // --- [ glSubpixelPrecisionBiasNV ] --- + + /** + * Sets the {@link #GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV SUBPIXEL_PRECISION_BIAS_X_BITS_NV} and {@link #GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV SUBPIXEL_PRECISION_BIAS_Y_BITS_NV} values. + * + *The vertex's window x and y coordinates may be optionally converted to fixed-point values with {@code N} fractional bits. If + * {@link #GL_CONSERVATIVE_RASTERIZATION_NV CONSERVATIVE_RASTERIZATION_NV} is disabled, then {@code N} is the implementation-dependent value of {@link GL11#GL_SUBPIXEL_BITS SUBPIXEL_BITS}. If + * {@link #GL_CONSERVATIVE_RASTERIZATION_NV CONSERVATIVE_RASTERIZATION_NV} is enabled, {@code N} is computed as the sum of the value of {@link GL11#GL_SUBPIXEL_BITS SUBPIXEL_BITS} and programmable values of + * {@link #GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV SUBPIXEL_PRECISION_BIAS_X_BITS_NV} and {@link #GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV SUBPIXEL_PRECISION_BIAS_Y_BITS_NV}.
+ * + *When these values are non-zero, the invariance requirement may not apply because the subpixel precision may not be the same at all window coordinates.
+ * + * @param xbits the {@link #GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV SUBPIXEL_PRECISION_BIAS_X_BITS_NV} value. The initial value is zero. + * @param ybits the {@link #GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV SUBPIXEL_PRECISION_BIAS_Y_BITS_NV} value. The initial value is zero. + */ + public static native void glSubpixelPrecisionBiasNV(@NativeType("GLuint") int xbits, @NativeType("GLuint") int ybits); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConservativeRasterDilate.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConservativeRasterDilate.java new file mode 100644 index 00000000..e5d68db2 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConservativeRasterDilate.java @@ -0,0 +1,48 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the NV_conservative_raster_dilate extension. + * + *This extension extends the conservative rasterization funtionality provided by NV_conservative_raster. It provides a new control to generate an + * "over-conservative" rasterization by dilating primitives prior to rasterization.
+ * + *When using conservative raster to bin geometry, this extension provides a programmable overlap region between adjacent primitives. Regular + * rasterization bins triangles with a shared edge uniquely into pixels. Conservative raster has a one-pixel overlap along the shared edge. Using a + * half-pixel raster dilation, this overlap region increases to two pixels.
+ * + *Requires {@link NVConservativeRaster NV_conservative_raster}.
+ */ +public class NVConservativeRasterDilate { + + /** Accepted by the {@code pname} parameter of ConservativeRasterParameterfNV, GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int + GL_CONSERVATIVE_RASTER_DILATE_NV = 0x9379, + GL_CONSERVATIVE_RASTER_DILATE_RANGE_NV = 0x937A, + GL_CONSERVATIVE_RASTER_DILATE_GRANULARITY_NV = 0x937B; + + static { GL.initialize(); } + + protected NVConservativeRasterDilate() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glConservativeRasterParameterfNV + ); + } + + // --- [ glConservativeRasterParameterfNV ] --- + + public static native void glConservativeRasterParameterfNV(@NativeType("GLenum") int pname, @NativeType("GLfloat") float value); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConservativeRasterPreSnap.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConservativeRasterPreSnap.java new file mode 100644 index 00000000..325f83bf --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConservativeRasterPreSnap.java @@ -0,0 +1,24 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_conservative_raster_pre_snap extension. + * + *{@link NVConservativeRasterPreSnapTriangles NV_conservative_raster_pre_snap_triangles} provides a new mode to achieve rasterization of triangles that is conservative w.r.t the triangle at + * infinite precision i.e. before it is snapped to the sub-pixel grid. This extension provides a new mode that expands this functionality to lines and + * points.
+ * + *Requires {@link NVConservativeRasterPreSnapTriangles NV_conservative_raster_pre_snap_triangles}.
+ */ +public final class NVConservativeRasterPreSnap { + + /** Accepted by the {@code param} parameter of {@link NVConservativeRasterPreSnapTriangles#glConservativeRasterParameteriNV ConservativeRasterParameteriNV} */ + public static final int GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_NV = 0x9550; + + private NVConservativeRasterPreSnap() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConservativeRasterPreSnapTriangles.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConservativeRasterPreSnapTriangles.java new file mode 100644 index 00000000..adae4855 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVConservativeRasterPreSnapTriangles.java @@ -0,0 +1,66 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * When {@link NVConservativeRaster#GL_CONSERVATIVE_RASTERIZATION_NV CONSERVATIVE_RASTERIZATION_NV} is enabled, the fragments generated for a primitive are conservative with respect to the primitive after snapping + * to sub-pixel grid. This extension provides a new mode of rasterization for triangles where the fragments generated are conservative with respect to the + * primitive at infinite precision before vertex snapping. + * + *When the conservative raster mode is set to {@link #GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV}, triangles are rasterized more conservatively, and may + * generate fragments not generated when the mode is {@link #GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV CONSERVATIVE_RASTER_MODE_POST_SNAP_NV} (default). In particular it may generate fragments for pixels + * covered by triangles with zero area, or for pixels that are adjacent to but not covered by any triangle. This modified behavior may be useful in + * compensating for rounding errors caused by snapping vertex positions to a sub-pixel grid during rasterization. It's possible that a non-degenerate + * triangle becomes degenerate due to snapping. It's additionally possible that rounding errors in computing the position of a vertex or from snapping may + * cause a primitive that would cover a pixel at infinite precision to fail to cover the pixel post-snap. Rasterizing such primitives more conservatively + * may be useful for "binning" algorithms described in {@link NVConservativeRaster NV_conservative_raster}.
+ * + *Requires {@link NVConservativeRaster NV_conservative_raster}.
+ */ +public class NVConservativeRasterPreSnapTriangles { + + /** Accepted by the {@code pname} parameter of ConservativeRasterParameteriNV. */ + public static final int GL_CONSERVATIVE_RASTER_MODE_NV = 0x954D; + + /** Accepted by the {@code param} parameter of ConservativeRasterParameteriNV. */ + public static final int + GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV = 0x954E, + GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV = 0x954F; + + static { GL.initialize(); } + + protected NVConservativeRasterPreSnapTriangles() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glConservativeRasterParameteriNV + ); + } + + // --- [ glConservativeRasterParameteriNV ] --- + + /** + * When {@link NVConservativeRaster#GL_CONSERVATIVE_RASTERIZATION_NV CONSERVATIVE_RASTERIZATION_NV} is enabled, the rasterization behavior may be controlled by calling the this command. + * + *If the mode is set to {@link #GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV CONSERVATIVE_RASTER_MODE_POST_SNAP_NV}, the generated fragments are conservative w.r.t the primitive after it is snapped to + * sub-pixel grid. If the mode is set to {@link #GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV} the fragments generated for triangles will be conservative w.r.t + * the triangle at infinite precision. Since non-degenerate triangles may become degenerate due to vertex snapping, this mode will generate fragments for + * zero area triangles that are otherwise culled when the mode is {@link #GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV CONSERVATIVE_RASTER_MODE_POST_SNAP_NV}. This mode may also generate fragments for pixels + * that are within half a sub-pixel distance away from a triangle's infinite precision boundary. The default mode is set to + * {@link #GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV CONSERVATIVE_RASTER_MODE_POST_SNAP_NV}.
+ * + * @param pname the parameter to set. Must be:| {@link #GL_CONSERVATIVE_RASTER_MODE_NV CONSERVATIVE_RASTER_MODE_NV} |
| {@link #GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV CONSERVATIVE_RASTER_MODE_POST_SNAP_NV} |
| {@link #GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV} |
To do this operation in unextended OpenGL, the app must use {@link GL11C#glReadPixels ReadPixels} of {@link GL11#GL_DEPTH_COMPONENT DEPTH_COMPONENT} data, followed by {@link GL11#glDrawPixels DrawPixels} of {@link GL11#GL_RGBA RGBA} + * data. However, this typically will not provide adequate performance.
+ * + *This extension provides a way to copy the depth data directly into the color buffer, by adding two new options for the "type" parameter of + * {@link GL11#glCopyPixels CopyPixels}: {@link #GL_DEPTH_STENCIL_TO_RGBA_NV DEPTH_STENCIL_TO_RGBA_NV} and {@link #GL_DEPTH_STENCIL_TO_BGRA_NV DEPTH_STENCIL_TO_BGRA_NV}.
+ * + *Requires {@link NVPackedDepthStencil NV_packed_depth_stencil}.
+ */ +public final class NVCopyDepthToColor { + + /** Accepted by the {@code type} parameter of CopyPixels. */ + public static final int + GL_DEPTH_STENCIL_TO_RGBA_NV = 0x886E, + GL_DEPTH_STENCIL_TO_BGRA_NV = 0x886F; + + private NVCopyDepthToColor() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVCopyImage.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVCopyImage.java new file mode 100644 index 00000000..e84d468c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVCopyImage.java @@ -0,0 +1,38 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the NV_copy_image extension. + * + *This extension enables efficient image data transfer between image objects (i.e. textures and renderbuffers) without the need to bind the objects or + * otherwise configure the rendering pipeline. The WGL and GLX versions allow copying between images in different contexts, even if those contexts are in + * different sharelists or even on different physical devices.
+ */ +public class NVCopyImage { + + static { GL.initialize(); } + + protected NVCopyImage() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glCopyImageSubDataNV + ); + } + + // --- [ glCopyImageSubDataNV ] --- + + /** Copies a region of texel data between two image objects. An image object may be either a texture or a renderbuffer. */ + public static native void glCopyImageSubDataNV(@NativeType("GLuint") int srcName, @NativeType("GLenum") int srcTarget, @NativeType("GLint") int srcLevel, @NativeType("GLint") int srcX, @NativeType("GLint") int srcY, @NativeType("GLint") int srcZ, @NativeType("GLuint") int dstName, @NativeType("GLenum") int dstTarget, @NativeType("GLint") int dstLevel, @NativeType("GLint") int dstX, @NativeType("GLint") int dstY, @NativeType("GLint") int dstZ, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDeepTexture3D.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDeepTexture3D.java new file mode 100644 index 00000000..088e0f6f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDeepTexture3D.java @@ -0,0 +1,24 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_deep_texture3D extension. + * + *Some applications require 3D textures that have a significant number of slices, but less resolution in width and height. In the current spec, the + * maximum value for the size of all three dimensions is specified by a single value. This extension adds a second set of limits against which 3D textures + * can be checked if an application needs deeper textures than would be allowed by the symmetric texture limits.
+ */ +public final class NVDeepTexture3D { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv and GetFloatv. */ + public static final int + GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV = 0x90D0, + GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV = 0x90D1; + + private NVDeepTexture3D() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDepthBufferFloat.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDepthBufferFloat.java new file mode 100644 index 00000000..fab932e0 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDepthBufferFloat.java @@ -0,0 +1,73 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the NV_depth_buffer_float extension. + * + *This extension provides new texture internal formats whose depth components are stored as 32-bit floating-point values, rather than the normalized + * unsigned integers used in existing depth formats. Floating-point depth textures support all the functionality supported for fixed-point depth textures, + * including shadow mapping and rendering support via EXT_framebuffer_object. Floating-point depth textures can store values outside the range [0,1].
+ * + *By default, OpenGL entry points taking depth values implicitly clamp the values to the range [0,1]. This extension provides new DepthClear, DepthRange, + * and DepthBoundsEXT entry points that allow applications to specify depth values that are not clamped.
+ * + *Additionally, this extension provides new packed depth/stencil pixel formats (see EXT_packed_depth_stencil) that have 64-bit pixels consisting of a + * 32-bit floating-point depth value, 8 bits of stencil, and 24 unused bites. A packed depth/stencil texture internal format is also provided.
+ * + *This extension does not provide support for WGL or GLX pixel formats with floating-point depth buffers. The existing (but not commonly used) + * WGL_EXT_depth_float extension could be used for this purpose.
+ * + *Requires {@link GL20 OpenGL 2.0}, {@link ARBColorBufferFloat ARB_color_buffer_float}, {@link EXTPackedDepthStencil EXT_packed_depth_stencil} and {@link EXTFramebufferObject EXT_framebuffer_object}.
+ */ +public class NVDepthBufferFloat { + + /** + * Accepted by the {@code internalformat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D, and RenderbufferStorageEXT, and + * returned in the {@code data} parameter of GetTexLevelParameter and GetRenderbufferParameterivEXT. + */ + public static final int + GL_DEPTH_COMPONENT32F_NV = 0x8DAB, + GL_DEPTH32F_STENCIL8_NV = 0x8DAC; + + /** + * Accepted by the {@code type} parameter of DrawPixels, ReadPixels, TexImage1D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, and + * GetTexImage. + */ + public static final int GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = 0x8DAD; + + /** Accepted by the {@code pname} parameters of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_DEPTH_BUFFER_FLOAT_MODE_NV = 0x8DAF; + + static { GL.initialize(); } + + protected NVDepthBufferFloat() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDepthRangedNV, caps.glClearDepthdNV, caps.glDepthBoundsdNV + ); + } + + // --- [ glDepthRangedNV ] --- + + public static native void glDepthRangedNV(@NativeType("GLdouble") double zNear, @NativeType("GLdouble") double zFar); + + // --- [ glClearDepthdNV ] --- + + public static native void glClearDepthdNV(@NativeType("GLdouble") double depth); + + // --- [ glDepthBoundsdNV ] --- + + public static native void glDepthBoundsdNV(@NativeType("GLdouble") double zmin, @NativeType("GLdouble") double zmax); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDepthClamp.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDepthClamp.java new file mode 100644 index 00000000..6d020e28 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDepthClamp.java @@ -0,0 +1,36 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_depth_clamp extension. + * + *In some rendering applications such as shadow volumes, it is useful + * to allow line and polygon primitives to be rasterized without + * clipping the primitive to the near or far clip volume planes (side + * clip volume planes clip normally). Without the near and far clip + * planes, rasterization (pixel coverage determination) in X and Y + * can proceed normally if we ignore the near and far clip planes. + * The one major issue is that fragments of a primitive may extend + * beyond the conventional window space depth range for depth values + * (typically the range [0,1]). Rather than discarding fragments that + * defy the window space depth range (effectively what near and far + * plane clipping accomplish), the depth values can be clamped to the + * current depth range.
+ * + *This extension provides exactly such functionality.
+ */ +public final class NVDepthClamp { + + /** + * Accepted by the {@code cap} parameter Enable, Disable, and IsEnabled, + * and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. + */ + public static final int GL_DEPTH_CLAMP_NV = 0x864F; + + private NVDepthClamp() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDrawTexture.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDrawTexture.java new file mode 100644 index 00000000..0406df4c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDrawTexture.java @@ -0,0 +1,42 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the NV_draw_texture extension. + * + *This extension provides a new function, DrawTextureNV(), allowing + * applications to draw an screen-aligned rectangle displaying some or all of + * the contents of a two-dimensional or rectangle texture. Callers specify a + * texture object, an optional sampler object, window coordinates of the + * rectangle to draw, and texture coordinates corresponding to the corners of + * the rectangle. For each fragment produced by the rectangle, DrawTextureNV + * interpolates the texture coordinates, performs a texture lookup, and uses + * the texture result as the fragment color.
+ */ +public class NVDrawTexture { + + static { GL.initialize(); } + + protected NVDrawTexture() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDrawTextureNV + ); + } + + // --- [ glDrawTextureNV ] --- + + public static native void glDrawTextureNV(@NativeType("GLuint") int texture, @NativeType("GLuint") int sampler, @NativeType("GLfloat") float x0, @NativeType("GLfloat") float y0, @NativeType("GLfloat") float x1, @NativeType("GLfloat") float y1, @NativeType("GLfloat") float z, @NativeType("GLfloat") float s0, @NativeType("GLfloat") float t0, @NativeType("GLfloat") float s1, @NativeType("GLfloat") float t1); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDrawVulkanImage.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDrawVulkanImage.java new file mode 100644 index 00000000..510e1625 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVDrawVulkanImage.java @@ -0,0 +1,132 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_draw_vulkan_image extension. + * + *This extension provides a new function, {@link #glDrawVkImageNV DrawVkImageNV}, allowing applications to draw a screen-aligned rectangle displaying some or all of the + * contents of a two-dimensional Vulkan VkImage. Callers specify a Vulkan {@code VkImage} handle, an optional OpenGL sampler object, window coordinates of + * the rectangle to draw, and texture coordinates corresponding to the corners of the rectangle. For each fragment produced by the rectangle, + * {@code DrawVkImageNV} interpolates the texture coordinates, performs a texture lookup, and uses the texture result as the fragment color.
+ * + *No shaders are used by {@code DrawVkImageNV}; the results of the texture lookup are used in lieu of a fragment shader output. The fragments generated + * are processed by all per-fragment operations. In particular, {@code DrawVkImageNV()} fully supports blending and multisampling.
+ * + *In order to synchronize between Vulkan and OpenGL there are three other functions provided; {@link #glWaitVkSemaphoreNV WaitVkSemaphoreNV}, {@link #glSignalVkSemaphoreNV SignalVkSemaphoreNV} and + * {@link #glSignalVkFenceNV SignalVkFenceNV}. These allow OpenGL to wait for Vulkan to complete work and also Vulkan to wait for OpenGL to complete work. Together OpenGL and + * Vulkan can synchronize on the server without application interation.
+ * + *Finally the function {@code GetVkProcAddrNV()} is provided to allow the OpenGL context to query the Vulkan entry points directly and avoid having to + * load them through the typical Vulkan loader.
+ */ +public class NVDrawVulkanImage { + + static { GL.initialize(); } + + protected NVDrawVulkanImage() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDrawVkImageNV, caps.glGetVkProcAddrNV, caps.glWaitVkSemaphoreNV, caps.glSignalVkSemaphoreNV, caps.glSignalVkFenceNV + ); + } + + // --- [ glDrawVkImageNV ] --- + + /** + * Draws a screen-aligned rectangle displaying a portion of the contents of the Vulkan {@code VkImage}. + * + * @param vkImage the Vulkan image handle + * @param sampler an optional sampler object + * @param x0 the rectangle left window coordinate + * @param y0 the rectangle bottom window coordinate + * @param x1 the rectangle right window coordinate + * @param y1 the rectangle top window coordinate + * @param z the Z window coordinate + * @param s0 the left texture coordinate + * @param t0 the bottom texture coordinate + * @param s1 the right texture coordinate + * @param t1 the top texture coordinate + */ + public static native void glDrawVkImageNV(@NativeType("GLuint64") long vkImage, @NativeType("GLuint") int sampler, @NativeType("GLfloat") float x0, @NativeType("GLfloat") float y0, @NativeType("GLfloat") float x1, @NativeType("GLfloat") float y1, @NativeType("GLfloat") float z, @NativeType("GLfloat") float s0, @NativeType("GLfloat") float t0, @NativeType("GLfloat") float s1, @NativeType("GLfloat") float t1); + + // --- [ glGetVkProcAddrNV ] --- + + /** Unsafe version of: {@link #glGetVkProcAddrNV GetVkProcAddrNV} */ + public static native long nglGetVkProcAddrNV(long name); + + /** + * Queries the Vulkan function entry points from within an OpenGL context. + * + * @param name name of the Vulkan function + */ + @NativeType("VULKANPROCNV") + public static long glGetVkProcAddrNV(@NativeType("GLchar const *") ByteBuffer name) { + if (CHECKS) { + checkNT1(name); + } + return nglGetVkProcAddrNV(memAddress(name)); + } + + /** + * Queries the Vulkan function entry points from within an OpenGL context. + * + * @param name name of the Vulkan function + */ + @NativeType("VULKANPROCNV") + public static long glGetVkProcAddrNV(@NativeType("GLchar const *") CharSequence name) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nASCII(name, true); + long nameEncoded = stack.getPointerAddress(); + return nglGetVkProcAddrNV(nameEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glWaitVkSemaphoreNV ] --- + + /** + * Causes the GL server to block until the Vulkan {@code VkSemaphore} is signalled. No GL commands after this command are executed by the server until the + * semaphore is signaled. + * + * @param vkSemaphore a valid Vulkan {@code VkSemaphore} non-dispatchable handle otherwise the operation is undefined + */ + public static native void glWaitVkSemaphoreNV(@NativeType("GLuint64") long vkSemaphore); + + // --- [ glSignalVkSemaphoreNV ] --- + + /** + * Causes the GL server to signal the Vulkan {@code VkSemaphore} when it executes this command. The semaphore is not signalled by GL until all commands + * issued before this have completed execution on the GL server. + * + * @param vkSemaphore a valid Vulkan {@code VkSemaphore} non-dispatchable handle otherwise the operation is undefined + */ + public static native void glSignalVkSemaphoreNV(@NativeType("GLuint64") long vkSemaphore); + + // --- [ glSignalVkFenceNV ] --- + + /** + * Causes the GL server to signal the Vulkan {@code VkFence} object when it executes this command. The fence is not signalled by the GL until all commands + * issued before this have completed execution on the GL server. + * + * @param vkFence a valid Vulkan VkFence non-dispatcable handle otherwise the operation is undefined + */ + public static native void glSignalVkFenceNV(@NativeType("GLuint64") long vkFence); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVExplicitMultisample.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVExplicitMultisample.java new file mode 100644 index 00000000..a2b9bdbc --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVExplicitMultisample.java @@ -0,0 +1,102 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_explicit_multisample extension. + * + *In traditional multisample specs, the API only allows access to the samples indirectly through methods such as coverage values and downsampled + * readbacks. NV_explicit_multisample adds a set of new capabilities to allow more precise control over the use of multisamples. Specifically, it adds:
+ * + *Requires {@link GL20 OpenGL 2.0} and {@link ARBMultisample ARB_multisample}.
+ */ +public class NVExplicitMultisample { + + /** Accepted by the {@code pname} parameter of GetMultisamplefvNV. */ + public static final int GL_SAMPLE_POSITION_NV = 0x8E50; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_SAMPLE_MASK_NV = 0x8E51; + + /** Accepted by the {@code pname} parameter of GetBooleanIndexedvEXT and GetIntegerIndexedvEXT. */ + public static final int GL_SAMPLE_MASK_VALUE_NV = 0x8E52; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int + GL_TEXTURE_BINDING_RENDERBUFFER_NV = 0x8E53, + GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV = 0x8E54, + GL_MAX_SAMPLE_MASK_WORDS_NV = 0x8E59; + + /** Accepted by the {@code target} parameter of BindTexture, and TexRenderbufferNV. */ + public static final int GL_TEXTURE_RENDERBUFFER_NV = 0x8E55; + + /** Returned by the {@code type} parameter of GetActiveUniform. */ + public static final int + GL_SAMPLER_RENDERBUFFER_NV = 0x8E56, + GL_INT_SAMPLER_RENDERBUFFER_NV = 0x8E57, + GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV = 0x8E58; + + static { GL.initialize(); } + + protected NVExplicitMultisample() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetMultisamplefvNV, caps.glSampleMaskIndexedNV, caps.glTexRenderbufferNV + ); + } + + // --- [ glGetMultisamplefvNV ] --- + + public static native void nglGetMultisamplefvNV(int pname, int index, long val); + + public static void glGetMultisamplefvNV(@NativeType("GLenum") int pname, @NativeType("GLuint") int index, @NativeType("GLfloat *") FloatBuffer val) { + if (CHECKS) { + check(val, 2); + } + nglGetMultisamplefvNV(pname, index, memAddress(val)); + } + + // --- [ glSampleMaskIndexedNV ] --- + + public static native void glSampleMaskIndexedNV(@NativeType("GLuint") int index, @NativeType("GLbitfield") int mask); + + // --- [ glTexRenderbufferNV ] --- + + public static native void glTexRenderbufferNV(@NativeType("GLenum") int target, @NativeType("GLuint") int renderbuffer); + + /** Array version of: {@link #glGetMultisamplefvNV GetMultisamplefvNV} */ + public static void glGetMultisamplefvNV(@NativeType("GLenum") int pname, @NativeType("GLuint") int index, @NativeType("GLfloat *") float[] val) { + long __functionAddress = GL.getICD().glGetMultisamplefvNV; + if (CHECKS) { + check(__functionAddress); + check(val, 2); + } + callPV(pname, index, val, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFence.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFence.java new file mode 100644 index 00000000..5dff612c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFence.java @@ -0,0 +1,165 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_fence extension. + * + *The goal of this extension is provide a finer granularity of synchronizing GL command completion than offered by standard OpenGL, which offers only two + * mechanisms for synchronization: Flush and Finish. Since Flush merely assures the user that the commands complete in a finite (though undetermined) + * amount of time, it is, thus, of only modest utility. Finish, on the other hand, stalls CPU execution until all pending GL commands have completed. This + * extension offers a middle ground - the ability to "finish" a subset of the command stream, and the ability to determine whether a given command has + * completed or not.
+ * + *This extension introduces the concept of a "fence" to the OpenGL command stream. Once the fence is inserted into the command stream, it can be queried + * for a given condition - typically, its completion. Moreover, the application may also request a partial Finish -- that is, all commands prior to the + * fence will be forced to complete until control is returned to the calling process. These new mechanisms allow for synchronization between the host CPU + * and the GPU, which may be accessing the same resources (typically memory).
+ * + *This extension is useful in conjunction with NV_vertex_array_range to determine when vertex information has been pulled from the vertex array range. + * Once a fence has been tested TRUE or finished, all vertex indices issued before the fence must have been pulled. This ensures that the vertex data + * memory corresponding to the issued vertex indices can be safely modified (assuming no other outstanding vertex indices are issued subsequent to the + * fence).
+ */ +public class NVFence { + + /** Accepted by the {@code condition} parameter of SetFenceNV. */ + public static final int GL_ALL_COMPLETED_NV = 0x84F2; + + /** Accepted by the {@code pname} parameter of GetFenceivNV. */ + public static final int + GL_FENCE_STATUS_NV = 0x84F3, + GL_FENCE_CONDITION_NV = 0x84F4; + + static { GL.initialize(); } + + protected NVFence() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDeleteFencesNV, caps.glGenFencesNV, caps.glIsFenceNV, caps.glTestFenceNV, caps.glGetFenceivNV, caps.glFinishFenceNV, caps.glSetFenceNV + ); + } + + // --- [ glDeleteFencesNV ] --- + + public static native void nglDeleteFencesNV(int n, long fences); + + public static void glDeleteFencesNV(@NativeType("GLuint const *") IntBuffer fences) { + nglDeleteFencesNV(fences.remaining(), memAddress(fences)); + } + + public static void glDeleteFencesNV(@NativeType("GLuint const *") int fence) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer fences = stack.ints(fence); + nglDeleteFencesNV(1, memAddress(fences)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGenFencesNV ] --- + + public static native void nglGenFencesNV(int n, long fences); + + public static void glGenFencesNV(@NativeType("GLuint *") IntBuffer fences) { + nglGenFencesNV(fences.remaining(), memAddress(fences)); + } + + @NativeType("void") + public static int glGenFencesNV() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer fences = stack.callocInt(1); + nglGenFencesNV(1, memAddress(fences)); + return fences.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glIsFenceNV ] --- + + @NativeType("GLboolean") + public static native boolean glIsFenceNV(@NativeType("GLuint") int fence); + + // --- [ glTestFenceNV ] --- + + @NativeType("GLboolean") + public static native boolean glTestFenceNV(@NativeType("GLuint") int fence); + + // --- [ glGetFenceivNV ] --- + + public static native void nglGetFenceivNV(int fence, int pname, long params); + + public static void glGetFenceivNV(@NativeType("GLuint") int fence, @NativeType("GLenum") int pname, @NativeType("GLint *") IntBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetFenceivNV(fence, pname, memAddress(params)); + } + + @NativeType("void") + public static int glGetFenceiNV(@NativeType("GLuint") int fence, @NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer params = stack.callocInt(1); + nglGetFenceivNV(fence, pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glFinishFenceNV ] --- + + public static native void glFinishFenceNV(@NativeType("GLuint") int fence); + + // --- [ glSetFenceNV ] --- + + public static native void glSetFenceNV(@NativeType("GLuint") int fence, @NativeType("GLenum") int condition); + + /** Array version of: {@link #glDeleteFencesNV DeleteFencesNV} */ + public static void glDeleteFencesNV(@NativeType("GLuint const *") int[] fences) { + long __functionAddress = GL.getICD().glDeleteFencesNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(fences.length, fences, __functionAddress); + } + + /** Array version of: {@link #glGenFencesNV GenFencesNV} */ + public static void glGenFencesNV(@NativeType("GLuint *") int[] fences) { + long __functionAddress = GL.getICD().glGenFencesNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(fences.length, fences, __functionAddress); + } + + /** Array version of: {@link #glGetFenceivNV GetFenceivNV} */ + public static void glGetFenceivNV(@NativeType("GLuint") int fence, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] params) { + long __functionAddress = GL.getICD().glGetFenceivNV; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(fence, pname, params, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFillRectangle.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFillRectangle.java new file mode 100644 index 00000000..88be949f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFillRectangle.java @@ -0,0 +1,22 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_fill_rectangle extension. + * + *This extension adds a new {@link GL11C#glPolygonMode PolygonMode} setting where a triangle is rasterized by computing and filling its axis-aligned screen-space bounding + * box, disregarding the actual triangle edges. This can be useful for drawing a rectangle without being split into two triangles with an internal edge. + * It is also useful to minimize the number of primitives that need to be drawn, particularly for a user-interface.
+ */ +public final class NVFillRectangle { + + /** Accepted by the {@code mode} parameter of PolygonMode. */ + public static final int GL_FILL_RECTANGLE_NV = 0x933C; + + private NVFillRectangle() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFloatBuffer.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFloatBuffer.java new file mode 100644 index 00000000..b91aa09b --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFloatBuffer.java @@ -0,0 +1,41 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_float_buffer extension. + * + *This extension builds upon NV_fragment_program to provide a framebuffer and texture format that allows fragment programs to read and write + * unconstrained floating point data.
+ */ +public final class NVFloatBuffer { + + /** Accepted by the {@code internalformat} parameter of TexImage2D and CopyTexImage2D. */ + public static final int + GL_FLOAT_R_NV = 0x8880, + GL_FLOAT_RG_NV = 0x8881, + GL_FLOAT_RGB_NV = 0x8882, + GL_FLOAT_RGBA_NV = 0x8883, + GL_FLOAT_R16_NV = 0x8884, + GL_FLOAT_R32_NV = 0x8885, + GL_FLOAT_RG16_NV = 0x8886, + GL_FLOAT_RG32_NV = 0x8887, + GL_FLOAT_RGB16_NV = 0x8888, + GL_FLOAT_RGB32_NV = 0x8889, + GL_FLOAT_RGBA16_NV = 0x888A, + GL_FLOAT_RGBA32_NV = 0x888B; + + /** Accepted by the {@code pname} parameter of GetTexLevelParameterfv and GetTexLevelParameteriv. */ + public static final int GL_TEXTURE_FLOAT_COMPONENTS_NV = 0x888C; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_FLOAT_CLEAR_COLOR_VALUE_NV = 0x888D, + GL_FLOAT_RGBA_MODE_NV = 0x888E; + + private NVFloatBuffer() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFogDistance.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFogDistance.java new file mode 100644 index 00000000..a28060e1 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFogDistance.java @@ -0,0 +1,44 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_fog_distance extension. + * + *Ideally, the fog distance (used to compute the fog factor as described in Section 3.10) should be computed as the per-fragment Euclidean distance to + * the fragment center from the eye. In practice, implementations "may choose to approximate the eye-coordinate distance from the eye to each fragment + * center by abs(ze). Further, [the fog factor] f need not be computed at each fragment, but may be computed at each vertex and interpolated as other data + * are."
+ * + *This extension provides the application specific control over how OpenGL computes the distance used in computing the fog factor.
+ * + *The extension supports three fog distance modes: "eye plane absolute", where the fog distance is the absolute planar distance from the eye plane (i.e., + * OpenGL's standard implementation allowance as cited above); "eye plane", where the fog distance is the signed planar distance from the eye plane; and + * "eye radial", where the fog distance is computed as a Euclidean distance. In the case of the eye radial fog distance mode, the distance may be computed + * per-vertex and then interpolated per-fragment.
+ * + *The intent of this extension is to provide applications with better control over the tradeoff between performance and fog quality. The "eye planar" + * modes (signed or absolute) are straightforward to implement with good performance, but scenes are consistently under-fogged at the edges of the field + * of view. The "eye radial" mode can provide for more accurate fog at the edges of the field of view, but this assumes that either the eye radial fog + * distance is computed per-fragment, or if the fog distance is computed per-vertex and then interpolated per-fragment, then the scene must be + * sufficiently tessellated.
+ */ +public final class NVFogDistance { + + /** Accepted by the {@code pname} parameters of Fogf, Fogi, Fogfv, Fogiv, GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_FOG_DISTANCE_MODE_NV = 0x855A; + + /** + * When the {@code pname} parameter of Fogf, Fogi, Foggv, and Fogiv, is FOG_DISTANCE_MODE_NV, then the value of {@code param} or the value pointed to by + * {@code params} may be. + */ + public static final int + GL_EYE_RADIAL_NV = 0x855B, + GL_EYE_PLANE_ABSOLUTE_NV = 0x855C; + + private NVFogDistance() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFragmentCoverageToColor.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFragmentCoverageToColor.java new file mode 100644 index 00000000..48ab0cb1 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFragmentCoverageToColor.java @@ -0,0 +1,49 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the NV_fragment_coverage_to_color extension. + * + *This extension allows the fragment coverage value, represented as an + * integer bitfield, to be substituted for a color output being written to a + * single-component color buffer with integer components (e.g., R8UI). The + * capability provided by this extension is different from simply writing the + * gl_SampleMask fragment shader output in that the coverage value written to + * the framebuffer is taken after alpha test, stencil test, and depth test, + * as well as after the multisample fragment operations such as + * alpha-to-coverage.
+ */ +public class NVFragmentCoverageToColor { + + /** Accepted by the {@code cap} parameter of Enable, Disable, IsEnabled. */ + public static final int GL_FRAGMENT_COVERAGE_TO_COLOR_NV = 0x92DD; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int GL_FRAGMENT_COVERAGE_COLOR_NV = 0x92DE; + + static { GL.initialize(); } + + protected NVFragmentCoverageToColor() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glFragmentCoverageColorNV + ); + } + + // --- [ glFragmentCoverageColorNV ] --- + + /** @param color the draw buffer index that the coverage value will be written to. Must be between 0 and the value of MAX_DRAW_BUFFERS minus one, inclusive. */ + public static native void glFragmentCoverageColorNV(@NativeType("GLuint") int color); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFramebufferMixedSamples.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFramebufferMixedSamples.java new file mode 100644 index 00000000..3c778879 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFramebufferMixedSamples.java @@ -0,0 +1,143 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_framebuffer_mixed_samples extension. + * + *This extension allows multisample rendering with a raster and + * depth/stencil sample count that is larger than the color sample count. + * Rasterization and the results of the depth and stencil tests together + * determine the portion of a pixel that is "covered". It can be useful to + * evaluate coverage at a higher frequency than color samples are stored. + * This coverage is then "reduced" to a collection of covered color samples, + * each having an opacity value corresponding to the fraction of the color + * sample covered. The opacity can optionally be blended into individual + * color samples.
+ */ +public class NVFramebufferMixedSamples { + + /** Accepted by the {@code cap} parameter of Enable, Disable, IsEnabled. */ + public static final int + GL_RASTER_MULTISAMPLE_EXT = 0x9327, + GL_COVERAGE_MODULATION_TABLE_NV = 0x9331; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int + GL_RASTER_SAMPLES_EXT = 0x9328, + GL_MAX_RASTER_SAMPLES_EXT = 0x9329, + GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT = 0x932A, + GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT = 0x932B, + GL_EFFECTIVE_RASTER_SAMPLES_EXT = 0x932C, + GL_COLOR_SAMPLES_NV = 0x8E20, + GL_DEPTH_SAMPLES_NV = 0x932D, + GL_STENCIL_SAMPLES_NV = 0x932E, + GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV = 0x932F, + GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV = 0x9330, + GL_COVERAGE_MODULATION_NV = 0x9332, + GL_COVERAGE_MODULATION_TABLE_SIZE_NV = 0x9333; + + static { GL.initialize(); } + + protected NVFramebufferMixedSamples() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glRasterSamplesEXT, caps.glCoverageModulationTableNV, caps.glGetCoverageModulationTableNV, caps.glCoverageModulationNV + ); + } + + // --- [ glRasterSamplesEXT ] --- + + /** + * Selects the number of samples to be used for rasterization. {@code samples} represents a request for a desired minimum number of samples. Since + * different implementations may support different sample counts, the actual sample pattern used is implementation-dependent. However, the resulting value + * for {@link EXTRasterMultisample#GL_RASTER_SAMPLES_EXT RASTER_SAMPLES_EXT} is guaranteed to be greater than or equal to {@code samples} and no more than the next larger sample count supported by the + * implementation. If {@code fixedsamplelocations} is {@link GL11#GL_TRUE TRUE}, identical sample locations will be used for all pixels. The sample locations chosen are a + * function of only the parameters to RasterSamplesEXT and not of any other state. + * + *If {@link EXTRasterMultisample#GL_RASTER_MULTISAMPLE_EXT RASTER_MULTISAMPLE_EXT} is enabled, then the sample pattern chosen by RasterSamplesEXT will be used instead of sampling at the center of the pixel. + * The sample locations can be queried with {@link GL32C#glGetMultisamplefv GetMultisamplefv} with a {@code pname} of {@link GL32#GL_SAMPLE_POSITION SAMPLE_POSITION}, similar to normal multisample sample + * locations.
+ * + *The value {@link EXTRasterMultisample#GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT MULTISAMPLE_RASTERIZATION_ALLOWED_EXT} is {@link GL11#GL_TRUE TRUE} if {@link GL13#GL_SAMPLE_BUFFERS SAMPLE_BUFFERS} is one or if {@link EXTRasterMultisample#GL_RASTER_MULTISAMPLE_EXT RASTER_MULTISAMPLE_EXT} is enabled. The value + * {@link EXTRasterMultisample#GL_EFFECTIVE_RASTER_SAMPLES_EXT EFFECTIVE_RASTER_SAMPLES_EXT} is equal to {@link EXTRasterMultisample#GL_RASTER_SAMPLES_EXT RASTER_SAMPLES_EXT} if {@link EXTRasterMultisample#GL_RASTER_MULTISAMPLE_EXT RASTER_MULTISAMPLE_EXT} is enabled, otherwise is equal to {@link GL13#GL_SAMPLES SAMPLES}.
+ * + *Explicit multisample rasterization can not be used in conjunction with depth, stencil, or depth bounds tests, multisample framebuffers, or if + * {@link EXTRasterMultisample#GL_RASTER_SAMPLES_EXT RASTER_SAMPLES_EXT} is zero. If {@link EXTRasterMultisample#GL_RASTER_MULTISAMPLE_EXT RASTER_MULTISAMPLE_EXT} is enabled, the error {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} will be generated by Draw commands if
+ * + *An {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if {@code samples} is greater than the value of {@link EXTRasterMultisample#GL_MAX_RASTER_SAMPLES_EXT MAX_RASTER_SAMPLES_EXT} (the implementation-dependent maximum + * number of samples).
+ * + * @param samples the number of samples to be used for rasterization + * @param fixedsamplelocations if {@link GL11#GL_TRUE TRUE}, identical sample locations will be used for all pixels + */ + public static void glRasterSamplesEXT(@NativeType("GLuint") int samples, @NativeType("GLboolean") boolean fixedsamplelocations) { + EXTRasterMultisample.glRasterSamplesEXT(samples, fixedsamplelocations); + } + + // --- [ glCoverageModulationTableNV ] --- + + /** + * Unsafe version of: {@link #glCoverageModulationTableNV CoverageModulationTableNV} + * + * @param n The size of the coverage modulation table. Must be equal to the value of COVERAGE_MODULATION_TABLE_SIZE_NV. + */ + public static native void nglCoverageModulationTableNV(int n, long v); + + public static void glCoverageModulationTableNV(@NativeType("GLfloat const *") FloatBuffer v) { + nglCoverageModulationTableNV(v.remaining(), memAddress(v)); + } + + // --- [ glGetCoverageModulationTableNV ] --- + + public static native void nglGetCoverageModulationTableNV(int bufsize, long v); + + public static void glGetCoverageModulationTableNV(@NativeType("GLfloat *") FloatBuffer v) { + nglGetCoverageModulationTableNV(v.remaining(), memAddress(v)); + } + + // --- [ glCoverageModulationNV ] --- + + public static native void glCoverageModulationNV(@NativeType("GLenum") int components); + + /** Array version of: {@link #glCoverageModulationTableNV CoverageModulationTableNV} */ + public static void glCoverageModulationTableNV(@NativeType("GLfloat const *") float[] v) { + long __functionAddress = GL.getICD().glCoverageModulationTableNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(v.length, v, __functionAddress); + } + + /** Array version of: {@link #glGetCoverageModulationTableNV GetCoverageModulationTableNV} */ + public static void glGetCoverageModulationTableNV(@NativeType("GLfloat *") float[] v) { + long __functionAddress = GL.getICD().glGetCoverageModulationTableNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(v.length, v, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFramebufferMultisampleCoverage.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFramebufferMultisampleCoverage.java new file mode 100644 index 00000000..90797f73 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVFramebufferMultisampleCoverage.java @@ -0,0 +1,56 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the NV_framebuffer_multisample_coverage extension. + * + *This extension extends the EXT_framebuffer_multisample specification by providing a new function, RenderBufferStorageMultisampleCoverageNV, that + * distinguishes between color samples and coverage samples.
+ * + *EXT_framebuffer_multisample introduced the function RenderbufferStorageMultisampleEXT as a method of defining the storage parameters for a multisample + * render buffer. This function takes a {@code samples} parameter. Using rules provided by the specification, the {@code samples} parameter is resolved to + * an actual number of samples that is supported by the underlying hardware. EXT_framebuffer_multisample does not specify whether {@code samples} refers + * to coverage samples or color samples.
+ * + *This extension adds the function RenderbufferStorageMultisamplCoverageNV, which takes a {@code coverageSamples} parameter as well as a + * {@code colorSamples} parameter. These two parameters give developers more fine grained control over the quality of multisampled images.
+ * + *Requires {@link EXTFramebufferObject EXT_framebuffer_object}, {@link EXTFramebufferBlit EXT_framebuffer_blit} and {@link EXTFramebufferMultisample EXT_framebuffer_multisample}.
+ */ +public class NVFramebufferMultisampleCoverage { + + /** Accepted by the {@code pname} parameter of GetRenderbufferParameterivEXT. */ + public static final int + GL_RENDERBUFFER_COVERAGE_SAMPLES_NV = 0x8CAB, + GL_RENDERBUFFER_COLOR_SAMPLES_NV = 0x8E10; + + /** Accepted by the {@code pname} parameter of GetIntegerv. */ + public static final int + GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E11, + GL_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E12; + + static { GL.initialize(); } + + protected NVFramebufferMultisampleCoverage() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glRenderbufferStorageMultisampleCoverageNV + ); + } + + // --- [ glRenderbufferStorageMultisampleCoverageNV ] --- + + public static native void glRenderbufferStorageMultisampleCoverageNV(@NativeType("GLenum") int target, @NativeType("GLsizei") int coverageSamples, @NativeType("GLsizei") int colorSamples, @NativeType("GLenum") int internalformat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVGPUMulticast.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVGPUMulticast.java new file mode 100644 index 00000000..73f4ea30 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVGPUMulticast.java @@ -0,0 +1,315 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_gpu_multicast extension. + * + *This extension enables novel multi-GPU rendering techniques by providing application control over a group of linked GPUs with identical hardware + * configuration.
+ * + *Multi-GPU rendering techniques fall into two categories: implicit and explicit. Existing explicit approaches like {@link WGLNVGPUAffinity WGL_NV_gpu_affinity} have two + * main drawbacks: CPU overhead and application complexity. An application must manage one context per GPU and multi-pump the API stream. Implicit + * multi-GPU rendering techniques avoid these issues by broadcasting rendering from one context to multiple GPUs. Common implicit approaches include + * alternate-frame rendering (AFR), split-frame rendering (SFR) and multi-GPU anti-aliasing. They each have drawbacks. AFR scales nicely but interacts + * poorly with inter-frame dependencies. SFR can improve latency but has challenges with offscreen rendering and scaling of vertex processing. With + * multi-GPU anti-aliasing, each GPU renders the same content with alternate sample positions and the driver blends the result to improve quality. This + * also has issues with offscreen rendering and can conflict with other anti-aliasing techniques.
+ * + *These issues with implicit multi-GPU rendering all have the same root cause: the driver lacks adequate knowledge to accelerate every application. To + * resolve this, NV_gpu_multicast provides fine-grained, explicit application control over multiple GPUs with a single context.
+ * + *Key points:
+ * + *Requires {@link ARBCopyImage ARB_copy_image} and {@link EXTDirectStateAccess EXT_direct_state_access}.
+ */ +public class NVGPUMulticast { + + /** Accepted in the {@code flags} parameter of BufferStorage and NamedBufferStorageEXT. */ + public static final int GL_PER_GPU_STORAGE_BIT_NV = 0x800; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int + GL_MULTICAST_GPUS_NV = 0x92BA, + GL_RENDER_GPU_MASK_NV = 0x9558; + + /** + * Accepted as a value for {@code pname} for the TexParameter{if}, TexParameter{if}v, TextureParameter{if}, TextureParameter{if}v, MultiTexParameter{if}EXT + * and MultiTexParameter{if}vEXT commands and for the {@code value} parameter of GetTexParameter{if}v, GetTextureParameter{if}vEXT and + * GetMultiTexParameter{if}vEXT. + */ + public static final int GL_PER_GPU_STORAGE_NV = 0x9548; + + /** Accepted by the {@code pname} parameter of GetMultisamplefv. */ + public static final int GL_MULTICAST_PROGRAMMABLE_SAMPLE_LOCATION_NV = 0x9549; + + static { GL.initialize(); } + + protected NVGPUMulticast() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glRenderGpuMaskNV, caps.glMulticastBufferSubDataNV, caps.glMulticastCopyBufferSubDataNV, caps.glMulticastCopyImageSubDataNV, + caps.glMulticastBlitFramebufferNV, caps.glMulticastFramebufferSampleLocationsfvNV, caps.glMulticastBarrierNV, caps.glMulticastWaitSyncNV, + caps.glMulticastGetQueryObjectivNV, caps.glMulticastGetQueryObjectuivNV, caps.glMulticastGetQueryObjecti64vNV, + caps.glMulticastGetQueryObjectui64vNV + ); + } + + // --- [ glRenderGpuMaskNV ] --- + + /** Restricts render commands to a specific set of GPUs. */ + public static native void glRenderGpuMaskNV(@NativeType("GLbitfield") int mask); + + // --- [ glMulticastBufferSubDataNV ] --- + + public static native void nglMulticastBufferSubDataNV(int gpuMask, int buffer, long offset, long size, long data); + + public static void glMulticastBufferSubDataNV(@NativeType("GLbitfield") int gpuMask, @NativeType("GLuint") int buffer, @NativeType("GLintptr") long offset, @NativeType("void const *") ByteBuffer data) { + nglMulticastBufferSubDataNV(gpuMask, buffer, offset, data.remaining(), memAddress(data)); + } + + public static void glMulticastBufferSubDataNV(@NativeType("GLbitfield") int gpuMask, @NativeType("GLuint") int buffer, @NativeType("GLintptr") long offset, @NativeType("void const *") ShortBuffer data) { + nglMulticastBufferSubDataNV(gpuMask, buffer, offset, Integer.toUnsignedLong(data.remaining()) << 1, memAddress(data)); + } + + public static void glMulticastBufferSubDataNV(@NativeType("GLbitfield") int gpuMask, @NativeType("GLuint") int buffer, @NativeType("GLintptr") long offset, @NativeType("void const *") IntBuffer data) { + nglMulticastBufferSubDataNV(gpuMask, buffer, offset, Integer.toUnsignedLong(data.remaining()) << 2, memAddress(data)); + } + + public static void glMulticastBufferSubDataNV(@NativeType("GLbitfield") int gpuMask, @NativeType("GLuint") int buffer, @NativeType("GLintptr") long offset, @NativeType("void const *") FloatBuffer data) { + nglMulticastBufferSubDataNV(gpuMask, buffer, offset, Integer.toUnsignedLong(data.remaining()) << 2, memAddress(data)); + } + + public static void glMulticastBufferSubDataNV(@NativeType("GLbitfield") int gpuMask, @NativeType("GLuint") int buffer, @NativeType("GLintptr") long offset, @NativeType("void const *") DoubleBuffer data) { + nglMulticastBufferSubDataNV(gpuMask, buffer, offset, Integer.toUnsignedLong(data.remaining()) << 3, memAddress(data)); + } + + // --- [ glMulticastCopyBufferSubDataNV ] --- + + public static native void glMulticastCopyBufferSubDataNV(@NativeType("GLuint") int readGpu, @NativeType("GLbitfield") int writeGpuMask, @NativeType("GLuint") int readBuffer, @NativeType("GLuint") int writeBuffer, @NativeType("GLintptr") long readOffset, @NativeType("GLintptr") long writeOffset, @NativeType("GLsizeiptr") long size); + + // --- [ glMulticastCopyImageSubDataNV ] --- + + public static native void glMulticastCopyImageSubDataNV(@NativeType("GLuint") int srcGpu, @NativeType("GLbitfield") int dstGpuMask, @NativeType("GLuint") int srcName, @NativeType("GLenum") int srcTarget, @NativeType("GLint") int srcLevel, @NativeType("GLint") int srcX, @NativeType("GLint") int srxY, @NativeType("GLint") int srcZ, @NativeType("GLuint") int dstName, @NativeType("GLenum") int dstTarget, @NativeType("GLint") int dstLevel, @NativeType("GLint") int dstX, @NativeType("GLint") int dstY, @NativeType("GLint") int dstZ, @NativeType("GLsizei") int srcWidth, @NativeType("GLsizei") int srcHeight, @NativeType("GLsizei") int srcDepth); + + // --- [ glMulticastBlitFramebufferNV ] --- + + public static native void glMulticastBlitFramebufferNV(@NativeType("GLuint") int srcGpu, @NativeType("GLuint") int dstGpu, @NativeType("GLint") int srcX0, @NativeType("GLint") int srcY0, @NativeType("GLint") int srcX1, @NativeType("GLint") int srcY1, @NativeType("GLint") int dstX0, @NativeType("GLint") int dstY0, @NativeType("GLint") int dstX1, @NativeType("GLint") int dstY1, @NativeType("GLbitfield") int mask, @NativeType("GLenum") int filter); + + // --- [ glMulticastFramebufferSampleLocationsfvNV ] --- + + public static native void nglMulticastFramebufferSampleLocationsfvNV(int gpu, int framebuffer, int start, int count, long v); + + public static void glMulticastFramebufferSampleLocationsfvNV(@NativeType("GLuint") int gpu, @NativeType("GLuint") int framebuffer, @NativeType("GLuint") int start, @NativeType("GLfloat const *") FloatBuffer v) { + nglMulticastFramebufferSampleLocationsfvNV(gpu, framebuffer, start, v.remaining() >> 1, memAddress(v)); + } + + // --- [ glMulticastBarrierNV ] --- + + public static native void glMulticastBarrierNV(); + + // --- [ glMulticastWaitSyncNV ] --- + + public static native void glMulticastWaitSyncNV(@NativeType("GLuint") int signalGpu, @NativeType("GLbitfield") int waitGpuMask); + + // --- [ glMulticastGetQueryObjectivNV ] --- + + public static native void nglMulticastGetQueryObjectivNV(int gpu, int id, int pname, long params); + + public static void glMulticastGetQueryObjectivNV(@NativeType("GLuint") int gpu, @NativeType("GLuint") int id, @NativeType("GLenum") int pname, @NativeType("GLint *") IntBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglMulticastGetQueryObjectivNV(gpu, id, pname, memAddress(params)); + } + + @NativeType("void") + public static int glMulticastGetQueryObjectiNV(@NativeType("GLuint") int gpu, @NativeType("GLuint") int id, @NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer params = stack.callocInt(1); + nglMulticastGetQueryObjectivNV(gpu, id, pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glMulticastGetQueryObjectuivNV ] --- + + public static native void nglMulticastGetQueryObjectuivNV(int gpu, int id, int pname, long params); + + public static void glMulticastGetQueryObjectuivNV(@NativeType("GLuint") int gpu, @NativeType("GLuint") int id, @NativeType("GLenum") int pname, @NativeType("GLuint *") IntBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglMulticastGetQueryObjectuivNV(gpu, id, pname, memAddress(params)); + } + + @NativeType("void") + public static int glMulticastGetQueryObjectuiNV(@NativeType("GLuint") int gpu, @NativeType("GLuint") int id, @NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer params = stack.callocInt(1); + nglMulticastGetQueryObjectuivNV(gpu, id, pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glMulticastGetQueryObjecti64vNV ] --- + + public static native void nglMulticastGetQueryObjecti64vNV(int gpu, int id, int pname, long params); + + public static void glMulticastGetQueryObjecti64vNV(@NativeType("GLuint") int gpu, @NativeType("GLuint") int id, @NativeType("GLenum") int pname, @NativeType("GLint64 *") LongBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglMulticastGetQueryObjecti64vNV(gpu, id, pname, memAddress(params)); + } + + @NativeType("void") + public static long glMulticastGetQueryObjecti64NV(@NativeType("GLuint") int gpu, @NativeType("GLuint") int id, @NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer params = stack.callocLong(1); + nglMulticastGetQueryObjecti64vNV(gpu, id, pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glMulticastGetQueryObjectui64vNV ] --- + + public static native void nglMulticastGetQueryObjectui64vNV(int gpu, int id, int pname, long params); + + public static void glMulticastGetQueryObjectui64vNV(@NativeType("GLuint") int gpu, @NativeType("GLuint") int id, @NativeType("GLenum") int pname, @NativeType("GLuint64 *") LongBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglMulticastGetQueryObjectui64vNV(gpu, id, pname, memAddress(params)); + } + + @NativeType("void") + public static long glMulticastGetQueryObjectui64NV(@NativeType("GLuint") int gpu, @NativeType("GLuint") int id, @NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer params = stack.callocLong(1); + nglMulticastGetQueryObjectui64vNV(gpu, id, pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + /** Array version of: {@link #glMulticastBufferSubDataNV MulticastBufferSubDataNV} */ + public static void glMulticastBufferSubDataNV(@NativeType("GLbitfield") int gpuMask, @NativeType("GLuint") int buffer, @NativeType("GLintptr") long offset, @NativeType("void const *") short[] data) { + long __functionAddress = GL.getICD().glMulticastBufferSubDataNV; + if (CHECKS) { + check(__functionAddress); + } + callPPPV(gpuMask, buffer, offset, Integer.toUnsignedLong(data.length) << 1, data, __functionAddress); + } + + /** Array version of: {@link #glMulticastBufferSubDataNV MulticastBufferSubDataNV} */ + public static void glMulticastBufferSubDataNV(@NativeType("GLbitfield") int gpuMask, @NativeType("GLuint") int buffer, @NativeType("GLintptr") long offset, @NativeType("void const *") int[] data) { + long __functionAddress = GL.getICD().glMulticastBufferSubDataNV; + if (CHECKS) { + check(__functionAddress); + } + callPPPV(gpuMask, buffer, offset, Integer.toUnsignedLong(data.length) << 2, data, __functionAddress); + } + + /** Array version of: {@link #glMulticastBufferSubDataNV MulticastBufferSubDataNV} */ + public static void glMulticastBufferSubDataNV(@NativeType("GLbitfield") int gpuMask, @NativeType("GLuint") int buffer, @NativeType("GLintptr") long offset, @NativeType("void const *") float[] data) { + long __functionAddress = GL.getICD().glMulticastBufferSubDataNV; + if (CHECKS) { + check(__functionAddress); + } + callPPPV(gpuMask, buffer, offset, Integer.toUnsignedLong(data.length) << 2, data, __functionAddress); + } + + /** Array version of: {@link #glMulticastBufferSubDataNV MulticastBufferSubDataNV} */ + public static void glMulticastBufferSubDataNV(@NativeType("GLbitfield") int gpuMask, @NativeType("GLuint") int buffer, @NativeType("GLintptr") long offset, @NativeType("void const *") double[] data) { + long __functionAddress = GL.getICD().glMulticastBufferSubDataNV; + if (CHECKS) { + check(__functionAddress); + } + callPPPV(gpuMask, buffer, offset, Integer.toUnsignedLong(data.length) << 3, data, __functionAddress); + } + + /** Array version of: {@link #glMulticastFramebufferSampleLocationsfvNV MulticastFramebufferSampleLocationsfvNV} */ + public static void glMulticastFramebufferSampleLocationsfvNV(@NativeType("GLuint") int gpu, @NativeType("GLuint") int framebuffer, @NativeType("GLuint") int start, @NativeType("GLfloat const *") float[] v) { + long __functionAddress = GL.getICD().glMulticastFramebufferSampleLocationsfvNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(gpu, framebuffer, start, v.length >> 1, v, __functionAddress); + } + + /** Array version of: {@link #glMulticastGetQueryObjectivNV MulticastGetQueryObjectivNV} */ + public static void glMulticastGetQueryObjectivNV(@NativeType("GLuint") int gpu, @NativeType("GLuint") int id, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] params) { + long __functionAddress = GL.getICD().glMulticastGetQueryObjectivNV; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(gpu, id, pname, params, __functionAddress); + } + + /** Array version of: {@link #glMulticastGetQueryObjectuivNV MulticastGetQueryObjectuivNV} */ + public static void glMulticastGetQueryObjectuivNV(@NativeType("GLuint") int gpu, @NativeType("GLuint") int id, @NativeType("GLenum") int pname, @NativeType("GLuint *") int[] params) { + long __functionAddress = GL.getICD().glMulticastGetQueryObjectuivNV; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(gpu, id, pname, params, __functionAddress); + } + + /** Array version of: {@link #glMulticastGetQueryObjecti64vNV MulticastGetQueryObjecti64vNV} */ + public static void glMulticastGetQueryObjecti64vNV(@NativeType("GLuint") int gpu, @NativeType("GLuint") int id, @NativeType("GLenum") int pname, @NativeType("GLint64 *") long[] params) { + long __functionAddress = GL.getICD().glMulticastGetQueryObjecti64vNV; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(gpu, id, pname, params, __functionAddress); + } + + /** Array version of: {@link #glMulticastGetQueryObjectui64vNV MulticastGetQueryObjectui64vNV} */ + public static void glMulticastGetQueryObjectui64vNV(@NativeType("GLuint") int gpu, @NativeType("GLuint") int id, @NativeType("GLenum") int pname, @NativeType("GLuint64 *") long[] params) { + long __functionAddress = GL.getICD().glMulticastGetQueryObjectui64vNV; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(gpu, id, pname, params, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVGPUShader5.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVGPUShader5.java new file mode 100644 index 00000000..6fe3d178 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVGPUShader5.java @@ -0,0 +1,514 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_gpu_shader5 extension. + * + *This extension provides a set of new features to the OpenGL Shading Language and related APIs to support capabilities of new GPUs. Shaders using the + * new functionality provided by this extension should enable this functionality via the construct
+ * + *
+ * \#extension GL_NV_gpu_shader5 : require (or enable)This extension was developed concurrently with the ARB_gpu_shader5 extension, and provides a superset of the features provided there. The features + * common to both extensions are documented in the ARB_gpu_shader5 specification; this document describes only the addition language features not + * available via ARB_gpu_shader5. A shader that enables this extension via an \#extension directive also implicitly enables the common capabilities + * provided by ARB_gpu_shader5.
+ * + *In addition to the capabilities of ARB_gpu_shader5, this extension provides a variety of new features for all shader types, including:
+ * + *This extension also provides additional support for processing patch primitives (introduced by ARB_tessellation_shader). ARB_tessellation_shader + * requires the use of a tessellation evaluation shader when processing patches, which means that patches will never survive past the tessellation + * pipeline stage. This extension lifts that restriction, and allows patches to proceed further in the pipeline and be used
+ * + *Additionally, it allows geometry shaders to read per-patch attributes written by a tessellation control shader using input variables declared with + * "patch in".
+ * + *Requires {@link GL32 OpenGL 3.2}, GLSL 1.50 and {@link ARBGPUShader5 ARB_gpu_shader5}.
+ */ +public class NVGPUShader5 { + + /** Returned by the {@code type} parameter of GetActiveAttrib, GetActiveUniform, and GetTransformFeedbackVarying. */ + public static final int + GL_INT64_NV = 0x140E, + GL_UNSIGNED_INT64_NV = 0x140F, + GL_INT8_NV = 0x8FE0, + GL_INT8_VEC2_NV = 0x8FE1, + GL_INT8_VEC3_NV = 0x8FE2, + GL_INT8_VEC4_NV = 0x8FE3, + GL_INT16_NV = 0x8FE4, + GL_INT16_VEC2_NV = 0x8FE5, + GL_INT16_VEC3_NV = 0x8FE6, + GL_INT16_VEC4_NV = 0x8FE7, + GL_INT64_VEC2_NV = 0x8FE9, + GL_INT64_VEC3_NV = 0x8FEA, + GL_INT64_VEC4_NV = 0x8FEB, + GL_UNSIGNED_INT8_NV = 0x8FEC, + GL_UNSIGNED_INT8_VEC2_NV = 0x8FED, + GL_UNSIGNED_INT8_VEC3_NV = 0x8FEE, + GL_UNSIGNED_INT8_VEC4_NV = 0x8FEF, + GL_UNSIGNED_INT16_NV = 0x8FF0, + GL_UNSIGNED_INT16_VEC2_NV = 0x8FF1, + GL_UNSIGNED_INT16_VEC3_NV = 0x8FF2, + GL_UNSIGNED_INT16_VEC4_NV = 0x8FF3, + GL_UNSIGNED_INT64_VEC2_NV = 0x8FF5, + GL_UNSIGNED_INT64_VEC3_NV = 0x8FF6, + GL_UNSIGNED_INT64_VEC4_NV = 0x8FF7, + GL_FLOAT16_NV = 0x8FF8, + GL_FLOAT16_VEC2_NV = 0x8FF9, + GL_FLOAT16_VEC3_NV = 0x8FFA, + GL_FLOAT16_VEC4_NV = 0x8FFB; + + static { GL.initialize(); } + + protected NVGPUShader5() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetThis extension introduces a new storage format and data type for half-precision (16-bit) floating-point quantities. The floating-point format is very + * similar to the IEEE single-precision floating-point standard, except that it has only 5 exponent bits and 10 mantissa bits. Half-precision floats are + * smaller than full precision floats and provide a larger dynamic range than similarly-sized normalized scalar data types.
+ * + *This extension allows applications to use half-precision floating point data when specifying vertices or pixel data. It adds new commands to specify + * vertex attributes using the new data type, and extends the existing vertex array and image specification commands to accept the new data type.
+ * + *This storage format is also used to represent 16-bit components in the floating-point frame buffers, as defined in the NV_float_buffer extension.
+ */ +public class NVHalfFloat { + + /** + * Accepted by the {@code type} argument of VertexPointer, NormalPointer, ColorPointer, TexCoordPointer, FogCoordPointerEXT, SecondaryColorPointerEXT, + * VertexWeightPointerEXT, VertexAttribPointerNV, DrawPixels, ReadPixels, TexImage1D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, + * and GetTexImage. + */ + public static final int GL_HALF_FLOAT_NV = 0x140B; + + static { GL.initialize(); } + + protected NVHalfFloat() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetSome OpenGL implementations support modes of multisampling which have + * properties which are non-obvious to applications and/or which may not be + * standards conformant. The idea of non-conformant AA modes is not new, + * and is exposed in both GLX and EGL with config caveats and the + * GLX_NON_CONFORMANT_CONFIG for GLX and EGL_NON_CONFORMANT_CONFIG for EGL, + * or by querying the EGL_CONFORMANT attribute in newer versions of EGL.
+ * + *Both of these mechanisms operate on a per-config basis, which works as + * intended for window-based configs. However, with the advent of + * application-created FBOs, it is now possible to do all the multisample + * operations in an application-created FBO and never use a multisample + * window.
+ * + *This extension further extends the internalformat query mechanism + * (first introduced by ARB_internalformat_query and extended in + * ARB_internalformat_query2) and introduces a mechanism for a + * implementation to report properties of formats that may also be + * dependent on the number of samples. This includes information + * such as whether the combination of format and samples should be + * considered conformant. This enables an implementation to report + * caveats which might apply to both window and FBO-based rendering + * configurations.
+ * + *Requires {@link GL42 OpenGL 4.2} or {@link ARBInternalformatQuery ARB_internalformat_query}.
+ */ +public class NVInternalformatSampleQuery { + + /** Accepted by the {@code pname} parameter of GetInternalformatSampleivNV */ + public static final int + GL_MULTISAMPLES_NV = 0x9371, + GL_SUPERSAMPLE_SCALE_X_NV = 0x9372, + GL_SUPERSAMPLE_SCALE_Y_NV = 0x9373, + GL_CONFORMANT_NV = 0x9374; + + static { GL.initialize(); } + + protected NVInternalformatSampleQuery() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGetInternalformatSampleivNV + ); + } + + // --- [ glGetInternalformatSampleivNV ] --- + + public static native void nglGetInternalformatSampleivNV(int target, int internalformat, int samples, int pname, int bufSize, long params); + + public static void glGetInternalformatSampleivNV(@NativeType("GLenum") int target, @NativeType("GLenum") int internalformat, @NativeType("GLsizei") int samples, @NativeType("GLenum") int pname, @NativeType("GLint *") IntBuffer params) { + nglGetInternalformatSampleivNV(target, internalformat, samples, pname, params.remaining(), memAddress(params)); + } + + /** Array version of: {@link #glGetInternalformatSampleivNV GetInternalformatSampleivNV} */ + public static void glGetInternalformatSampleivNV(@NativeType("GLenum") int target, @NativeType("GLenum") int internalformat, @NativeType("GLsizei") int samples, @NativeType("GLenum") int pname, @NativeType("GLint *") int[] params) { + long __functionAddress = GL.getICD().glGetInternalformatSampleivNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, internalformat, samples, pname, params.length, params, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVLightMaxExponent.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVLightMaxExponent.java new file mode 100644 index 00000000..2caf607d --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVLightMaxExponent.java @@ -0,0 +1,23 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_light_max_exponent extension. + * + *Default OpenGL does not permit a shininess or spot exponent over 128.0. This extension permits implementations to support and advertise a maximum + * shininess and spot exponent beyond 128.0.
+ */ +public final class NVLightMaxExponent { + + /** Accepted by the {@code pname} parameters of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev */ + public static final int + GL_MAX_SHININESS_NV = 0x8504, + GL_MAX_SPOT_EXPONENT_NV = 0x8505; + + private NVLightMaxExponent() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVMemoryAttachment.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVMemoryAttachment.java new file mode 100644 index 00000000..42fcb853 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVMemoryAttachment.java @@ -0,0 +1,106 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_memory_attachment extension. + * + *This extension extends the memory objects introduced with {@link EXTMemoryObject EXT_memory_object} to allow existing textures and buffers to be migrated to an + * imported memory allocation. The primary use-case of this extension is plug-in development where resource management (creation, deletion, sizing etc.) + * is handled by inaccessible host application code.
+ * + *Requires {@link EXTMemoryObject EXT_memory_object} and {@link ARBTextureStorage ARB_texture_storage} or a version of OpenGL that incorporates it.
+ */ +public class NVMemoryAttachment { + + /** + * Accepted by the {@code pname} parameter of TexParameter{ifx}{v}, TexParameterI{i ui}v, TextureParameter{if}{v}, TextureParameterI{i ui}v, + * GetTexParameter{if}v, GetTexParameterI{i ui}v, GetTextureParameter{if}v, GetTextureParameterI{i ui}v, GetBufferParameter{i|i64}v and + * GetNamedBufferParameter{i|i64}v. + */ + public static final int + GL_ATTACHED_MEMORY_OBJECT_NV = 0x95A4, + GL_ATTACHED_MEMORY_OFFSET_NV = 0x95A5, + GL_MEMORY_ATTACHABLE_ALIGNMENT_NV = 0x95A6, + GL_MEMORY_ATTACHABLE_SIZE_NV = 0x95A7, + GL_MEMORY_ATTACHABLE_NV = 0x95A8; + + /** + * Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetFloatv, GetIntegerv, GetInteger64v, GetUnsignedBytevEXT, + * GetMemoryObjectParameterivEXT, and the {@code target} parameter of GetBooleani_v, GetIntegeri_v,GetFloati_v, GetDoublei_v, GetInteger64i_v and + * GetUnsignedBytei_vEXT. + */ + public static final int GL_DETACHED_MEMORY_INCARNATION_NV = 0x95A9; + + /** Accepted by the {@code pname} parameter of GetMemoryObjectParameterivEXT, GetMemoryObjectDetachedResourcesuivNV and ResetMemoryObjectParameterNV. */ + public static final int + GL_DETACHED_TEXTURES_NV = 0x95AA, + GL_DETACHED_BUFFERS_NV = 0x95AB; + + /** Accepted by the {@code pname} parameter of MemoryObjectParameterivEXT, GetMemoryObjectParameterivEXT. */ + public static final int + GL_MAX_DETACHED_TEXTURES_NV = 0x95AC, + GL_MAX_DETACHED_BUFFERS_NV = 0x95AD; + + static { GL.initialize(); } + + protected NVMemoryAttachment() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetThis extension provides a new mechanism allowing applications to use two new programmable shader types -- the task and mesh shader -- to generate + * collections of geometric primitives to be processed by fixed-function primitive assembly and rasterization logic. When the task and mesh shaders are + * drawn, they replace the standard programmable vertex processing pipeline, including vertex array attribute fetching, vertex shader processing, + * tessellation, and the geometry shader processing.
+ * + *Requires {@link GL45 OpenGL 4.5}.
+ */ +public class NVMeshShader { + + /** Accepted by the {@code type} parameter of {@link GL20C#glCreateShader CreateShader} and returned by the {@code params} parameter of {@link GL20C#glGetShaderiv GetShaderiv}. */ + public static final int + GL_MESH_SHADER_NV = 0x9559, + GL_TASK_SHADER_NV = 0x955A; + + /** Accepted by the {@code pname} parameter of {@link GL11C#glGetIntegerv GetIntegerv}, {@link GL11C#glGetBooleanv GetBooleanv}, {@link GL11C#glGetFloatv GetFloatv}, {@link GL11C#glGetDoublev GetDoublev} and {@link GL32C#glGetInteger64v GetInteger64v}. */ + public static final int + GL_MAX_MESH_UNIFORM_BLOCKS_NV = 0x8E60, + GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV = 0x8E61, + GL_MAX_MESH_IMAGE_UNIFORMS_NV = 0x8E62, + GL_MAX_MESH_UNIFORM_COMPONENTS_NV = 0x8E63, + GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV = 0x8E64, + GL_MAX_MESH_ATOMIC_COUNTERS_NV = 0x8E65, + GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV = 0x8E66, + GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV = 0x8E67, + GL_MAX_TASK_UNIFORM_BLOCKS_NV = 0x8E68, + GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV = 0x8E69, + GL_MAX_TASK_IMAGE_UNIFORMS_NV = 0x8E6A, + GL_MAX_TASK_UNIFORM_COMPONENTS_NV = 0x8E6B, + GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV = 0x8E6C, + GL_MAX_TASK_ATOMIC_COUNTERS_NV = 0x8E6D, + GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV = 0x8E6E, + GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV = 0x8E6F, + GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV = 0x95A2, + GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV = 0x95A3, + GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV = 0x9536, + GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV = 0x9537, + GL_MAX_MESH_OUTPUT_VERTICES_NV = 0x9538, + GL_MAX_MESH_OUTPUT_PRIMITIVES_NV = 0x9539, + GL_MAX_TASK_OUTPUT_COUNT_NV = 0x953A, + GL_MAX_DRAW_MESH_TASKS_COUNT_NV = 0x953D, + GL_MAX_MESH_VIEWS_NV = 0x9557, + GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV = 0x92DF, + GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV = 0x9543; + + /** Accepted by the {@code pname} parameter of {@link GL30C#glGetIntegeri_v GetIntegeri_v}, {@link GL30C#glGetBooleani_v GetBooleani_v}, {@link GL41C#glGetFloati_v GetFloati_v}, {@link GL41C#glGetDoublei_v GetDoublei_v} and {@link GL32C#glGetInteger64i_v GetInteger64i_v}. */ + public static final int + GL_MAX_MESH_WORK_GROUP_SIZE_NV = 0x953B, + GL_MAX_TASK_WORK_GROUP_SIZE_NV = 0x953C; + + /** Accepted by the {@code pname} parameter of {@link GL20C#glGetProgramiv GetProgramiv}. */ + public static final int + GL_MESH_WORK_GROUP_SIZE_NV = 0x953E, + GL_TASK_WORK_GROUP_SIZE_NV = 0x953F, + GL_MESH_VERTICES_OUT_NV = 0x9579, + GL_MESH_PRIMITIVES_OUT_NV = 0x957A, + GL_MESH_OUTPUT_TYPE_NV = 0x957B; + + /** Accepted by the {@code pname} parameter of {@link GL31C#glGetActiveUniformBlockiv GetActiveUniformBlockiv}. */ + public static final int + GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV = 0x959C, + GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV = 0x959D; + + /** Accepted by the {@code pname} parameter of {@link GL42C#glGetActiveAtomicCounterBufferiv GetActiveAtomicCounterBufferiv}. */ + public static final int + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV = 0x959E, + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV = 0x959F; + + /** Accepted in the {@code props} array of {@link GL43C#glGetProgramResourceiv GetProgramResourceiv}. */ + public static final int + GL_REFERENCED_BY_MESH_SHADER_NV = 0x95A0, + GL_REFERENCED_BY_TASK_SHADER_NV = 0x95A1; + + /** + * Accepted by the {@code programInterface} parameter of {@link GL43C#glGetProgramInterfaceiv GetProgramInterfaceiv}, {@link GL43C#glGetProgramResourceIndex GetProgramResourceIndex}, {@link GL43C#glGetProgramResourceName GetProgramResourceName}, + * {@link GL43C#glGetProgramResourceiv GetProgramResourceiv}, {@link GL43C#glGetProgramResourceLocation GetProgramResourceLocation}, and {@link GL43C#glGetProgramResourceLocationIndex GetProgramResourceLocationIndex}. + */ + public static final int + GL_MESH_SUBROUTINE_NV = 0x957C, + GL_TASK_SUBROUTINE_NV = 0x957D, + GL_MESH_SUBROUTINE_UNIFORM_NV = 0x957E, + GL_TASK_SUBROUTINE_UNIFORM_NV = 0x957F; + + /** Accepted by the {@code stages} parameter of {@link GL41C#glUseProgramStages UseProgramStages}. */ + public static final int + GL_MESH_SHADER_BIT_NV = 0x40, + GL_TASK_SHADER_BIT_NV = 0x80; + + static { GL.initialize(); } + + protected NVMeshShader() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glDrawMeshTasksNV, caps.glDrawMeshTasksIndirectNV, caps.glMultiDrawMeshTasksIndirectNV, caps.glMultiDrawMeshTasksIndirectCountNV + ); + } + + // --- [ glDrawMeshTasksNV ] --- + + public static native void glDrawMeshTasksNV(@NativeType("GLuint") int first, @NativeType("GLuint") int count); + + // --- [ glDrawMeshTasksIndirectNV ] --- + + public static native void glDrawMeshTasksIndirectNV(@NativeType("GLintptr") long indirect); + + // --- [ glMultiDrawMeshTasksIndirectNV ] --- + + public static native void glMultiDrawMeshTasksIndirectNV(@NativeType("GLintptr") long indirect, @NativeType("GLsizei") int drawcount, @NativeType("GLsizei") int stride); + + // --- [ glMultiDrawMeshTasksIndirectCountNV ] --- + + public static native void glMultiDrawMeshTasksIndirectCountNV(@NativeType("GLintptr") long indirect, @NativeType("GLintptr") long drawcount, @NativeType("GLsizei") int maxdrawcount, @NativeType("GLsizei") int stride); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVMultisampleCoverage.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVMultisampleCoverage.java new file mode 100644 index 00000000..4573a8ef --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVMultisampleCoverage.java @@ -0,0 +1,33 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_multisample_coverage extension. + * + *The ARB_multisample extension provides a mechanism for antialiasing primitives. This mechanism allows an application to request an additional buffer, + * the multisample buffer, that is added to the framebuffer. An application can request the number of samples per fragment that are stored in the + * multisample buffer. Rendering proceeds by writing color, depth, and stencil values for each sample to the multisample buffer. The results are + * automatically resolved to a single displayable color each time a pixel is updated.
+ * + *Coverage Sample Anti-Aliasing (CSAA) is an extension to multisample antialiasing. The technique separates "samples" into two types of samples. "Color + * samples" are samples with color, depth, and stencil information stored in the multisample buffer. "Coverage samples" include both color samples and + * additional samples that only provide pixel coverage information.
+ * + *This extension follows the example of the NV_framebuffer_multisample_coverage extension, which adds CSAA support for framebuffer objects. The base + * description of multisample rendering is written in terms of coverage samples and color samples. The windows system notion of "samples" (SAMPLES_ARB) is + * layered on top of coverage and color samples.
+ * + *Requires {@link ARBMultisample ARB_multisample}.
+ */ +public final class NVMultisampleCoverage { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int GL_COLOR_SAMPLES_NV = 0x8E20; + + private NVMultisampleCoverage() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVMultisampleFilterHint.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVMultisampleFilterHint.java new file mode 100644 index 00000000..1b14d27b --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVMultisampleFilterHint.java @@ -0,0 +1,27 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_multisample_filter_hint extension. + * + *OpenGL multisampling typically assumes that the samples of a given pixel are weighted uniformly and averaged to compute the pixel's resolved color. + * This extension provides a hint that permits implementations to provide an alternative method of resolving the color of multisampled pixels.
+ * + *As an example of such an alternative method, NVIDIA's GeForce3 GPU provides a technique known as Quincunx filtering. This technique is used in + * two-sample multisampling, but it blends the pixel's two samples and three additional samples from adjacent pixels. The sample pattern is analogous to + * the 5 pattern on a die. The quality of this technique is widely regarded as comparable to 4 sample multisampling.
+ * + *Requires {@link ARBMultisample ARB_multisample}.
+ */ +public final class NVMultisampleFilterHint { + + /** Accepted by the {@code target} parameter of Hint and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_MULTISAMPLE_FILTER_HINT_NV = 0x8534; + + private NVMultisampleFilterHint() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPackedDepthStencil.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPackedDepthStencil.java new file mode 100644 index 00000000..8fb05b53 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPackedDepthStencil.java @@ -0,0 +1,30 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * This extension provides a new data format, {@link #GL_DEPTH_STENCIL_NV DEPTH_STENCIL_NV}, that can be used with the glDrawPixels, glReadPixels, and glCopyPixels commands, as well + * as a packed data type, {@link #GL_UNSIGNED_INT_24_8_NV UNSIGNED_INT_24_8_NV}, that is meant to be used with GL_DEPTH_STENCIL_NV. No other formats are supported with + * GL_DEPTH_STENCIL_NV. If SGIX_depth_texture is supported, GL_DEPTH_STENCIL_NV/GL_UNSIGNED_INT_24_8_NV data can also be used for + * textures; this provides a more efficient way to supply data for a 24-bit depth texture. + */ +public final class NVPackedDepthStencil { + + /** + * Accepted by the {@code format} parameter of DrawPixels, ReadPixels, TexImage1D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, + * and GetTexImage, and by the {@code type} parameter of CopyPixels. + */ + public static final int GL_DEPTH_STENCIL_NV = 0x84F9; + + /** + * Accepted by the {@code type} parameter of DrawPixels, ReadPixels, TexImage1D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, and + * GetTexImage. + */ + public static final int GL_UNSIGNED_INT_24_8_NV = 0x84FA; + + private NVPackedDepthStencil() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPathRendering.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPathRendering.java new file mode 100644 index 00000000..406e5f6d --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPathRendering.java @@ -0,0 +1,1713 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +import static org.lwjgl.opengl.GL11.*; + +/** + * Native bindings to the NV_path_rendering extension. + * + *Conventional OpenGL supports rendering images (pixel rectangles and bitmaps) and simple geometric primitives (points, lines, polygons).
+ * + *This extension adds a new rendering paradigm, known as path rendering, for rendering filled and stroked paths. Path rendering is not novel but rather a + * standard part of most resolution-independent 2D rendering systems such as Flash, PDF, Silverlight, SVG, Java 2D, Office drawings, TrueType fonts, + * PostScript and its fonts, Quartz 2D, XML Paper Specification (XPS), and OpenVG. What is novel is the ability to mix path rendering with arbitrary + * OpenGL 3D rendering and imaging.
+ * + *With this extension, path rendering becomes a first-class rendering mode within the OpenGL graphics system that can be arbitrarily mixed with existing + * OpenGL rendering and can take advantage of OpenGL's existing mechanisms for texturing, programmability, and per-fragment operations.
+ * + *Unlike geometric primitive rendering, paths are specified on a 2D (non-projective) plane rather than in 3D (projective) space. Even though the path is + * defined in a 2D plane, every path can be transformed into 3D clip space allowing for 3D view frustum & user-defined clipping, depth offset, and + * depth testing in the same manner as geometric primitive rendering.
+ * + *Both geometric primitive rendering and path rendering support rasterization of edges defined by line segments; however, path rendering also allows path + * segments to be specified by Bezier (cubic or quadratic) curves or partial elliptical arcs. This allows path rendering to define truly curved primitive + * boundaries unlike the straight edges of line and polygon primitives. Whereas geometric primitive rendering requires convex polygons for well-defined + * rendering results, path rendering allows (and encourages!) concave and curved outlines to be specified. These paths are even allowed to self-intersect.
+ * + *When filling closed paths, the winding of paths (counterclockwise or clockwise) determines whether pixels are inside or outside of the path.
+ * + *Paths can also be stroked whereby, conceptually, a fixed-width "brush" is pulled along the path such that the brush remains orthogonal to the gradient + * of each path segment. Samples within the sweep of this brush are considered inside the stroke of the path.
+ * + *This extension supports path rendering through a sequence of three operations:
+ * + *Path commands can be specified explicitly from path command and coordinate data, parsed from a string based on standard grammars for representing + * paths, or specified by a particular glyph of standard font representations. Also new paths can be specified by weighting one or more existing paths + * so long as all the weighted paths have consistent command sequences.
+ * + *Each path object contains zero or more subpaths specified by a sequence of line segments, partial elliptical arcs, and (cubic or quadratic) Bezier + * curve segments. Each path may contain multiple subpaths that can be closed (forming a contour) or open.
Path stenciling can determine either the filled or stroked coverage of a path.
+ * + *The details of path stenciling are explained within the core of the specification.
+ * + *Stenciling a stroked path supports all the standard embellishments for path stroking such as end caps, join styles, miter limits, dashing, and dash + * caps. These stroking properties specified are parameters of path objects.
Path covering can cover either the filled or stroked coverage of a path.
+ * + *The details of path covering are explained within the core of the specification.
To render a path object into the color buffer, an application specifies a path object and then uses a two-step rendering process. First, the path + * object is stenciled whereby the path object's stroked or filled coverage is rasterized into the stencil buffer. Second, the path object is covered + * whereby conservative bounding geometry for the path is transformed and rasterized with stencil testing configured to test against the coverage + * information written to the stencil buffer in the first step so that only fragments covered by the path are written during this second step. Also during + * this second step written pixels typically have their stencil value reset (so there's no need for clearing the stencil buffer between rendering each + * path).
+ */ +public class NVPathRendering { + + /** Accepted in elements of the {@code commands} array parameter of PathCommandsNV and PathSubCommandsNV. */ + public static final byte + GL_CLOSE_PATH_NV = 0x0, + GL_MOVE_TO_NV = 0x2, + GL_RELATIVE_MOVE_TO_NV = 0x3, + GL_LINE_TO_NV = 0x4, + GL_RELATIVE_LINE_TO_NV = 0x5, + GL_HORIZONTAL_LINE_TO_NV = 0x6, + GL_RELATIVE_HORIZONTAL_LINE_TO_NV = 0x7, + GL_VERTICAL_LINE_TO_NV = 0x8, + GL_RELATIVE_VERTICAL_LINE_TO_NV = 0x9, + GL_QUADRATIC_CURVE_TO_NV = 0xA, + GL_RELATIVE_QUADRATIC_CURVE_TO_NV = 0xB, + GL_CUBIC_CURVE_TO_NV = 0xC, + GL_RELATIVE_CUBIC_CURVE_TO_NV = 0xD, + GL_SMOOTH_QUADRATIC_CURVE_TO_NV = 0xE, + GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV = 0xF, + GL_SMOOTH_CUBIC_CURVE_TO_NV = 0x10, + GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV = 0x11, + GL_SMALL_CCW_ARC_TO_NV = 0x12, + GL_RELATIVE_SMALL_CCW_ARC_TO_NV = 0x13, + GL_SMALL_CW_ARC_TO_NV = 0x14, + GL_RELATIVE_SMALL_CW_ARC_TO_NV = 0x15, + GL_LARGE_CCW_ARC_TO_NV = 0x16, + GL_RELATIVE_LARGE_CCW_ARC_TO_NV = 0x17, + GL_LARGE_CW_ARC_TO_NV = 0x18, + GL_RELATIVE_LARGE_CW_ARC_TO_NV = 0x19, + GL_CONIC_CURVE_TO_NV = 0x1A, + GL_RELATIVE_CONIC_CURVE_TO_NV = 0x1B, + GL_ROUNDED_RECT_NV = (byte)0xE8, + GL_RELATIVE_ROUNDED_RECT_NV = (byte)0xE9, + GL_ROUNDED_RECT2_NV = (byte)0xEA, + GL_RELATIVE_ROUNDED_RECT2_NV = (byte)0xEB, + GL_ROUNDED_RECT4_NV = (byte)0xEC, + GL_RELATIVE_ROUNDED_RECT4_NV = (byte)0xED, + GL_ROUNDED_RECT8_NV = (byte)0xEE, + GL_RELATIVE_ROUNDED_RECT8_NV = (byte)0xEF, + GL_RESTART_PATH_NV = (byte)0xF0, + GL_DUP_FIRST_CUBIC_CURVE_TO_NV = (byte)0xF2, + GL_DUP_LAST_CUBIC_CURVE_TO_NV = (byte)0xF4, + GL_RECT_NV = (byte)0xF6, + GL_RELATIVE_RECT_NV = (byte)0xF7, + GL_CIRCULAR_CCW_ARC_TO_NV = (byte)0xF8, + GL_CIRCULAR_CW_ARC_TO_NV = (byte)0xFA, + GL_CIRCULAR_TANGENT_ARC_TO_NV = (byte)0xFC, + GL_ARC_TO_NV = (byte)0xFE, + GL_RELATIVE_ARC_TO_NV = (byte)0xFF; + + /** Accepted by the {@code format} parameter of PathStringNV. */ + public static final int + GL_PATH_FORMAT_SVG_NV = 0x9070, + GL_PATH_FORMAT_PS_NV = 0x9071; + + /** Accepted by the {@code fontTarget} parameter of PathGlyphsNV, PathGlyphRangeNV, and PathGlyphIndexRangeNV. */ + public static final int + GL_STANDARD_FONT_NAME_NV = 0x9072, + GL_SYSTEM_FONT_NAME_NV = 0x9073, + GL_FILE_NAME_NV = 0x9074; + + /** Accepted by the {@code fontTarget} parameter of PathMemoryGlyphIndexArrayNV. */ + public static final int GL_STANDARD_FONT_FORMAT_NV = 0x936C; + + /** Accepted by the {@code handleMissingGlyph} parameter of PathGlyphsNV and PathGlyphRangeNV. */ + public static final int + GL_SKIP_MISSING_GLYPH_NV = 0x90A9, + GL_USE_MISSING_GLYPH_NV = 0x90AA; + + /** Returned by PathGlyphIndexRangeNV. */ + public static final int + GL_FONT_GLYPHS_AVAILABLE_NV = 0x9368, + GL_FONT_TARGET_UNAVAILABLE_NV = 0x9369, + GL_FONT_UNAVAILABLE_NV = 0x936A, + GL_FONT_UNINTELLIGIBLE_NV = 0x936B; + + /** + * Accepted by the {@code pname} parameter of PathParameterfNV, PathParameterfvNV, GetPathParameterfvNV, PathParameteriNV, PathParameterivNV, and + * GetPathParameterivNV. + */ + public static final int + GL_PATH_STROKE_WIDTH_NV = 0x9075, + GL_PATH_INITIAL_END_CAP_NV = 0x9077, + GL_PATH_TERMINAL_END_CAP_NV = 0x9078, + GL_PATH_JOIN_STYLE_NV = 0x9079, + GL_PATH_MITER_LIMIT_NV = 0x907A, + GL_PATH_INITIAL_DASH_CAP_NV = 0x907C, + GL_PATH_TERMINAL_DASH_CAP_NV = 0x907D, + GL_PATH_DASH_OFFSET_NV = 0x907E, + GL_PATH_CLIENT_LENGTH_NV = 0x907F, + GL_PATH_DASH_OFFSET_RESET_NV = 0x90B4, + GL_PATH_FILL_MODE_NV = 0x9080, + GL_PATH_FILL_MASK_NV = 0x9081, + GL_PATH_FILL_COVER_MODE_NV = 0x9082, + GL_PATH_STROKE_COVER_MODE_NV = 0x9083, + GL_PATH_STROKE_MASK_NV = 0x9084, + GL_PATH_STROKE_BOUND_NV = 0x9086; + + /** Accepted by the {@code pname} parameter of PathParameterfNV and PathParameterfvNV. */ + public static final int + GL_PATH_END_CAPS_NV = 0x9076, + GL_PATH_DASH_CAPS_NV = 0x907B; + + /** Accepted by the {@code fillMode} parameter of StencilFillPathNV and StencilFillPathInstancedNV. */ + public static final int + GL_COUNT_UP_NV = 0x9088, + GL_COUNT_DOWN_NV = 0x9089; + + /** Accepted by the {@code color} parameter of PathColorGenNV, GetPathColorGenivNV, and GetPathColorGenfvNV. */ + public static final int + GL_PRIMARY_COLOR_NV = 0x852C, + GL_SECONDARY_COLOR_NV = 0x852D; + + /** Accepted by the {@code genMode} parameter of PathColorGenNV, PathTexGenNV, ProgramPathFragmentInputGenNV. */ + public static final int GL_PATH_OBJECT_BOUNDING_BOX_NV = 0x908A; + + /** Accepted by the {@code coverMode} parameter of CoverFillPathNV and CoverFillPathInstancedNV. */ + public static final int + GL_CONVEX_HULL_NV = 0x908B, + GL_BOUNDING_BOX_NV = 0x908D; + + /** + * Accepted by the {@code transformType} parameter of StencilFillPathInstancedNV, StencilStrokePathInstancedNV, CoverFillPathInstancedNV, and + * CoverStrokePathInstancedNV. + */ + public static final int + GL_TRANSLATE_X_NV = 0x908E, + GL_TRANSLATE_Y_NV = 0x908F, + GL_TRANSLATE_2D_NV = 0x9090, + GL_TRANSLATE_3D_NV = 0x9091, + GL_AFFINE_2D_NV = 0x9092, + GL_AFFINE_3D_NV = 0x9094, + GL_TRANSPOSE_AFFINE_2D_NV = 0x9096, + GL_TRANSPOSE_AFFINE_3D_NV = 0x9098; + + /** + * Accepted by the {@code type} or {@code pathNameType} parameter of StencilFillPathInstancedNV, StencilStrokePathInstancedNV, CoverFillPathInstancedNV, + * CoverStrokePathInstancedNV, GetPathMetricsNV, and GetPathSpacingNV. + */ + public static final int + GL_UTF8_NV = 0x909A, + GL_UTF16_NV = 0x909B; + + /** Accepted by the {@code coverMode} parameter of CoverFillPathInstancedNV. */ + public static final int GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV = 0x909C; + + /** Accepted by the {@code pname} parameter of GetPathParameterfvNV and GetPathParameterivNV. */ + public static final int + GL_PATH_COMMAND_COUNT_NV = 0x909D, + GL_PATH_COORD_COUNT_NV = 0x909E, + GL_PATH_DASH_ARRAY_COUNT_NV = 0x909F, + GL_PATH_COMPUTED_LENGTH_NV = 0x90A0, + GL_PATH_FILL_BOUNDING_BOX_NV = 0x90A1, + GL_PATH_STROKE_BOUNDING_BOX_NV = 0x90A2; + + /** + * Accepted by the {@code value} parameter of PathParameterfNV, PathParameterfvNV, PathParameteriNV, and PathParameterivNV when {@code pname} is one of + * PATH_END_CAPS_NV, PATH_INTIAL_END_CAP_NV, PATH_TERMINAL_END_CAP_NV, PATH_DASH_CAPS_NV, PATH_INITIAL_DASH_CAP_NV, and PATH_TERMINAL_DASH_CAP_NV. + */ + public static final int + GL_SQUARE_NV = 0x90A3, + GL_ROUND_NV = 0x90A4, + GL_TRIANGULAR_NV = 0x90A5; + + /** + * Accepted by the {@code value} parameter of PathParameterfNV, PathParameterfvNV, PathParameteriNV, and PathParameterivNV when {@code pname} is + * PATH_JOIN_STYLE_NV. + */ + public static final int + GL_BEVEL_NV = 0x90A6, + GL_MITER_REVERT_NV = 0x90A7, + GL_MITER_TRUNCATE_NV = 0x90A8; + + /** + * Accepted by the {@code value} parameter of PathParameterfNV, PathParameterfvNV, PathParameteriNV, and PathParameterivNV when {@code pname} is + * PATH_DASH_OFFSET_RESET_NV. + */ + public static final int + GL_MOVE_TO_RESETS_NV = 0x90B5, + GL_MOVE_TO_CONTINUES_NV = 0x90B6; + + /** Accepted by the {@code fontStyle} parameter of PathGlyphsNV, PathGlyphRangeNV, and PathGlyphIndexRangeNV. */ + public static final int + GL_BOLD_BIT_NV = 0x1, + GL_ITALIC_BIT_NV = 0x2; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int + GL_PATH_ERROR_POSITION_NV = 0x90AB, + GL_PATH_FOG_GEN_MODE_NV = 0x90AC, + GL_PATH_STENCIL_FUNC_NV = 0x90B7, + GL_PATH_STENCIL_REF_NV = 0x90B8, + GL_PATH_STENCIL_VALUE_MASK_NV = 0x90B9, + GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV = 0x90BD, + GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV = 0x90BE, + GL_PATH_COVER_DEPTH_FUNC_NV = 0x90BF; + + /** Accepted as a bit within the {@code metricQueryMask} parameter of GetPathMetricRangeNV or GetPathMetricsNV. */ + public static final int + GL_GLYPH_WIDTH_BIT_NV = 0x1, + GL_GLYPH_HEIGHT_BIT_NV = 0x2, + GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV = 0x4, + GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV = 0x8, + GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV = 0x10, + GL_GLYPH_VERTICAL_BEARING_X_BIT_NV = 0x20, + GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV = 0x40, + GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV = 0x80, + GL_GLYPH_HAS_KERNING_BIT_NV = 0x100, + GL_FONT_X_MIN_BOUNDS_BIT_NV = 0x10000, + GL_FONT_Y_MIN_BOUNDS_BIT_NV = 0x20000, + GL_FONT_X_MAX_BOUNDS_BIT_NV = 0x40000, + GL_FONT_Y_MAX_BOUNDS_BIT_NV = 0x80000, + GL_FONT_UNITS_PER_EM_BIT_NV = 0x100000, + GL_FONT_ASCENDER_BIT_NV = 0x200000, + GL_FONT_DESCENDER_BIT_NV = 0x400000, + GL_FONT_HEIGHT_BIT_NV = 0x800000, + GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV = 0x1000000, + GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV = 0x2000000, + GL_FONT_UNDERLINE_POSITION_BIT_NV = 0x4000000, + GL_FONT_UNDERLINE_THICKNESS_BIT_NV = 0x8000000, + GL_FONT_HAS_KERNING_BIT_NV = 0x10000000, + GL_FONT_NUM_GLYPH_INDICES_BIT_NV = 0x20000000; + + /** Accepted by the {@code pathListMode} parameter of GetPathSpacingNV. */ + public static final int + GL_ACCUM_ADJACENT_PAIRS_NV = 0x90AD, + GL_ADJACENT_PAIRS_NV = 0x90AE, + GL_FIRST_TO_REST_NV = 0x90AF; + + /** Accepted by the {@code pname} parameter of GetPathColorGenivNV, GetPathColorGenfvNV, GetPathTexGenivNV and GetPathTexGenfvNV. */ + public static final int + GL_PATH_GEN_MODE_NV = 0x90B0, + GL_PATH_GEN_COEFF_NV = 0x90B1; + + /** Accepted by the {@code pname} parameter of GetPathColorGenivNV and GetPathColorGenfvNV. */ + public static final int GL_PATH_GEN_COLOR_FORMAT_NV = 0x90B2; + + /** Accepted by the {@code pname} parameter of GetPathTexGenivNV and GetPathTexGenfvNV. */ + public static final int GL_PATH_GEN_COMPONENTS_NV = 0x90B3; + + /** + * Accepted by the {@code programInterface} parameter of GetProgramInterfaceiv, GetProgramResourceIndex, GetProgramResourceName, GetProgramResourceiv, + * GetProgramResourcefvNV, and GetProgramResourceLocation. + */ + public static final int GL_FRAGMENT_INPUT_NV = 0x936D; + + /** Token values for matrices. */ + public static final int + GL_PATH_PROJECTION_NV = 0x1701, + GL_PATH_MODELVIEW_NV = 0x1700, + GL_PATH_MODELVIEW_STACK_DEPTH_NV = 0xBA3, + GL_PATH_MODELVIEW_MATRIX_NV = 0xBA6, + GL_PATH_MAX_MODELVIEW_STACK_DEPTH_NV = 0xD36, + GL_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV = 0x84E3, + GL_PATH_PROJECTION_STACK_DEPTH_NV = 0xBA4, + GL_PATH_PROJECTION_MATRIX_NV = 0xBA7, + GL_PATH_MAX_PROJECTION_STACK_DEPTH_NV = 0xD38, + GL_PATH_TRANSPOSE_PROJECTION_MATRIX_NV = 0x84E4; + + /** The following types are defined as alias to the GL tokens. */ + public static final int + GL_2_BYTES_NV = 0x1407, + GL_3_BYTES_NV = 0x1408, + GL_4_BYTES_NV = 0x1409, + GL_EYE_LINEAR_NV = 0x2400, + GL_OBJECT_LINEAR_NV = 0x2401, + GL_CONSTANT_NV = 0x8576; + + static { GL.initialize(); } + + protected NVPathRendering() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glPathCommandsNV, caps.glPathCoordsNV, caps.glPathSubCommandsNV, caps.glPathSubCoordsNV, caps.glPathStringNV, caps.glPathGlyphsNV, + caps.glPathGlyphRangeNV, caps.glCopyPathNV, caps.glInterpolatePathsNV, caps.glTransformPathNV, caps.glPathParameterivNV, caps.glPathParameteriNV, + caps.glPathParameterfvNV, caps.glPathParameterfNV, caps.glPathDashArrayNV, caps.glGenPathsNV, caps.glDeletePathsNV, caps.glIsPathNV, + caps.glPathStencilFuncNV, caps.glPathStencilDepthOffsetNV, caps.glStencilFillPathNV, caps.glStencilStrokePathNV, caps.glStencilFillPathInstancedNV, + caps.glStencilStrokePathInstancedNV, caps.glPathCoverDepthFuncNV, caps.glCoverFillPathNV, caps.glCoverStrokePathNV, caps.glCoverFillPathInstancedNV, + caps.glCoverStrokePathInstancedNV, caps.glGetPathParameterivNV, caps.glGetPathParameterfvNV, caps.glGetPathCommandsNV, caps.glGetPathCoordsNV, + caps.glGetPathDashArrayNV, caps.glGetPathMetricsNV, caps.glGetPathMetricRangeNV, caps.glGetPathSpacingNV, caps.glIsPointInFillPathNV, + caps.glIsPointInStrokePathNV, caps.glGetPathLengthNV, caps.glPointAlongPathNV + ); + } + + // --- [ glPathCommandsNV ] --- + + /** Unsafe version of: {@link #glPathCommandsNV PathCommandsNV} */ + public static native void nglPathCommandsNV(int path, int numCommands, long commands, int numCoords, int coordType, long coords); + + /** @param coordType one of:| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_FLOAT FLOAT} |
| {@link #GL_PATH_FORMAT_SVG_NV PATH_FORMAT_SVG_NV} | {@link #GL_PATH_FORMAT_PS_NV PATH_FORMAT_PS_NV} |
| {@link #GL_STANDARD_FONT_NAME_NV STANDARD_FONT_NAME_NV} | {@link #GL_SYSTEM_FONT_NAME_NV SYSTEM_FONT_NAME_NV} | {@link #GL_FILE_NAME_NV FILE_NAME_NV} |
| {@link #GL_BOLD_BIT_NV BOLD_BIT_NV} | {@link #GL_ITALIC_BIT_NV ITALIC_BIT_NV} |
| {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link #GL_UTF8_NV UTF8_NV} | {@link #GL_UTF16_NV UTF16_NV} | {@link #GL_2_BYTES_NV 2_BYTES_NV} | {@link #GL_3_BYTES_NV 3_BYTES_NV} |
| {@link #GL_4_BYTES_NV 4_BYTES_NV} |
| {@link #GL_SKIP_MISSING_GLYPH_NV SKIP_MISSING_GLYPH_NV} | {@link #GL_USE_MISSING_GLYPH_NV USE_MISSING_GLYPH_NV} |
| {@link #GL_STANDARD_FONT_NAME_NV STANDARD_FONT_NAME_NV} | {@link #GL_SYSTEM_FONT_NAME_NV SYSTEM_FONT_NAME_NV} | {@link #GL_FILE_NAME_NV FILE_NAME_NV} |
| {@link #GL_BOLD_BIT_NV BOLD_BIT_NV} | {@link #GL_ITALIC_BIT_NV ITALIC_BIT_NV} |
| {@link #GL_SKIP_MISSING_GLYPH_NV SKIP_MISSING_GLYPH_NV} | {@link #GL_USE_MISSING_GLYPH_NV USE_MISSING_GLYPH_NV} |
| {@link #GL_STANDARD_FONT_NAME_NV STANDARD_FONT_NAME_NV} | {@link #GL_SYSTEM_FONT_NAME_NV SYSTEM_FONT_NAME_NV} | {@link #GL_FILE_NAME_NV FILE_NAME_NV} |
| {@link #GL_BOLD_BIT_NV BOLD_BIT_NV} | {@link #GL_ITALIC_BIT_NV ITALIC_BIT_NV} |
| {@link #GL_STANDARD_FONT_NAME_NV STANDARD_FONT_NAME_NV} | {@link #GL_SYSTEM_FONT_NAME_NV SYSTEM_FONT_NAME_NV} | {@link #GL_FILE_NAME_NV FILE_NAME_NV} |
| {@link #GL_TRANSLATE_X_NV TRANSLATE_X_NV} | {@link #GL_TRANSLATE_Y_NV TRANSLATE_Y_NV} | {@link #GL_TRANSLATE_2D_NV TRANSLATE_2D_NV} | {@link #GL_TRANSLATE_3D_NV TRANSLATE_3D_NV} | {@link #GL_AFFINE_2D_NV AFFINE_2D_NV} |
| {@link #GL_AFFINE_3D_NV AFFINE_3D_NV} | {@link #GL_TRANSPOSE_AFFINE_2D_NV TRANSPOSE_AFFINE_2D_NV} | {@link #GL_TRANSPOSE_AFFINE_3D_NV TRANSPOSE_AFFINE_3D_NV} |
| {@link #GL_PATH_STROKE_WIDTH_NV PATH_STROKE_WIDTH_NV} | {@link #GL_PATH_INITIAL_END_CAP_NV PATH_INITIAL_END_CAP_NV} | {@link #GL_PATH_TERMINAL_END_CAP_NV PATH_TERMINAL_END_CAP_NV} |
| {@link #GL_PATH_JOIN_STYLE_NV PATH_JOIN_STYLE_NV} | {@link #GL_PATH_MITER_LIMIT_NV PATH_MITER_LIMIT_NV} | {@link #GL_PATH_INITIAL_DASH_CAP_NV PATH_INITIAL_DASH_CAP_NV} |
| {@link #GL_PATH_TERMINAL_DASH_CAP_NV PATH_TERMINAL_DASH_CAP_NV} | {@link #GL_PATH_DASH_OFFSET_NV PATH_DASH_OFFSET_NV} | {@link #GL_PATH_CLIENT_LENGTH_NV PATH_CLIENT_LENGTH_NV} |
| {@link #GL_PATH_DASH_OFFSET_RESET_NV PATH_DASH_OFFSET_RESET_NV} | {@link #GL_PATH_FILL_MODE_NV PATH_FILL_MODE_NV} | {@link #GL_PATH_FILL_MASK_NV PATH_FILL_MASK_NV} |
| {@link #GL_PATH_FILL_COVER_MODE_NV PATH_FILL_COVER_MODE_NV} | {@link #GL_PATH_STROKE_COVER_MODE_NV PATH_STROKE_COVER_MODE_NV} | {@link #GL_PATH_STROKE_MASK_NV PATH_STROKE_MASK_NV} |
| {@link #GL_PATH_STROKE_BOUND_NV PATH_STROKE_BOUND_NV} |
| {@link #GL_PATH_STROKE_WIDTH_NV PATH_STROKE_WIDTH_NV} | {@link #GL_PATH_INITIAL_END_CAP_NV PATH_INITIAL_END_CAP_NV} | {@link #GL_PATH_TERMINAL_END_CAP_NV PATH_TERMINAL_END_CAP_NV} |
| {@link #GL_PATH_JOIN_STYLE_NV PATH_JOIN_STYLE_NV} | {@link #GL_PATH_MITER_LIMIT_NV PATH_MITER_LIMIT_NV} | {@link #GL_PATH_INITIAL_DASH_CAP_NV PATH_INITIAL_DASH_CAP_NV} |
| {@link #GL_PATH_TERMINAL_DASH_CAP_NV PATH_TERMINAL_DASH_CAP_NV} | {@link #GL_PATH_DASH_OFFSET_NV PATH_DASH_OFFSET_NV} | {@link #GL_PATH_CLIENT_LENGTH_NV PATH_CLIENT_LENGTH_NV} |
| {@link #GL_PATH_DASH_OFFSET_RESET_NV PATH_DASH_OFFSET_RESET_NV} | {@link #GL_PATH_FILL_MODE_NV PATH_FILL_MODE_NV} | {@link #GL_PATH_FILL_MASK_NV PATH_FILL_MASK_NV} |
| {@link #GL_PATH_FILL_COVER_MODE_NV PATH_FILL_COVER_MODE_NV} | {@link #GL_PATH_STROKE_COVER_MODE_NV PATH_STROKE_COVER_MODE_NV} | {@link #GL_PATH_STROKE_MASK_NV PATH_STROKE_MASK_NV} |
| {@link #GL_PATH_STROKE_BOUND_NV PATH_STROKE_BOUND_NV} |
| {@link #GL_PATH_STROKE_WIDTH_NV PATH_STROKE_WIDTH_NV} | {@link #GL_PATH_INITIAL_END_CAP_NV PATH_INITIAL_END_CAP_NV} | {@link #GL_PATH_TERMINAL_END_CAP_NV PATH_TERMINAL_END_CAP_NV} |
| {@link #GL_PATH_JOIN_STYLE_NV PATH_JOIN_STYLE_NV} | {@link #GL_PATH_MITER_LIMIT_NV PATH_MITER_LIMIT_NV} | {@link #GL_PATH_INITIAL_DASH_CAP_NV PATH_INITIAL_DASH_CAP_NV} |
| {@link #GL_PATH_TERMINAL_DASH_CAP_NV PATH_TERMINAL_DASH_CAP_NV} | {@link #GL_PATH_DASH_OFFSET_NV PATH_DASH_OFFSET_NV} | {@link #GL_PATH_CLIENT_LENGTH_NV PATH_CLIENT_LENGTH_NV} |
| {@link #GL_PATH_DASH_OFFSET_RESET_NV PATH_DASH_OFFSET_RESET_NV} | {@link #GL_PATH_FILL_MODE_NV PATH_FILL_MODE_NV} | {@link #GL_PATH_FILL_MASK_NV PATH_FILL_MASK_NV} |
| {@link #GL_PATH_FILL_COVER_MODE_NV PATH_FILL_COVER_MODE_NV} | {@link #GL_PATH_STROKE_COVER_MODE_NV PATH_STROKE_COVER_MODE_NV} | {@link #GL_PATH_STROKE_MASK_NV PATH_STROKE_MASK_NV} |
| {@link #GL_PATH_STROKE_BOUND_NV PATH_STROKE_BOUND_NV} | {@link #GL_PATH_END_CAPS_NV PATH_END_CAPS_NV} | {@link #GL_PATH_DASH_CAPS_NV PATH_DASH_CAPS_NV} |
| {@link #GL_PATH_STROKE_WIDTH_NV PATH_STROKE_WIDTH_NV} | {@link #GL_PATH_INITIAL_END_CAP_NV PATH_INITIAL_END_CAP_NV} | {@link #GL_PATH_TERMINAL_END_CAP_NV PATH_TERMINAL_END_CAP_NV} |
| {@link #GL_PATH_JOIN_STYLE_NV PATH_JOIN_STYLE_NV} | {@link #GL_PATH_MITER_LIMIT_NV PATH_MITER_LIMIT_NV} | {@link #GL_PATH_INITIAL_DASH_CAP_NV PATH_INITIAL_DASH_CAP_NV} |
| {@link #GL_PATH_TERMINAL_DASH_CAP_NV PATH_TERMINAL_DASH_CAP_NV} | {@link #GL_PATH_DASH_OFFSET_NV PATH_DASH_OFFSET_NV} | {@link #GL_PATH_CLIENT_LENGTH_NV PATH_CLIENT_LENGTH_NV} |
| {@link #GL_PATH_DASH_OFFSET_RESET_NV PATH_DASH_OFFSET_RESET_NV} | {@link #GL_PATH_FILL_MODE_NV PATH_FILL_MODE_NV} | {@link #GL_PATH_FILL_MASK_NV PATH_FILL_MASK_NV} |
| {@link #GL_PATH_FILL_COVER_MODE_NV PATH_FILL_COVER_MODE_NV} | {@link #GL_PATH_STROKE_COVER_MODE_NV PATH_STROKE_COVER_MODE_NV} | {@link #GL_PATH_STROKE_MASK_NV PATH_STROKE_MASK_NV} |
| {@link #GL_PATH_STROKE_BOUND_NV PATH_STROKE_BOUND_NV} | {@link #GL_PATH_END_CAPS_NV PATH_END_CAPS_NV} | {@link #GL_PATH_DASH_CAPS_NV PATH_DASH_CAPS_NV} |
| {@link GL11#GL_INVERT INVERT} | {@link #GL_COUNT_UP_NV COUNT_UP_NV} | {@link #GL_COUNT_DOWN_NV COUNT_DOWN_NV} | {@link #GL_PATH_FILL_MODE_NV PATH_FILL_MODE_NV} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_FLOAT FLOAT} | {@link #GL_UTF8_NV UTF8_NV} | {@link #GL_UTF16_NV UTF16_NV} | {@link #GL_2_BYTES_NV 2_BYTES_NV} |
| {@link #GL_3_BYTES_NV 3_BYTES_NV} | {@link #GL_4_BYTES_NV 4_BYTES_NV} |
| {@link GL11#GL_INVERT INVERT} | {@link #GL_COUNT_UP_NV COUNT_UP_NV} | {@link #GL_COUNT_DOWN_NV COUNT_DOWN_NV} | {@link #GL_PATH_FILL_MODE_NV PATH_FILL_MODE_NV} |
| {@link #GL_TRANSLATE_X_NV TRANSLATE_X_NV} | {@link #GL_TRANSLATE_Y_NV TRANSLATE_Y_NV} | {@link #GL_TRANSLATE_2D_NV TRANSLATE_2D_NV} | {@link #GL_TRANSLATE_3D_NV TRANSLATE_3D_NV} | {@link #GL_AFFINE_2D_NV AFFINE_2D_NV} |
| {@link #GL_AFFINE_3D_NV AFFINE_3D_NV} | {@link #GL_TRANSPOSE_AFFINE_2D_NV TRANSPOSE_AFFINE_2D_NV} | {@link #GL_TRANSPOSE_AFFINE_3D_NV TRANSPOSE_AFFINE_3D_NV} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_FLOAT FLOAT} | {@link #GL_UTF8_NV UTF8_NV} | {@link #GL_UTF16_NV UTF16_NV} | {@link #GL_2_BYTES_NV 2_BYTES_NV} |
| {@link #GL_3_BYTES_NV 3_BYTES_NV} | {@link #GL_4_BYTES_NV 4_BYTES_NV} |
| {@link #GL_TRANSLATE_X_NV TRANSLATE_X_NV} | {@link #GL_TRANSLATE_Y_NV TRANSLATE_Y_NV} | {@link #GL_TRANSLATE_2D_NV TRANSLATE_2D_NV} | {@link #GL_TRANSLATE_3D_NV TRANSLATE_3D_NV} | {@link #GL_AFFINE_2D_NV AFFINE_2D_NV} |
| {@link #GL_AFFINE_3D_NV AFFINE_3D_NV} | {@link #GL_TRANSPOSE_AFFINE_2D_NV TRANSPOSE_AFFINE_2D_NV} | {@link #GL_TRANSPOSE_AFFINE_3D_NV TRANSPOSE_AFFINE_3D_NV} |
| {@link GL13#GL_PRIMARY_COLOR PRIMARY_COLOR} | {@link #GL_PRIMARY_COLOR_NV PRIMARY_COLOR_NV} | {@link #GL_SECONDARY_COLOR_NV SECONDARY_COLOR_NV} |
| {@link GL11#GL_NONE NONE} | {@link #GL_OBJECT_LINEAR_NV OBJECT_LINEAR_NV} | {@link #GL_PATH_OBJECT_BOUNDING_BOX_NV PATH_OBJECT_BOUNDING_BOX_NV} | {@link #GL_EYE_LINEAR_NV EYE_LINEAR_NV} | {@link #GL_CONSTANT_NV CONSTANT_NV} |
| {@link #GL_CONVEX_HULL_NV CONVEX_HULL_NV} | {@link #GL_BOUNDING_BOX_NV BOUNDING_BOX_NV} |
| {@link #GL_CONVEX_HULL_NV CONVEX_HULL_NV} | {@link #GL_BOUNDING_BOX_NV BOUNDING_BOX_NV} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_FLOAT FLOAT} | {@link #GL_UTF8_NV UTF8_NV} | {@link #GL_UTF16_NV UTF16_NV} | {@link #GL_2_BYTES_NV 2_BYTES_NV} |
| {@link #GL_3_BYTES_NV 3_BYTES_NV} | {@link #GL_4_BYTES_NV 4_BYTES_NV} |
| {@link #GL_CONVEX_HULL_NV CONVEX_HULL_NV} | {@link #GL_BOUNDING_BOX_NV BOUNDING_BOX_NV} | {@link #GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV BOUNDING_BOX_OF_BOUNDING_BOXES_NV} |
| {@link #GL_TRANSLATE_X_NV TRANSLATE_X_NV} | {@link #GL_TRANSLATE_Y_NV TRANSLATE_Y_NV} | {@link #GL_TRANSLATE_2D_NV TRANSLATE_2D_NV} | {@link #GL_TRANSLATE_3D_NV TRANSLATE_3D_NV} | {@link #GL_AFFINE_2D_NV AFFINE_2D_NV} |
| {@link #GL_AFFINE_3D_NV AFFINE_3D_NV} | {@link #GL_TRANSPOSE_AFFINE_2D_NV TRANSPOSE_AFFINE_2D_NV} | {@link #GL_TRANSPOSE_AFFINE_3D_NV TRANSPOSE_AFFINE_3D_NV} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_FLOAT FLOAT} | {@link #GL_UTF8_NV UTF8_NV} | {@link #GL_UTF16_NV UTF16_NV} | {@link #GL_2_BYTES_NV 2_BYTES_NV} |
| {@link #GL_3_BYTES_NV 3_BYTES_NV} | {@link #GL_4_BYTES_NV 4_BYTES_NV} |
| {@link #GL_CONVEX_HULL_NV CONVEX_HULL_NV} | {@link #GL_BOUNDING_BOX_NV BOUNDING_BOX_NV} | {@link #GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV BOUNDING_BOX_OF_BOUNDING_BOXES_NV} |
| {@link #GL_TRANSLATE_X_NV TRANSLATE_X_NV} | {@link #GL_TRANSLATE_Y_NV TRANSLATE_Y_NV} | {@link #GL_TRANSLATE_2D_NV TRANSLATE_2D_NV} | {@link #GL_TRANSLATE_3D_NV TRANSLATE_3D_NV} | {@link #GL_AFFINE_2D_NV AFFINE_2D_NV} |
| {@link #GL_AFFINE_3D_NV AFFINE_3D_NV} | {@link #GL_TRANSPOSE_AFFINE_2D_NV TRANSPOSE_AFFINE_2D_NV} | {@link #GL_TRANSPOSE_AFFINE_3D_NV TRANSPOSE_AFFINE_3D_NV} |
| {@link GL11#GL_INVERT INVERT} | {@link #GL_COUNT_UP_NV COUNT_UP_NV} | {@link #GL_COUNT_DOWN_NV COUNT_DOWN_NV} | {@link #GL_PATH_FILL_MODE_NV PATH_FILL_MODE_NV} |
| {@link #GL_CONVEX_HULL_NV CONVEX_HULL_NV} | {@link #GL_BOUNDING_BOX_NV BOUNDING_BOX_NV} |
| {@link #GL_CONVEX_HULL_NV CONVEX_HULL_NV} | {@link #GL_BOUNDING_BOX_NV BOUNDING_BOX_NV} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_FLOAT FLOAT} | {@link #GL_UTF8_NV UTF8_NV} | {@link #GL_UTF16_NV UTF16_NV} | {@link #GL_2_BYTES_NV 2_BYTES_NV} |
| {@link #GL_3_BYTES_NV 3_BYTES_NV} | {@link #GL_4_BYTES_NV 4_BYTES_NV} |
| {@link GL11#GL_INVERT INVERT} | {@link #GL_COUNT_UP_NV COUNT_UP_NV} | {@link #GL_COUNT_DOWN_NV COUNT_DOWN_NV} | {@link #GL_PATH_FILL_MODE_NV PATH_FILL_MODE_NV} |
| {@link #GL_CONVEX_HULL_NV CONVEX_HULL_NV} | {@link #GL_BOUNDING_BOX_NV BOUNDING_BOX_NV} | {@link #GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV BOUNDING_BOX_OF_BOUNDING_BOXES_NV} |
| {@link #GL_TRANSLATE_X_NV TRANSLATE_X_NV} | {@link #GL_TRANSLATE_Y_NV TRANSLATE_Y_NV} | {@link #GL_TRANSLATE_2D_NV TRANSLATE_2D_NV} | {@link #GL_TRANSLATE_3D_NV TRANSLATE_3D_NV} | {@link #GL_AFFINE_2D_NV AFFINE_2D_NV} |
| {@link #GL_AFFINE_3D_NV AFFINE_3D_NV} | {@link #GL_TRANSPOSE_AFFINE_2D_NV TRANSPOSE_AFFINE_2D_NV} | {@link #GL_TRANSPOSE_AFFINE_3D_NV TRANSPOSE_AFFINE_3D_NV} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_FLOAT FLOAT} | {@link #GL_UTF8_NV UTF8_NV} | {@link #GL_UTF16_NV UTF16_NV} | {@link #GL_2_BYTES_NV 2_BYTES_NV} |
| {@link #GL_3_BYTES_NV 3_BYTES_NV} | {@link #GL_4_BYTES_NV 4_BYTES_NV} |
| {@link #GL_CONVEX_HULL_NV CONVEX_HULL_NV} | {@link #GL_BOUNDING_BOX_NV BOUNDING_BOX_NV} | {@link #GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV BOUNDING_BOX_OF_BOUNDING_BOXES_NV} |
| {@link #GL_TRANSLATE_X_NV TRANSLATE_X_NV} | {@link #GL_TRANSLATE_Y_NV TRANSLATE_Y_NV} | {@link #GL_TRANSLATE_2D_NV TRANSLATE_2D_NV} | {@link #GL_TRANSLATE_3D_NV TRANSLATE_3D_NV} | {@link #GL_AFFINE_2D_NV AFFINE_2D_NV} |
| {@link #GL_AFFINE_3D_NV AFFINE_3D_NV} | {@link #GL_TRANSPOSE_AFFINE_2D_NV TRANSPOSE_AFFINE_2D_NV} | {@link #GL_TRANSPOSE_AFFINE_3D_NV TRANSPOSE_AFFINE_3D_NV} |
| {@link #GL_STANDARD_FONT_NAME_NV STANDARD_FONT_NAME_NV} | {@link #GL_SYSTEM_FONT_NAME_NV SYSTEM_FONT_NAME_NV} | {@link #GL_FILE_NAME_NV FILE_NAME_NV} |
| {@link #GL_BOLD_BIT_NV BOLD_BIT_NV} | {@link #GL_ITALIC_BIT_NV ITALIC_BIT_NV} |
| {@link #GL_PATH_STROKE_WIDTH_NV PATH_STROKE_WIDTH_NV} | {@link #GL_PATH_INITIAL_END_CAP_NV PATH_INITIAL_END_CAP_NV} | {@link #GL_PATH_TERMINAL_END_CAP_NV PATH_TERMINAL_END_CAP_NV} |
| {@link #GL_PATH_JOIN_STYLE_NV PATH_JOIN_STYLE_NV} | {@link #GL_PATH_MITER_LIMIT_NV PATH_MITER_LIMIT_NV} | {@link #GL_PATH_INITIAL_DASH_CAP_NV PATH_INITIAL_DASH_CAP_NV} |
| {@link #GL_PATH_TERMINAL_DASH_CAP_NV PATH_TERMINAL_DASH_CAP_NV} | {@link #GL_PATH_DASH_OFFSET_NV PATH_DASH_OFFSET_NV} | {@link #GL_PATH_CLIENT_LENGTH_NV PATH_CLIENT_LENGTH_NV} |
| {@link #GL_PATH_DASH_OFFSET_RESET_NV PATH_DASH_OFFSET_RESET_NV} | {@link #GL_PATH_FILL_MODE_NV PATH_FILL_MODE_NV} | {@link #GL_PATH_FILL_MASK_NV PATH_FILL_MASK_NV} |
| {@link #GL_PATH_FILL_COVER_MODE_NV PATH_FILL_COVER_MODE_NV} | {@link #GL_PATH_STROKE_COVER_MODE_NV PATH_STROKE_COVER_MODE_NV} | {@link #GL_PATH_STROKE_MASK_NV PATH_STROKE_MASK_NV} |
| {@link #GL_PATH_STROKE_BOUND_NV PATH_STROKE_BOUND_NV} | {@link #GL_PATH_COMMAND_COUNT_NV PATH_COMMAND_COUNT_NV} | {@link #GL_PATH_COORD_COUNT_NV PATH_COORD_COUNT_NV} |
| {@link #GL_PATH_DASH_ARRAY_COUNT_NV PATH_DASH_ARRAY_COUNT_NV} | {@link #GL_PATH_COMPUTED_LENGTH_NV PATH_COMPUTED_LENGTH_NV} | {@link #GL_PATH_FILL_BOUNDING_BOX_NV PATH_FILL_BOUNDING_BOX_NV} |
| {@link #GL_PATH_STROKE_BOUNDING_BOX_NV PATH_STROKE_BOUNDING_BOX_NV} |
| {@link #GL_PATH_STROKE_WIDTH_NV PATH_STROKE_WIDTH_NV} | {@link #GL_PATH_INITIAL_END_CAP_NV PATH_INITIAL_END_CAP_NV} | {@link #GL_PATH_TERMINAL_END_CAP_NV PATH_TERMINAL_END_CAP_NV} |
| {@link #GL_PATH_JOIN_STYLE_NV PATH_JOIN_STYLE_NV} | {@link #GL_PATH_MITER_LIMIT_NV PATH_MITER_LIMIT_NV} | {@link #GL_PATH_INITIAL_DASH_CAP_NV PATH_INITIAL_DASH_CAP_NV} |
| {@link #GL_PATH_TERMINAL_DASH_CAP_NV PATH_TERMINAL_DASH_CAP_NV} | {@link #GL_PATH_DASH_OFFSET_NV PATH_DASH_OFFSET_NV} | {@link #GL_PATH_CLIENT_LENGTH_NV PATH_CLIENT_LENGTH_NV} |
| {@link #GL_PATH_DASH_OFFSET_RESET_NV PATH_DASH_OFFSET_RESET_NV} | {@link #GL_PATH_FILL_MODE_NV PATH_FILL_MODE_NV} | {@link #GL_PATH_FILL_MASK_NV PATH_FILL_MASK_NV} |
| {@link #GL_PATH_FILL_COVER_MODE_NV PATH_FILL_COVER_MODE_NV} | {@link #GL_PATH_STROKE_COVER_MODE_NV PATH_STROKE_COVER_MODE_NV} | {@link #GL_PATH_STROKE_MASK_NV PATH_STROKE_MASK_NV} |
| {@link #GL_PATH_STROKE_BOUND_NV PATH_STROKE_BOUND_NV} | {@link #GL_PATH_COMMAND_COUNT_NV PATH_COMMAND_COUNT_NV} | {@link #GL_PATH_COORD_COUNT_NV PATH_COORD_COUNT_NV} |
| {@link #GL_PATH_DASH_ARRAY_COUNT_NV PATH_DASH_ARRAY_COUNT_NV} | {@link #GL_PATH_COMPUTED_LENGTH_NV PATH_COMPUTED_LENGTH_NV} | {@link #GL_PATH_FILL_BOUNDING_BOX_NV PATH_FILL_BOUNDING_BOX_NV} |
| {@link #GL_PATH_STROKE_BOUNDING_BOX_NV PATH_STROKE_BOUNDING_BOX_NV} |
| {@link #GL_PATH_STROKE_WIDTH_NV PATH_STROKE_WIDTH_NV} | {@link #GL_PATH_INITIAL_END_CAP_NV PATH_INITIAL_END_CAP_NV} | {@link #GL_PATH_TERMINAL_END_CAP_NV PATH_TERMINAL_END_CAP_NV} |
| {@link #GL_PATH_JOIN_STYLE_NV PATH_JOIN_STYLE_NV} | {@link #GL_PATH_MITER_LIMIT_NV PATH_MITER_LIMIT_NV} | {@link #GL_PATH_INITIAL_DASH_CAP_NV PATH_INITIAL_DASH_CAP_NV} |
| {@link #GL_PATH_TERMINAL_DASH_CAP_NV PATH_TERMINAL_DASH_CAP_NV} | {@link #GL_PATH_DASH_OFFSET_NV PATH_DASH_OFFSET_NV} | {@link #GL_PATH_CLIENT_LENGTH_NV PATH_CLIENT_LENGTH_NV} |
| {@link #GL_PATH_DASH_OFFSET_RESET_NV PATH_DASH_OFFSET_RESET_NV} | {@link #GL_PATH_FILL_MODE_NV PATH_FILL_MODE_NV} | {@link #GL_PATH_FILL_MASK_NV PATH_FILL_MASK_NV} |
| {@link #GL_PATH_FILL_COVER_MODE_NV PATH_FILL_COVER_MODE_NV} | {@link #GL_PATH_STROKE_COVER_MODE_NV PATH_STROKE_COVER_MODE_NV} | {@link #GL_PATH_STROKE_MASK_NV PATH_STROKE_MASK_NV} |
| {@link #GL_PATH_STROKE_BOUND_NV PATH_STROKE_BOUND_NV} | {@link #GL_PATH_COMMAND_COUNT_NV PATH_COMMAND_COUNT_NV} | {@link #GL_PATH_COORD_COUNT_NV PATH_COORD_COUNT_NV} |
| {@link #GL_PATH_DASH_ARRAY_COUNT_NV PATH_DASH_ARRAY_COUNT_NV} | {@link #GL_PATH_COMPUTED_LENGTH_NV PATH_COMPUTED_LENGTH_NV} | {@link #GL_PATH_FILL_BOUNDING_BOX_NV PATH_FILL_BOUNDING_BOX_NV} |
| {@link #GL_PATH_STROKE_BOUNDING_BOX_NV PATH_STROKE_BOUNDING_BOX_NV} |
| {@link #GL_PATH_STROKE_WIDTH_NV PATH_STROKE_WIDTH_NV} | {@link #GL_PATH_INITIAL_END_CAP_NV PATH_INITIAL_END_CAP_NV} | {@link #GL_PATH_TERMINAL_END_CAP_NV PATH_TERMINAL_END_CAP_NV} |
| {@link #GL_PATH_JOIN_STYLE_NV PATH_JOIN_STYLE_NV} | {@link #GL_PATH_MITER_LIMIT_NV PATH_MITER_LIMIT_NV} | {@link #GL_PATH_INITIAL_DASH_CAP_NV PATH_INITIAL_DASH_CAP_NV} |
| {@link #GL_PATH_TERMINAL_DASH_CAP_NV PATH_TERMINAL_DASH_CAP_NV} | {@link #GL_PATH_DASH_OFFSET_NV PATH_DASH_OFFSET_NV} | {@link #GL_PATH_CLIENT_LENGTH_NV PATH_CLIENT_LENGTH_NV} |
| {@link #GL_PATH_DASH_OFFSET_RESET_NV PATH_DASH_OFFSET_RESET_NV} | {@link #GL_PATH_FILL_MODE_NV PATH_FILL_MODE_NV} | {@link #GL_PATH_FILL_MASK_NV PATH_FILL_MASK_NV} |
| {@link #GL_PATH_FILL_COVER_MODE_NV PATH_FILL_COVER_MODE_NV} | {@link #GL_PATH_STROKE_COVER_MODE_NV PATH_STROKE_COVER_MODE_NV} | {@link #GL_PATH_STROKE_MASK_NV PATH_STROKE_MASK_NV} |
| {@link #GL_PATH_STROKE_BOUND_NV PATH_STROKE_BOUND_NV} | {@link #GL_PATH_COMMAND_COUNT_NV PATH_COMMAND_COUNT_NV} | {@link #GL_PATH_COORD_COUNT_NV PATH_COORD_COUNT_NV} |
| {@link #GL_PATH_DASH_ARRAY_COUNT_NV PATH_DASH_ARRAY_COUNT_NV} | {@link #GL_PATH_COMPUTED_LENGTH_NV PATH_COMPUTED_LENGTH_NV} | {@link #GL_PATH_FILL_BOUNDING_BOX_NV PATH_FILL_BOUNDING_BOX_NV} |
| {@link #GL_PATH_STROKE_BOUNDING_BOX_NV PATH_STROKE_BOUNDING_BOX_NV} |
| {@link #GL_GLYPH_WIDTH_BIT_NV GLYPH_WIDTH_BIT_NV} | {@link #GL_GLYPH_HEIGHT_BIT_NV GLYPH_HEIGHT_BIT_NV} |
| {@link #GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV GLYPH_HORIZONTAL_BEARING_X_BIT_NV} | {@link #GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV GLYPH_HORIZONTAL_BEARING_Y_BIT_NV} |
| {@link #GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV} | {@link #GL_GLYPH_VERTICAL_BEARING_X_BIT_NV GLYPH_VERTICAL_BEARING_X_BIT_NV} |
| {@link #GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV GLYPH_VERTICAL_BEARING_Y_BIT_NV} | {@link #GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV} |
| {@link #GL_GLYPH_HAS_KERNING_BIT_NV GLYPH_HAS_KERNING_BIT_NV} | {@link #GL_FONT_X_MIN_BOUNDS_BIT_NV FONT_X_MIN_BOUNDS_BIT_NV} |
| {@link #GL_FONT_Y_MIN_BOUNDS_BIT_NV FONT_Y_MIN_BOUNDS_BIT_NV} | {@link #GL_FONT_X_MAX_BOUNDS_BIT_NV FONT_X_MAX_BOUNDS_BIT_NV} |
| {@link #GL_FONT_Y_MAX_BOUNDS_BIT_NV FONT_Y_MAX_BOUNDS_BIT_NV} | {@link #GL_FONT_UNITS_PER_EM_BIT_NV FONT_UNITS_PER_EM_BIT_NV} |
| {@link #GL_FONT_ASCENDER_BIT_NV FONT_ASCENDER_BIT_NV} | {@link #GL_FONT_DESCENDER_BIT_NV FONT_DESCENDER_BIT_NV} |
| {@link #GL_FONT_HEIGHT_BIT_NV FONT_HEIGHT_BIT_NV} | {@link #GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV FONT_MAX_ADVANCE_WIDTH_BIT_NV} |
| {@link #GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV FONT_MAX_ADVANCE_HEIGHT_BIT_NV} | {@link #GL_FONT_UNDERLINE_POSITION_BIT_NV FONT_UNDERLINE_POSITION_BIT_NV} |
| {@link #GL_FONT_UNDERLINE_THICKNESS_BIT_NV FONT_UNDERLINE_THICKNESS_BIT_NV} | {@link #GL_FONT_HAS_KERNING_BIT_NV FONT_HAS_KERNING_BIT_NV} |
| {@link #GL_FONT_NUM_GLYPH_INDICES_BIT_NV FONT_NUM_GLYPH_INDICES_BIT_NV} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_FLOAT FLOAT} | {@link #GL_UTF8_NV UTF8_NV} | {@link #GL_UTF16_NV UTF16_NV} | {@link #GL_2_BYTES_NV 2_BYTES_NV} |
| {@link #GL_3_BYTES_NV 3_BYTES_NV} | {@link #GL_4_BYTES_NV 4_BYTES_NV} |
| {@link #GL_GLYPH_WIDTH_BIT_NV GLYPH_WIDTH_BIT_NV} | {@link #GL_GLYPH_HEIGHT_BIT_NV GLYPH_HEIGHT_BIT_NV} |
| {@link #GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV GLYPH_HORIZONTAL_BEARING_X_BIT_NV} | {@link #GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV GLYPH_HORIZONTAL_BEARING_Y_BIT_NV} |
| {@link #GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV} | {@link #GL_GLYPH_VERTICAL_BEARING_X_BIT_NV GLYPH_VERTICAL_BEARING_X_BIT_NV} |
| {@link #GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV GLYPH_VERTICAL_BEARING_Y_BIT_NV} | {@link #GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV} |
| {@link #GL_GLYPH_HAS_KERNING_BIT_NV GLYPH_HAS_KERNING_BIT_NV} | {@link #GL_FONT_X_MIN_BOUNDS_BIT_NV FONT_X_MIN_BOUNDS_BIT_NV} |
| {@link #GL_FONT_Y_MIN_BOUNDS_BIT_NV FONT_Y_MIN_BOUNDS_BIT_NV} | {@link #GL_FONT_X_MAX_BOUNDS_BIT_NV FONT_X_MAX_BOUNDS_BIT_NV} |
| {@link #GL_FONT_Y_MAX_BOUNDS_BIT_NV FONT_Y_MAX_BOUNDS_BIT_NV} | {@link #GL_FONT_UNITS_PER_EM_BIT_NV FONT_UNITS_PER_EM_BIT_NV} |
| {@link #GL_FONT_ASCENDER_BIT_NV FONT_ASCENDER_BIT_NV} | {@link #GL_FONT_DESCENDER_BIT_NV FONT_DESCENDER_BIT_NV} |
| {@link #GL_FONT_HEIGHT_BIT_NV FONT_HEIGHT_BIT_NV} | {@link #GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV FONT_MAX_ADVANCE_WIDTH_BIT_NV} |
| {@link #GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV FONT_MAX_ADVANCE_HEIGHT_BIT_NV} | {@link #GL_FONT_UNDERLINE_POSITION_BIT_NV FONT_UNDERLINE_POSITION_BIT_NV} |
| {@link #GL_FONT_UNDERLINE_THICKNESS_BIT_NV FONT_UNDERLINE_THICKNESS_BIT_NV} | {@link #GL_FONT_HAS_KERNING_BIT_NV FONT_HAS_KERNING_BIT_NV} |
| {@link #GL_FONT_NUM_GLYPH_INDICES_BIT_NV FONT_NUM_GLYPH_INDICES_BIT_NV} |
| {@link #GL_ACCUM_ADJACENT_PAIRS_NV ACCUM_ADJACENT_PAIRS_NV} | {@link #GL_ADJACENT_PAIRS_NV ADJACENT_PAIRS_NV} | {@link #GL_FIRST_TO_REST_NV FIRST_TO_REST_NV} |
| {@link GL11#GL_BYTE BYTE} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} | {@link GL11#GL_SHORT SHORT} | {@link GL11#GL_UNSIGNED_SHORT UNSIGNED_SHORT} | {@link GL11#GL_INT INT} | {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_FLOAT FLOAT} | {@link #GL_UTF8_NV UTF8_NV} | {@link #GL_UTF16_NV UTF16_NV} | {@link #GL_2_BYTES_NV 2_BYTES_NV} |
| {@link #GL_3_BYTES_NV 3_BYTES_NV} | {@link #GL_4_BYTES_NV 4_BYTES_NV} |
| {@link #GL_TRANSLATE_X_NV TRANSLATE_X_NV} | {@link #GL_TRANSLATE_2D_NV TRANSLATE_2D_NV} |
| {@link GL13#GL_PRIMARY_COLOR PRIMARY_COLOR} | {@link #GL_PRIMARY_COLOR_NV PRIMARY_COLOR_NV} | {@link #GL_SECONDARY_COLOR_NV SECONDARY_COLOR_NV} |
| {@link #GL_PATH_GEN_MODE_NV PATH_GEN_MODE_NV} | {@link #GL_PATH_GEN_COEFF_NV PATH_GEN_COEFF_NV} | {@link #GL_PATH_GEN_COLOR_FORMAT_NV PATH_GEN_COLOR_FORMAT_NV} |
| {@link GL13#GL_PRIMARY_COLOR PRIMARY_COLOR} | {@link #GL_PRIMARY_COLOR_NV PRIMARY_COLOR_NV} | {@link #GL_SECONDARY_COLOR_NV SECONDARY_COLOR_NV} |
| {@link #GL_PATH_GEN_MODE_NV PATH_GEN_MODE_NV} | {@link #GL_PATH_GEN_COEFF_NV PATH_GEN_COEFF_NV} | {@link #GL_PATH_GEN_COLOR_FORMAT_NV PATH_GEN_COLOR_FORMAT_NV} |
| {@link GL13#GL_PRIMARY_COLOR PRIMARY_COLOR} | {@link #GL_PRIMARY_COLOR_NV PRIMARY_COLOR_NV} | {@link #GL_SECONDARY_COLOR_NV SECONDARY_COLOR_NV} |
| {@link #GL_PATH_GEN_MODE_NV PATH_GEN_MODE_NV} | {@link #GL_PATH_GEN_COEFF_NV PATH_GEN_COEFF_NV} | {@link #GL_PATH_GEN_COLOR_FORMAT_NV PATH_GEN_COLOR_FORMAT_NV} |
| {@link GL13#GL_PRIMARY_COLOR PRIMARY_COLOR} | {@link #GL_PRIMARY_COLOR_NV PRIMARY_COLOR_NV} | {@link #GL_SECONDARY_COLOR_NV SECONDARY_COLOR_NV} |
| {@link #GL_PATH_GEN_MODE_NV PATH_GEN_MODE_NV} | {@link #GL_PATH_GEN_COEFF_NV PATH_GEN_COEFF_NV} | {@link #GL_PATH_GEN_COLOR_FORMAT_NV PATH_GEN_COLOR_FORMAT_NV} |
| {@link #GL_PATH_PROJECTION_NV PATH_PROJECTION_NV} | {@link #GL_PATH_MODELVIEW_NV PATH_MODELVIEW_NV} |
| {@link #GL_PATH_PROJECTION_NV PATH_PROJECTION_NV} | {@link #GL_PATH_MODELVIEW_NV PATH_MODELVIEW_NV} |
| {@link #GL_PATH_PROJECTION_NV PATH_PROJECTION_NV} | {@link #GL_PATH_MODELVIEW_NV PATH_MODELVIEW_NV} |
| {@link #GL_PATH_PROJECTION_NV PATH_PROJECTION_NV} | {@link #GL_PATH_MODELVIEW_NV PATH_MODELVIEW_NV} |
| {@link #GL_PATH_PROJECTION_NV PATH_PROJECTION_NV} | {@link #GL_PATH_MODELVIEW_NV PATH_MODELVIEW_NV} |
| {@link #GL_PATH_PROJECTION_NV PATH_PROJECTION_NV} | {@link #GL_PATH_MODELVIEW_NV PATH_MODELVIEW_NV} |
This extension introduces a new path command modifier to the NV_path_rendering extension to indicate that a path command represents an edge (either + * straight or curved) that is shared with another path.
+ * + *When used in conjunction with {@link NVFramebufferMixedSamples NV_framebuffer_mixed_samples}, a shared edge (or a whole path including shared edges) will use modified + * rasterization rules in order to ensure that groups of raster samples associated with a given coverage sample will all produce consistent coverage + * results, in order to avoid artifacts described further in the issues section at the end of this document.
+ * + *Requires {@link NVPathRendering NV_path_rendering}.
+ */ +public final class NVPathRenderingSharedEdge { + + /** Allowed to be added to command tokens in elements of the {@code commands} array parameter of PathCommandsNV and PathSubCommandsNV. */ + public static final int GL_SHARED_EDGE_NV = 0xC0; + + private NVPathRenderingSharedEdge() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPixelDataRange.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPixelDataRange.java new file mode 100644 index 00000000..ecba268c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPixelDataRange.java @@ -0,0 +1,94 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_pixel_data_range extension. + * + *The vertex array range extension is intended to improve the efficiency of OpenGL vertex arrays. OpenGL vertex arrays' coherency model and ability to + * access memory from arbitrary locations in memory prevented implementations from using DMA (Direct Memory Access) operations.
+ * + *Many image-intensive applications, such as those that use dynamically generated textures, face similar problems. These applications would like to be + * able to sustain throughputs of hundreds of millions of pixels per second through DrawPixels and hundreds of millions of texels per second through + * TexSubImage.
+ * + *However, the same restrictions that limited vertex throughput also limit pixel throughput.
+ * + *By the time that any pixel operation that reads data from user memory returns, OpenGL requires that it must be safe for the application to start using + * that memory for a different purpose. This coherency model prevents asynchronous DMA transfers directly out of the user's buffer.
+ * + *There are also no restrictions on the pointer provided to pixel operations or on the size of the data. To facilitate DMA implementations, the driver + * needs to know in advance what region of the address space to lock down.
+ * + *Vertex arrays faced both of these restrictions already, but pixel operations have one additional complicating factor -- they are bidirectional. Vertex + * array data is always being transfered from the application to the driver and the HW, whereas pixel operations sometimes transfer data to the + * application from the driver and HW. Note that the types of memory that are suitable for DMA for reading and writing purposes are often different. For + * example, on many PC platforms, DMA pulling is best accomplished with write-combined (uncached) AGP memory, while pushing data should use cached memory + * so that the application can read the data efficiently once it has been read back over the AGP bus.
+ * + *This extension defines an API where an application can specify two pixel data ranges, which are analogous to vertex array ranges, except that one is + * for operations where the application is reading data (e.g. glReadPixels) and one is for operations where the application is writing data (e.g. + * glDrawPixels, glTexSubImage2D, etc.). Each pixel data range has a pointer to its start and a length in bytes.
+ * + *When the pixel data range is enabled, and if the pointer specified as the argument to a pixel operation is inside the corresponding pixel data range, + * the implementation may choose to asynchronously pull data from the pixel data range or push data to the pixel data range. Data pulled from outside the + * pixel data range is undefined, while pushing data to outside the pixel data range produces undefined results.
+ * + *The application may synchronize with the hardware in one of two ways: by flushing the pixel data range (or causing an implicit flush) or by using the + * NV_fence extension to insert fences in the command stream.
+ */ +public class NVPixelDataRange { + + /** + * Accepted by the {@code target} parameter of PixelDataRangeNV and FlushPixelDataRangeNV, and by the {@code cap} parameter of EnableClientState, + * DisableClientState, and IsEnabled. + */ + public static final int + GL_WRITE_PIXEL_DATA_RANGE_NV = 0x8878, + GL_READ_PIXEL_DATA_RANGE_NV = 0x8879; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = 0x887A, + GL_READ_PIXEL_DATA_RANGE_LENGTH_NV = 0x887B; + + /** Accepted by the {@code pname} parameter of GetPointerv. */ + public static final int + GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV = 0x887C, + GL_READ_PIXEL_DATA_RANGE_POINTER_NV = 0x887D; + + static { GL.initialize(); } + + protected NVPixelDataRange() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glPixelDataRangeNV, caps.glFlushPixelDataRangeNV + ); + } + + // --- [ glPixelDataRangeNV ] --- + + public static native void nglPixelDataRangeNV(int target, int length, long pointer); + + public static void glPixelDataRangeNV(@NativeType("GLenum") int target, @NativeType("void const *") ByteBuffer pointer) { + nglPixelDataRangeNV(target, pointer.remaining(), memAddress(pointer)); + } + + // --- [ glFlushPixelDataRangeNV ] --- + + public static native void glFlushPixelDataRangeNV(@NativeType("GLenum") int target); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPointSprite.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPointSprite.java new file mode 100644 index 00000000..faad2b99 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPointSprite.java @@ -0,0 +1,91 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_point_sprite extension. + * + *Applications such as particle systems usually must use OpenGL quads rather than points to render their geometry, since they would like to use a + * custom-drawn texture for each particle, rather than the traditional OpenGL round antialiased points, and each fragment in a point has the same texture + * coordinates as every other fragment.
+ * + *Unfortunately, specifying the geometry for these quads can be quite expensive, since it quadruples the amount of geometry required, and it may also + * require the application to do extra processing to compute the location of each vertex.
+ * + *The goal of this extension is to allow such apps to use points rather than quads. When {@link #GL_POINT_SPRITE_NV POINT_SPRITE_NV} is enabled, the state of point antialiasing + * is ignored. For each texture unit, the app can then specify whether to replace the existing texture coordinates with point sprite texture coordinates, + * which are interpolated across the point. Finally, the app can set a global parameter for the way to generate the R coordinate for point sprites; the R + * coordinate can either be zero, the input S coordinate, or the input R coordinate. This allows applications to use a 3D texture to represent a point + * sprite that goes through an animation, with filtering between frames, for example.
+ * + *Requires {@link EXTPointParameters EXT_point_parameters}.
+ */ +public class NVPointSprite { + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev, and by the {@code target} parameter of TexEnvi, TexEnviv, TexEnvf, TexEnvfv, GetTexEnviv, and GetTexEnvfv. + */ + public static final int GL_POINT_SPRITE_NV = 0x8861; + + /** + * When the {@code target} parameter of TexEnvf, TexEnvfv, TexEnvi, TexEnviv, GetTexEnvfv, or GetTexEnviv is POINT_SPRITE_NV, then the value of + * {@code pname} may be. + */ + public static final int GL_COORD_REPLACE_NV = 0x8862; + + /** + * Accepted by the {@code pname} parameter of PointParameteriNV, PointParameterfEXT, PointParameterivNV, PointParameterfvEXT, GetBooleanv, GetIntegerv, + * GetFloatv, and GetDoublev. + */ + public static final int GL_POINT_SPRITE_R_MODE_NV = 0x8863; + + static { GL.initialize(); } + + protected NVPointSprite() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glPointParameteriNV, caps.glPointParameterivNV + ); + } + + // --- [ glPointParameteriNV ] --- + + public static native void glPointParameteriNV(@NativeType("GLenum") int pname, @NativeType("GLint") int param); + + // --- [ glPointParameterivNV ] --- + + public static native void nglPointParameterivNV(int pname, long params); + + public static void glPointParameterivNV(@NativeType("GLenum") int pname, @NativeType("GLint const *") IntBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglPointParameterivNV(pname, memAddress(params)); + } + + /** Array version of: {@link #glPointParameterivNV PointParameterivNV} */ + public static void glPointParameterivNV(@NativeType("GLenum") int pname, @NativeType("GLint const *") int[] params) { + long __functionAddress = GL.getICD().glPointParameterivNV; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(pname, params, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPrimitiveRestart.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPrimitiveRestart.java new file mode 100644 index 00000000..c94b90df --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVPrimitiveRestart.java @@ -0,0 +1,60 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the NV_primitive_restart extension. + * + *This extension allows applications to easily and inexpensively restart a primitive in its middle. A "primitive restart" is simply the same as an End + * command, followed by another Begin command with the same mode as the original. The typical expected use of this feature is to draw a mesh with many + * triangle strips, though primitive restarts are legal for all primitive types, even for points (where they are not useful).
+ * + *Although the EXT_multi_draw_arrays extension did reduce the overhead of such drawing techniques, they still remain more expensive than one would like.
+ * + *This extension provides an extremely lightweight primitive restart, which is accomplished by allowing the application to choose a special index number + * that signals that a primitive restart should occur, rather than a vertex being provoked. This index can be an arbitrary 32-bit integer for maximum + * application convenience.
+ * + *In addition, for full orthogonality, a special OpenGL command is provided to restart primitives when in immediate mode. This command is not likely to + * increase performance in any significant fashion, but providing it greatly simplifies the specification and implementation of display list compilation + * and indirect rendering.
+ */ +public class NVPrimitiveRestart { + + /** + * Accepted by the {@code array} parameter of EnableClientState and DisableClientState, by the {@code cap} parameter of IsEnabled, and by the {@code pname} + * parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. + */ + public static final int GL_PRIMITIVE_RESTART_NV = 0x8558; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int GL_PRIMITIVE_RESTART_INDEX_NV = 0x8559; + + static { GL.initialize(); } + + protected NVPrimitiveRestart() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glPrimitiveRestartNV, caps.glPrimitiveRestartIndexNV + ); + } + + // --- [ glPrimitiveRestartNV ] --- + + public static native void glPrimitiveRestartNV(); + + // --- [ glPrimitiveRestartIndexNV ] --- + + public static native void glPrimitiveRestartIndexNV(@NativeType("GLuint") int index); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVQueryResource.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVQueryResource.java new file mode 100644 index 00000000..ad363995 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVQueryResource.java @@ -0,0 +1,79 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_query_resource extension. + * + *OpenGL implementations manage the residence of textures, shaders, and other graphical objects in GPU accessible memory (whether in on-board video + * memory or addressable system memory is implementation dependent). With more insight into OpenGL's memory usage 1) applications could make educated + * decisions on better utilizing the limited GPU resources, 2) users could better optimize their workflow when working with multiple tools, and 3) + * administrators can make better decisions regarding resource allocation and system configurations.
+ * + *The purpose of this extension is to return a more detailed breakdown of memory usage in terms of the OpenGL objects residing in memory (textures, + * render buffers, buffer objects, system reserved objects, ...). This extension differs from GL_NVX_gpu_memory_info in that this extension returns + * detailed memory usage at the object level for video memory while the other extension only reports total vidmem usage.
+ * + *For the purposes of this specification the term vidmem refers to video memory resident on the graphics card that is directly accessible to the GPU at + * the highest performance level.
+ * + *Requires {@link GL20 OpenGL 2.0}.
+ */ +public class NVQueryResource { + + /** Accepted by the {@code queryType} parameter of {@link #glQueryResourceNV QueryResourceNV}. */ + public static final int GL_QUERY_RESOURCE_TYPE_VIDMEM_ALLOC_NV = 0x9540; + + /** New enums defined. */ + public static final int + GL_QUERY_RESOURCE_MEMTYPE_VIDMEM_NV = 0x9542, + GL_QUERY_RESOURCE_SYS_RESERVED_NV = 0x9544, + GL_QUERY_RESOURCE_TEXTURE_NV = 0x9545, + GL_QUERY_RESOURCE_RENDERBUFFER_NV = 0x9546, + GL_QUERY_RESOURCE_BUFFEROBJECT_NV = 0x9547; + + static { GL.initialize(); } + + protected NVQueryResource() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glQueryResourceNV + ); + } + + // --- [ glQueryResourceNV ] --- + + /** Unsafe version of: {@link #glQueryResourceNV QueryResourceNV} */ + public static native int nglQueryResourceNV(int queryType, int pname, int bufSize, long buffer); + + /** @param queryType must be:| {@link #GL_QUERY_RESOURCE_TYPE_VIDMEM_ALLOC_NV QUERY_RESOURCE_TYPE_VIDMEM_ALLOC_NV} |
This extension adds the capability to associate a tag with one or more memory resource allocations. This tag can be reported back during + * {@code queryResource} operations and also be used to limit resource reporting to only those allocations with the specified tag. A tag is a previously + * reserved id and an optional text string.
+ * + *Requires {@link GL20 OpenGL 2.0} and {@link NVQueryResource NV_query_resource}.
+ */ +public class NVQueryResourceTag { + + static { GL.initialize(); } + + protected NVQueryResourceTag() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glGenQueryResourceTagNV, caps.glDeleteQueryResourceTagNV, caps.glQueryResourceTagNV + ); + } + + // --- [ glGenQueryResourceTagNV ] --- + + public static native void nglGenQueryResourceTagNV(int n, long tagIds); + + public static void glGenQueryResourceTagNV(@NativeType("GLuint *") IntBuffer tagIds) { + nglGenQueryResourceTagNV(tagIds.remaining(), memAddress(tagIds)); + } + + @NativeType("void") + public static int glGenQueryResourceTagNV() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer tagIds = stack.callocInt(1); + nglGenQueryResourceTagNV(1, memAddress(tagIds)); + return tagIds.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glDeleteQueryResourceTagNV ] --- + + public static native void nglDeleteQueryResourceTagNV(int n, long tagIds); + + public static void glDeleteQueryResourceTagNV(@NativeType("GLuint const *") IntBuffer tagIds) { + nglDeleteQueryResourceTagNV(tagIds.remaining(), memAddress(tagIds)); + } + + public static void glDeleteQueryResourceTagNV(@NativeType("GLuint const *") int tagId) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer tagIds = stack.ints(tagId); + nglDeleteQueryResourceTagNV(1, memAddress(tagIds)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glQueryResourceTagNV ] --- + + public static native void nglQueryResourceTagNV(int tagId, long tagString); + + public static void glQueryResourceTagNV(@NativeType("GLuint") int tagId, @NativeType("GLchar const *") ByteBuffer tagString) { + if (CHECKS) { + checkNT1(tagString); + } + nglQueryResourceTagNV(tagId, memAddress(tagString)); + } + + public static void glQueryResourceTagNV(@NativeType("GLuint") int tagId, @NativeType("GLchar const *") CharSequence tagString) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nASCII(tagString, true); + long tagStringEncoded = stack.getPointerAddress(); + nglQueryResourceTagNV(tagId, tagStringEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + /** Array version of: {@link #glGenQueryResourceTagNV GenQueryResourceTagNV} */ + public static void glGenQueryResourceTagNV(@NativeType("GLuint *") int[] tagIds) { + long __functionAddress = GL.getICD().glGenQueryResourceTagNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(tagIds.length, tagIds, __functionAddress); + } + + /** Array version of: {@link #glDeleteQueryResourceTagNV DeleteQueryResourceTagNV} */ + public static void glDeleteQueryResourceTagNV(@NativeType("GLuint const *") int[] tagIds) { + long __functionAddress = GL.getICD().glDeleteQueryResourceTagNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(tagIds.length, tagIds, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVRepresentativeFragmentTest.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVRepresentativeFragmentTest.java new file mode 100644 index 00000000..d30eb61d --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVRepresentativeFragmentTest.java @@ -0,0 +1,38 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_representative_fragment_test extension. + * + *This extension provides a new representative fragment test that allows implementations to reduce the amount of rasterization and fragment + * processing work performed for each point, line, or triangle primitive. For any primitive that produces one or more fragments that pass all other early + * fragment tests, the implementation is permitted to choose one or more "representative" fragments for processing and discard all other fragments. For + * draw calls rendering multiple points, lines, or triangles arranged in lists, strips, or fans, the representative fragment test is performed + * independently for each of those primitives.
+ * + *This extension is useful for applications that use an early render pass to determine the full set of primitives that would be visible in the final + * scene. In this render pass, such applications would set up a fragment shader that enables early fragment tests and writes to an image or shader storage + * buffer to record the ID of the primitive that generated the fragment. Without this extension, the shader would record the ID separately for each + * visible fragment of each primitive. With this extension, fewer stores will be performed, particularly for large primitives.
+ * + *The representative fragment test has no effect if early fragment tests are not enabled via the fragment shader. The set of fragments discarded by the + * representative fragment test is implementation-dependent and may vary from frame to frame. In some cases, the representative fragment test may not + * discard any fragments for a given primitive.
+ * + *Requires {@link GL45 OpenGL 4.5}.
+ */ +public final class NVRepresentativeFragmentTest { + + /** + * Accepted by the {@code cap} parameter of {@link CGL#CGLEnable Enable}, {@link CGL#CGLDisable Disable}, and {@link CGL#CGLIsEnabled IsEnabled}, and by the {@code pname} parameter of {@link GL11C#glGetBooleanv GetBooleanv}, {@link GL11C#glGetIntegerv GetIntegerv}, + * {@link GL11C#glGetFloatv GetFloatv}, and {@link GL11C#glGetDoublev GetDoublev}. + */ + public static final int GL_REPRESENTATIVE_FRAGMENT_TEST_NV = 0x937F; + + private NVRepresentativeFragmentTest() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVRobustnessVideoMemoryPurge.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVRobustnessVideoMemoryPurge.java new file mode 100644 index 00000000..088bd659 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVRobustnessVideoMemoryPurge.java @@ -0,0 +1,32 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_robustness_video_memory_purge extension. + * + *This extension allows applications to be notified when video memory has been purged.
+ * + *The NVIDIA OpenGL driver architecture on Linux has a limitation: resources located in video memory are not persistent across certain events. VT + * switches, suspend/resume events, and mode switching events may erase the contents of video memory. Any resource that is located exclusively in video + * memory, such as framebuffer objects (FBOs), will be lost. As the OpenGL specification makes no mention of events where the video memory is allowed to + * be cleared, the driver attempts to hide this fact from the application, but cannot do it for all resources.
+ * + *This extension provides a way for applications to discover when video memory content has been lost, so that the application can re-populate the video + * memory content as necessary.
+ * + *This extension will have a limited lifespan, as planned architectural evolutions in the NVIDIA Linux driver stack will allow video memory to be + * persistent. Any driver that exposes this extension is a driver that considers video memory to be volatile. Once the driver stack has been improved, the + * extension will no longer be exposed.
+ */ +public final class NVRobustnessVideoMemoryPurge { + + /** Returned by GetGraphicsResetStatusARB, in addition to other tokens defined in ARB_robustness. */ + public static final int GL_PURGED_CONTEXT_RESET_NV = 0x92BB; + + private NVRobustnessVideoMemoryPurge() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVSampleLocations.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVSampleLocations.java new file mode 100644 index 00000000..f39de524 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVSampleLocations.java @@ -0,0 +1,135 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_sample_locations extension. + * + *This extension allows an application to modify the locations of samples within a pixel used in multisample rasterization. Additionally, it allows + * applications to specify different sample locations for each pixel in a group of adjacent pixels, which may increase antialiasing quality (particularly + * if a custom resolve shader is used that takes advantage of these different locations).
+ * + *It is common for implementations to optimize the storage of depth values by storing values that can be used to reconstruct depth at each sample + * location, rather than storing separate depth values for each sample. For example, the depth values from a single triangle can be represented using + * plane equations. When the depth value for a sample is needed, it is automatically evaluated at the sample location. Modifying the sample locations + * causes the reconstruction to no longer evaluate the same depth values as when the samples were originally generated. This extension provides a command + * to "resolve" and store per-sample depth values using the currently programmed sample locations, which allows the application to manage this issue + * if/when necessary.
+ * + *The programmable sample locations are used during rasterization and for evaluation of depth functions during normal geometric rendering. The + * programmable locations are associated with a framebuffer object rather than an individual depth buffer, so if the depth buffer is used as a texture the + * texture sampling may be done at the standard sample locations. Additionally, commands that do not render geometric primitives (e.g. ReadPixels, + * BlitFramebuffer, CopyTexSubImage2D, etc.) may use the standard sample locations to resolve depth functions rather than the programmable locations. If a + * single depth buffer is used at different times with different sample locations, the depth functions may be interpreted using the current sample + * locations.
+ */ +public class NVSampleLocations { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */ + public static final int + GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV = 0x933D, + GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV = 0x933E, + GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV = 0x933F, + GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV = 0x9340; + + /** Accepted by the {@code pname} parameter of GetMultisamplefv. */ + public static final int + GL_SAMPLE_LOCATION_NV = 0x8E50, + GL_PROGRAMMABLE_SAMPLE_LOCATION_NV = 0x9341; + + /** Accepted by the {@code pname} parameter of FramebufferParameteri, GetFramebufferParameteriv. */ + public static final int + GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV = 0x9342, + GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV = 0x9343; + + static { GL.initialize(); } + + protected NVSampleLocations() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glFramebufferSampleLocationsfvNV, caps.glNamedFramebufferSampleLocationsfvNV, caps.glResolveDepthValuesNV + ); + } + + // --- [ glFramebufferSampleLocationsfvNV ] --- + + /** + * Unsafe version of: {@link #glFramebufferSampleLocationsfvNV FramebufferSampleLocationsfvNV} + * + * @param count the number of sample locations to modify + */ + public static native void nglFramebufferSampleLocationsfvNV(int target, int start, int count, long v); + + /** + * Updates the programmable sample locations + * + * @param target the framebuffer whose programmable sample locations are modified + * @param start the index of the first sample location to modify + * @param v a pair of floating point values in the range [0,1] for each sample location + */ + public static void glFramebufferSampleLocationsfvNV(@NativeType("GLenum") int target, @NativeType("GLuint") int start, @NativeType("GLfloat const *") FloatBuffer v) { + nglFramebufferSampleLocationsfvNV(target, start, v.remaining() >> 1, memAddress(v)); + } + + // --- [ glNamedFramebufferSampleLocationsfvNV ] --- + + /** + * Unsafe version of: {@link #glNamedFramebufferSampleLocationsfvNV NamedFramebufferSampleLocationsfvNV} + * + * @param count the number of sample locations to modify + */ + public static native void nglNamedFramebufferSampleLocationsfvNV(int framebuffer, int start, int count, long v); + + /** + * Updates the programmable sample locations + * + * @param framebuffer the framebuffer whose programmable sample locations are modified + * @param start the index of the first sample location to modify + * @param v a pair of floating point values in the range [0,1] for each sample location + */ + public static void glNamedFramebufferSampleLocationsfvNV(@NativeType("GLuint") int framebuffer, @NativeType("GLuint") int start, @NativeType("GLfloat const *") FloatBuffer v) { + nglNamedFramebufferSampleLocationsfvNV(framebuffer, start, v.remaining() >> 1, memAddress(v)); + } + + // --- [ glResolveDepthValuesNV ] --- + + /** + * Evaluates depth values for all samples in the current depth buffer (subject to the pixel ownership and scissor tests) and stores each value in the + * depth buffer. This can be used to ensure that later accesses will use depth values consistent with the sample locations used when the samples were + * generated. If the current framebuffer has no depth buffer, ResolveDepthValuesNV will have no effect. + */ + public static native void glResolveDepthValuesNV(); + + /** Array version of: {@link #glFramebufferSampleLocationsfvNV FramebufferSampleLocationsfvNV} */ + public static void glFramebufferSampleLocationsfvNV(@NativeType("GLenum") int target, @NativeType("GLuint") int start, @NativeType("GLfloat const *") float[] v) { + long __functionAddress = GL.getICD().glFramebufferSampleLocationsfvNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(target, start, v.length >> 1, v, __functionAddress); + } + + /** Array version of: {@link #glNamedFramebufferSampleLocationsfvNV NamedFramebufferSampleLocationsfvNV} */ + public static void glNamedFramebufferSampleLocationsfvNV(@NativeType("GLuint") int framebuffer, @NativeType("GLuint") int start, @NativeType("GLfloat const *") float[] v) { + long __functionAddress = GL.getICD().glNamedFramebufferSampleLocationsfvNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(framebuffer, start, v.length >> 1, v, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVScissorExclusive.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVScissorExclusive.java new file mode 100644 index 00000000..ca40c7a5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVScissorExclusive.java @@ -0,0 +1,79 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_scissor_exclusive extension. + * + *In unextended OpenGL, applications can enable a per-viewport scissor test ({@link GL11#GL_SCISSOR_TEST SCISSOR_TEST}) where fragments are discarded if their (x,y) coordinates lie + * outside the corresponding scissor rectangle. In this extension, we provide a separate per-viewport exclusive scissor test, where fragments are + * discarded if their (x,y) coordinates lie inside the corresponding exclusive scissor rectangle.
+ * + *The regular (inclusive) scissor test and exclusive scissor test are orthogonal; applications can enable either or both tests for each viewport. If both + * tests are enabled, fragments will be discarded unless their (x,y) coordinates are both inside the regular scissor rectangle and outside the exclusive + * scissor rectangle.
+ * + *Requires {@link GL45 OpenGL 4.5}.
+ */ +public class NVScissorExclusive { + + /** + * Accepted by the {@code cap} parameter of {@link CGL#CGLEnable Enable}, {@link CGL#CGLDisable Disable}, and {@link CGL#CGLIsEnabled IsEnabled}, by the {@code target} parameter of {@link GL30C#glEnablei Enablei}, {@link GL30C#glDisablei Disablei}, + * {@link GL30C#glIsEnabledi IsEnabledi}, {@link EXTDrawBuffers2#glEnableIndexedEXT EnableIndexedEXT}, {@link EXTDrawBuffers2#glDisableIndexedEXT DisableIndexedEXT}, and {@link EXTDrawBuffers2#glIsEnabledIndexedEXT IsEnabledIndexedEXT}, and by the {@code pname} parameter of {@link GL11C#glGetBooleanv GetBooleanv}, + * {@link GL11C#glGetIntegerv GetIntegerv}, {@link GL32C#glGetInteger64v GetInteger64v}, {@link GL11C#glGetFloatv GetFloatv}, {@link GL11C#glGetDoublev GetDoublev}, {@link EXTDirectStateAccess#glGetDoubleIndexedvEXT GetDoubleIndexedvEXT}, {@link GL30C#glGetBooleani_v GetBooleani_v}, {@link GL30C#glGetIntegeri_v GetIntegeri_v}, {@link GL32C#glGetInteger64i_v GetInteger64i_v}, + * {@link GL41C#glGetFloati_v GetFloati_v}, {@link GL41C#glGetDoublei_v GetDoublei_v}, {@link EXTDrawBuffers2#glGetBooleanIndexedvEXT GetBooleanIndexedvEXT}, {@link EXTDrawBuffers2#glGetIntegerIndexedvEXT GetIntegerIndexedvEXT}, and {@link EXTDirectStateAccess#glGetFloatIndexedvEXT GetFloatIndexedvEXT}. + */ + public static final int GL_SCISSOR_TEST_EXCLUSIVE_NV = 0x9555; + + /** + * Accepted by the {@code pname} parameter of {@link GL11C#glGetBooleanv GetBooleanv}, {@link GL11C#glGetIntegerv GetIntegerv}, {@link GL32C#glGetInteger64v GetInteger64v}, {@link GL11C#glGetFloatv GetFloatv}, {@link GL11C#glGetDoublev GetDoublev}, {@link GL30C#glGetBooleani_v GetBooleani_v}, + * {@link GL30C#glGetIntegeri_v GetIntegeri_v}, {@link GL32C#glGetInteger64i_v GetInteger64i_v}, {@link GL41C#glGetFloati_v GetFloati_v}, {@link GL41C#glGetDoublei_v GetDoublei_v}, {@link EXTDirectStateAccess#glGetDoubleIndexedvEXT GetDoubleIndexedvEXT}, {@link EXTDrawBuffers2#glGetBooleanIndexedvEXT GetBooleanIndexedvEXT}, {@link EXTDrawBuffers2#glGetIntegerIndexedvEXT GetIntegerIndexedvEXT}, and + * {@link EXTDirectStateAccess#glGetFloatIndexedvEXT GetFloatIndexedvEXT}. + */ + public static final int GL_SCISSOR_BOX_EXCLUSIVE_NV = 0x9556; + + static { GL.initialize(); } + + protected NVScissorExclusive() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glScissorExclusiveArrayvNV, caps.glScissorExclusiveNV + ); + } + + // --- [ glScissorExclusiveArrayvNV ] --- + + public static native void nglScissorExclusiveArrayvNV(int first, int count, long v); + + public static void glScissorExclusiveArrayvNV(@NativeType("GLuint") int first, @NativeType("GLint const *") IntBuffer v) { + nglScissorExclusiveArrayvNV(first, v.remaining() >> 2, memAddress(v)); + } + + // --- [ glScissorExclusiveNV ] --- + + public static native void glScissorExclusiveNV(@NativeType("GLint") int x, @NativeType("GLint") int y, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height); + + /** Array version of: {@link #glScissorExclusiveArrayvNV ScissorExclusiveArrayvNV} */ + public static void glScissorExclusiveArrayvNV(@NativeType("GLuint") int first, @NativeType("GLint const *") int[] v) { + long __functionAddress = GL.getICD().glScissorExclusiveArrayvNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(first, v.length >> 2, v, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShaderBufferLoad.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShaderBufferLoad.java new file mode 100644 index 00000000..15d80e09 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShaderBufferLoad.java @@ -0,0 +1,316 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_shader_buffer_load extension. + * + *At a very coarse level, GL has evolved in a way that allows applications to replace many of the original state machine variables with blocks of + * user-defined data. For example, the current vertex state has been augmented by vertex buffer objects, fixed-function shading state and parameters have + * been replaced by shaders/programs and constant buffers, etc. Applications switch between coarse sets of state by binding objects to the context or to + * other container objects (e.g. vertex array objects) instead of manipulating state variables of the context. In terms of the number of GL commands + * required to draw an object, modern applications are orders of magnitude more efficient than legacy applications, but this explosion of objects bound to + * other objects has led to a new bottleneck - pointer chasing and CPU L2 cache misses in the driver, and general L2 cache pollution.
+ * + *This extension provides a mechanism to read from a flat, 64-bit GPU address space from programs/shaders, to query GPU addresses of buffer objects at the + * API level, and to bind buffer objects to the context in such a way that they can be accessed via their GPU addresses in any shader stage.
+ * + *The intent is that applications can avoid re-binding buffer objects or updating constants between each Draw call and instead simply use a VertexAttrib + * (or TexCoord, or InstanceID, or...) to "point" to the new object's state. In this way, one of the cheapest "state" updates (from the CPU's point of + * view) can be used to effect a significant state change in the shader similarly to how a pointer change may on the CPU. At the same time, this relieves + * the limits on how many buffer objects can be accessed at once by shaders, and allows these buffer object accesses to be exposed as C-style pointer + * dereferences in the shading language.
+ * + *As a very simple example, imagine packing a group of similar objects' constants into a single buffer object and pointing your program at object + * <i> by setting {@code glVertexAttribI1iEXT(attrLoc, i);} and using a shader as such:
+ * + *
+ * struct MyObjectType {
+ * mat4x4 modelView;
+ * vec4 materialPropertyX;
+ * // etc.
+ * };
+ * uniform MyObjectType *allObjects;
+ * in int objectID; // bound to attrLoc
+ *
+ * ...
+ *
+ * mat4x4 thisObjectsMatrix = allObjects[objectID].modelView;
+ * // do transform, shading, etc.This is beneficial in much the same way that texture arrays allow choosing between similar, but independent, texture maps with a single coordinate + * identifying which slice of the texture to use. It also resembles instancing, where a lightweight change (incrementing the instance ID) can be used to + * generate a different and interesting result, but with additional flexibility over instancing because the values are app-controlled and not a single incrementing counter.
+ * + *Dependent pointer fetches are allowed, so more complex scene graph structures can be built into buffer objects providing significant new flexibility in + * the use of shaders. Another simple example, showing something you can't do with existing functionality, is to do dependent fetches into many buffer + * objects:
+ * + *
+ * GenBuffers(N, dataBuffers);
+ * GenBuffers(1, &pointerBuffer);
+ *
+ * GLuint64EXT gpuAddrs[N];
+ * for (i = 0; i < N; ++i) {
+ * BindBuffer(target, dataBuffers[i]);
+ * BufferData(target, size[i], myData[i], STATIC_DRAW);
+ *
+ * // get the address of this buffer and make it resident.
+ * GetBufferParameterui64vNV(target, BUFFER_GPU_ADDRESS,
+ * gpuaddrs[i]);
+ * MakeBufferResidentNV(target, READ_ONLY);
+ * }
+ *
+ * GLuint64EXT pointerBufferAddr;
+ * BindBuffer(target, pointerBuffer);
+ * BufferData(target, sizeof(GLuint64EXT)*N, gpuAddrs, STATIC_DRAW);
+ * GetBufferParameterui64vNV(target, BUFFER_GPU_ADDRESS,
+ * &pointerBufferAddr);
+ * MakeBufferResidentNV(target, READ_ONLY);
+ *
+ * // now in the shader, we can use a double indirection
+ * vec4 **ptrToBuffers = pointerBufferAddr;
+ * vec4 *ptrToBufferI = ptrToBuffers[i];This allows simultaneous access to more buffers than {@link EXTBindableUniform EXT_bindable_uniform} ({@link EXTBindableUniform#GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT MAX_VERTEX_BINDABLE_UNIFORMS_EXT}, etc.) and each can be larger than + * {@link EXTBindableUniform#GL_MAX_BINDABLE_UNIFORM_SIZE_EXT MAX_BINDABLE_UNIFORM_SIZE_EXT}.
+ */ +public class NVShaderBufferLoad { + + /** Accepted by the {@code pname} parameter of GetBufferParameterui64vNV, GetNamedBufferParameterui64vNV. */ + public static final int GL_BUFFER_GPU_ADDRESS_NV = 0x8F1D; + + /** Returned by the {@code type} parameter of GetActiveUniform. */ + public static final int GL_GPU_ADDRESS_NV = 0x8F34; + + /** Accepted by the {@code value} parameter of GetIntegerui64vNV. */ + public static final int GL_MAX_SHADER_BUFFER_ADDRESS_NV = 0x8F35; + + static { GL.initialize(); } + + protected NVShaderBufferLoad() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glMakeBufferResidentNV, caps.glMakeBufferNonResidentNV, caps.glIsBufferResidentNV, caps.glMakeNamedBufferResidentNV, + caps.glMakeNamedBufferNonResidentNV, caps.glIsNamedBufferResidentNV, caps.glGetBufferParameterui64vNV, caps.glGetNamedBufferParameterui64vNV, + caps.glGetIntegerui64vNV, caps.glUniformui64NV, caps.glUniformui64vNV, caps.glGetUniformui64vNV, caps.glProgramUniformui64NV, + caps.glProgramUniformui64vNV + ); + } + + // --- [ glMakeBufferResidentNV ] --- + + public static native void glMakeBufferResidentNV(@NativeType("GLenum") int target, @NativeType("GLenum") int access); + + // --- [ glMakeBufferNonResidentNV ] --- + + public static native void glMakeBufferNonResidentNV(@NativeType("GLenum") int target); + + // --- [ glIsBufferResidentNV ] --- + + @NativeType("GLboolean") + public static native boolean glIsBufferResidentNV(@NativeType("GLenum") int target); + + // --- [ glMakeNamedBufferResidentNV ] --- + + public static native void glMakeNamedBufferResidentNV(@NativeType("GLuint") int buffer, @NativeType("GLenum") int access); + + // --- [ glMakeNamedBufferNonResidentNV ] --- + + public static native void glMakeNamedBufferNonResidentNV(@NativeType("GLuint") int buffer); + + // --- [ glIsNamedBufferResidentNV ] --- + + @NativeType("GLboolean") + public static native boolean glIsNamedBufferResidentNV(@NativeType("GLuint") int buffer); + + // --- [ glGetBufferParameterui64vNV ] --- + + public static native void nglGetBufferParameterui64vNV(int target, int pname, long params); + + public static void glGetBufferParameterui64vNV(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLuint64EXT *") LongBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetBufferParameterui64vNV(target, pname, memAddress(params)); + } + + @NativeType("void") + public static long glGetBufferParameterui64NV(@NativeType("GLenum") int target, @NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer params = stack.callocLong(1); + nglGetBufferParameterui64vNV(target, pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetNamedBufferParameterui64vNV ] --- + + public static native void nglGetNamedBufferParameterui64vNV(int buffer, int pname, long params); + + public static void glGetNamedBufferParameterui64vNV(@NativeType("GLuint") int buffer, @NativeType("GLenum") int pname, @NativeType("GLuint64EXT *") LongBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetNamedBufferParameterui64vNV(buffer, pname, memAddress(params)); + } + + @NativeType("void") + public static long glGetNamedBufferParameterui64NV(@NativeType("GLuint") int buffer, @NativeType("GLenum") int pname) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer params = stack.callocLong(1); + nglGetNamedBufferParameterui64vNV(buffer, pname, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetIntegerui64vNV ] --- + + public static native void nglGetIntegerui64vNV(int value, long result); + + public static void glGetIntegerui64vNV(@NativeType("GLenum") int value, @NativeType("GLuint64EXT *") LongBuffer result) { + if (CHECKS) { + check(result, 1); + } + nglGetIntegerui64vNV(value, memAddress(result)); + } + + @NativeType("void") + public static long glGetIntegerui64NV(@NativeType("GLenum") int value) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer result = stack.callocLong(1); + nglGetIntegerui64vNV(value, memAddress(result)); + return result.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glUniformui64NV ] --- + + public static native void glUniformui64NV(@NativeType("GLint") int location, @NativeType("GLuint64EXT") long value); + + // --- [ glUniformui64vNV ] --- + + public static native void nglUniformui64vNV(int location, int count, long value); + + public static void glUniformui64vNV(@NativeType("GLint") int location, @NativeType("GLuint64EXT const *") LongBuffer value) { + nglUniformui64vNV(location, value.remaining(), memAddress(value)); + } + + // --- [ glGetUniformui64vNV ] --- + + public static native void nglGetUniformui64vNV(int program, int location, long params); + + public static void glGetUniformui64vNV(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64EXT *") LongBuffer params) { + if (CHECKS) { + check(params, 1); + } + nglGetUniformui64vNV(program, location, memAddress(params)); + } + + @NativeType("void") + public static long glGetUniformui64NV(@NativeType("GLuint") int program, @NativeType("GLint") int location) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer params = stack.callocLong(1); + nglGetUniformui64vNV(program, location, memAddress(params)); + return params.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glProgramUniformui64NV ] --- + + public static native void glProgramUniformui64NV(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64EXT") long value); + + // --- [ glProgramUniformui64vNV ] --- + + public static native void nglProgramUniformui64vNV(int program, int location, int count, long value); + + public static void glProgramUniformui64vNV(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64EXT const *") LongBuffer value) { + nglProgramUniformui64vNV(program, location, value.remaining(), memAddress(value)); + } + + /** Array version of: {@link #glGetBufferParameterui64vNV GetBufferParameterui64vNV} */ + public static void glGetBufferParameterui64vNV(@NativeType("GLenum") int target, @NativeType("GLenum") int pname, @NativeType("GLuint64EXT *") long[] params) { + long __functionAddress = GL.getICD().glGetBufferParameterui64vNV; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(target, pname, params, __functionAddress); + } + + /** Array version of: {@link #glGetNamedBufferParameterui64vNV GetNamedBufferParameterui64vNV} */ + public static void glGetNamedBufferParameterui64vNV(@NativeType("GLuint") int buffer, @NativeType("GLenum") int pname, @NativeType("GLuint64EXT *") long[] params) { + long __functionAddress = GL.getICD().glGetNamedBufferParameterui64vNV; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(buffer, pname, params, __functionAddress); + } + + /** Array version of: {@link #glGetIntegerui64vNV GetIntegerui64vNV} */ + public static void glGetIntegerui64vNV(@NativeType("GLenum") int value, @NativeType("GLuint64EXT *") long[] result) { + long __functionAddress = GL.getICD().glGetIntegerui64vNV; + if (CHECKS) { + check(__functionAddress); + check(result, 1); + } + callPV(value, result, __functionAddress); + } + + /** Array version of: {@link #glUniformui64vNV Uniformui64vNV} */ + public static void glUniformui64vNV(@NativeType("GLint") int location, @NativeType("GLuint64EXT const *") long[] value) { + long __functionAddress = GL.getICD().glUniformui64vNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(location, value.length, value, __functionAddress); + } + + /** Array version of: {@link #glGetUniformui64vNV GetUniformui64vNV} */ + public static void glGetUniformui64vNV(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64EXT *") long[] params) { + long __functionAddress = GL.getICD().glGetUniformui64vNV; + if (CHECKS) { + check(__functionAddress); + check(params, 1); + } + callPV(program, location, params, __functionAddress); + } + + /** Array version of: {@link #glProgramUniformui64vNV ProgramUniformui64vNV} */ + public static void glProgramUniformui64vNV(@NativeType("GLuint") int program, @NativeType("GLint") int location, @NativeType("GLuint64EXT const *") long[] value) { + long __functionAddress = GL.getICD().glProgramUniformui64vNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(program, location, value.length, value, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShaderBufferStore.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShaderBufferStore.java new file mode 100644 index 00000000..4e683ff8 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShaderBufferStore.java @@ -0,0 +1,26 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_shader_buffer_store extension. + * + *This extension builds upon the mechanisms added by the NV_shader_buffer_load extension to allow shaders to perform random-access + * reads to buffer object memory without using dedicated buffer object binding points. Instead, it allowed an application to make a buffer + * object resident, query a GPU address (pointer) for the buffer object, and then use that address as a pointer in shader code. This approach allows + * shaders to access a large number of buffer objects without needing to repeatedly bind buffers to a limited number of fixed-functionality binding + * points.
+ * + *Requires {@link GL30 OpenGL 3.0}, GLSL 1.30, {@link NVShaderBufferLoad NV_shader_buffer_load}, NV_gpu_program5 and/or {@link NVGPUShader5 NV_gpu_shader5}.
+ */ +public final class NVShaderBufferStore { + + /** Accepted by the {@code barriers} parameter of MemoryBarrierNV. */ + public static final int GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV = 0x10; + + private NVShaderBufferStore() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShaderSubgroupPartitioned.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShaderSubgroupPartitioned.java new file mode 100644 index 00000000..bd17ddd7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShaderSubgroupPartitioned.java @@ -0,0 +1,26 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_shader_subgroup_partitioned extension. + * + *This extension enables support for the {@code NV_shader_subgroup_partitioned} shading language extension in OpenGL.
+ * + *This extension adds a new {@link #GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV SUBGROUP_FEATURE_PARTITIONED_BIT_NV} feature bit that is returned by queryies for {@link KHRShaderSubgroup#GL_SUBGROUP_SUPPORTED_FEATURES_KHR SUBGROUP_SUPPORTED_FEATURES_KHR}.
+ * + *In OpenGL implementations supporting SPIR-V, this extension enables support for the {@code SPV_NV_shader_subgroup_partitioned} extension.
+ * + *Requires {@link GL43 OpenGL 4.3} and {@link KHRShaderSubgroup KHR_shader_subgroup}.
+ */ +public final class NVShaderSubgroupPartitioned { + + /** Returned as bitfield in the {@code data} argument when {@link GL11C#glGetIntegerv GetIntegerv} is queried with a {@code pname} of {@link KHRShaderSubgroup#GL_SUBGROUP_SUPPORTED_FEATURES_KHR SUBGROUP_SUPPORTED_FEATURES_KHR}. */ + public static final int GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x100; + + private NVShaderSubgroupPartitioned() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShaderThreadGroup.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShaderThreadGroup.java new file mode 100644 index 00000000..34c35d2b --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShaderThreadGroup.java @@ -0,0 +1,27 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_shader_thread_group extension. + * + *Implementations of the OpenGL Shading Language may, but are not required to, run multiple shader threads for a single stage as a SIMD thread group, + * where individual execution threads are assigned to thread groups in an undefined, implementation-dependent order. This extension provides a set of new + * features to the OpenGL Shading Language to query thread states and to share data between fragments within a 2x2 pixel quad.
+ * + *Requires {@link GL43 OpenGL 4.3}.
+ */ +public final class NVShaderThreadGroup { + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_WARP_SIZE_NV = 0x9339, + GL_WARPS_PER_SM_NV = 0x933A, + GL_SM_COUNT_NV = 0x933B; + + private NVShaderThreadGroup() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShadingRateImage.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShadingRateImage.java new file mode 100644 index 00000000..fe349b1f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVShadingRateImage.java @@ -0,0 +1,187 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_shading_rate_image extension. + * + *By default, OpenGL runs a fragment shader once for each pixel covered by a primitive being rasterized. When using multisampling, the outputs of that + * fragment shader are broadcast to each covered sample of the fragment's pixel. When using multisampling, applications can also request that the fragment + * shader be run once per color sample (when using the {@code "sample"} qualifier on one or more active fragment shader inputs), or run a fixed number of + * times per pixel using {@link GL40#GL_SAMPLE_SHADING SAMPLE_SHADING} enable and the {@link GL40C#glMinSampleShading MinSampleShading} frequency value. In all of these approaches, the number of fragment shader + * invocations per pixel is fixed, based on API state.
+ * + *This extension allows applications to bind and enable a shading rate image that can be used to vary the number of fragment shader invocations across + * the framebuffer. This can be useful for applications like eye tracking for virtual reality, where the portion of the framebuffer that the user is + * looking at directly can be processed at high frequency, while distant corners of the image can be processed at lower frequency. The shading rate image + * is an immutable-format two-dimensional or two-dimensional array texture that uses a format of {@link GL30#GL_R8UI R8UI}. Each texel represents a fixed-size rectangle in + * the framebuffer, covering 16x16 pixels in the initial implementation of this extension. When rasterizing a primitive covering one of these rectangles, + * the OpenGL implementation reads the texel in the bound shading rate image and looks up the fetched value in a palette of shading rates. The shading + * rate used can vary from (finest) 16 fragment shader invocations per pixel to (coarsest) one fragment shader invocation for each 4x4 block of pixels.
+ * + *When this extension is advertised by an OpenGL implementation, the implementation must also support the GLSL extension + * {@code "GL_NV_shading_rate_image"} (documented separately), which provides new built-in variables that allow fragment shaders to determine the + * effective shading rate used for each fragment. Additionally, the GLSL extension also provides new layout qualifiers allowing the interlock + * functionality provided by ARB_fragment_shader_interlock to guarantee mutual exclusion across an entire fragment when the shading rate specifies + * multiple pixels per fragment shader invocation.
+ * + *Note that this extension requires the use of a framebuffer object; the shading rate image and related state are ignored when rendering to the default + * framebuffer.
+ * + *Requires {@link GL45 OpenGL 4.5} and {@link NVFramebufferMixedSamples NV_framebuffer_mixed_samples}.
+ */ +public class NVShadingRateImage { + + /** + * Accepted by the {@code cap} parameter of {@link CGL#CGLEnable Enable}, {@link CGL#CGLDisable Disable}, and {@link CGL#CGLIsEnabled IsEnabled}, by the {@code target} parameter of {@link GL30C#glEnablei Enablei}, {@link GL30C#glDisablei Disablei}, + * {@link GL30C#glIsEnabledi IsEnabledi}, {@link EXTDrawBuffers2#glEnableIndexedEXT EnableIndexedEXT}, {@link EXTDrawBuffers2#glDisableIndexedEXT DisableIndexedEXT}, and {@link EXTDrawBuffers2#glIsEnabledIndexedEXT IsEnabledIndexedEXT}, and by the {@code pname} parameter of {@link GL11C#glGetBooleanv GetBooleanv}, + * {@link GL11C#glGetIntegerv GetIntegerv}, {@link GL32C#glGetInteger64v GetInteger64v}, {@link GL11C#glGetFloatv GetFloatv}, {@link GL11C#glGetDoublev GetDoublev}, {@link EXTDirectStateAccess#glGetDoubleIndexedvEXT GetDoubleIndexedvEXT}, {@link GL30C#glGetBooleani_v GetBooleani_v}, {@link GL30C#glGetIntegeri_v GetIntegeri_v}, {@link GL32C#glGetInteger64i_v GetInteger64i_v}, + * {@link GL41C#glGetFloati_v GetFloati_v}, {@link GL41C#glGetDoublei_v GetDoublei_v}, {@link EXTDrawBuffers2#glGetBooleanIndexedvEXT GetBooleanIndexedvEXT}, {@link EXTDrawBuffers2#glGetIntegerIndexedvEXT GetIntegerIndexedvEXT}, and {@link EXTDirectStateAccess#glGetFloatIndexedvEXT GetFloatIndexedvEXT}. + */ + public static final int GL_SHADING_RATE_IMAGE_NV = 0x9563; + + /** + * Accepted in the {@code rates} parameter of {@link #glShadingRateImagePaletteNV ShadingRateImagePaletteNV} and the {@code rate} parameter of {@link #glShadingRateSampleOrderCustomNV ShadingRateSampleOrderCustomNV} and + * {@link #glGetShadingRateSampleLocationivNV GetShadingRateSampleLocationivNV}; returned in the {@code rate} parameter of {@link #glGetShadingRateImagePaletteNV GetShadingRateImagePaletteNV}. + */ + public static final int + GL_SHADING_RATE_NO_INVOCATIONS_NV = 0x9564, + GL_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0x9565, + GL_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 0x9566, + GL_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 0x9567, + GL_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 0x9568, + GL_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 0x9569, + GL_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 0x956A, + GL_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 0x956B, + GL_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 0x956C, + GL_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 0x956D, + GL_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 0x956E, + GL_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 0x956F; + + /** Accepted by the {@code pname} parameter of {@link GL11C#glGetBooleanv GetBooleanv}, {@link GL11C#glGetDoublev GetDoublev}, {@link GL11C#glGetIntegerv GetIntegerv}, and {@link GL11C#glGetFloatv GetFloatv}. */ + public static final int + GL_SHADING_RATE_IMAGE_BINDING_NV = 0x955B, + GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV = 0x955C, + GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV = 0x955D, + GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV = 0x955E, + GL_MAX_COARSE_FRAGMENT_SAMPLES_NV = 0x955F; + + /** Accepted by the {@code order} parameter of {@link #glShadingRateSampleOrderNV ShadingRateSampleOrderNV}. */ + public static final int + GL_SHADING_RATE_SAMPLE_ORDER_DEFAULT_NV = 0x95AE, + GL_SHADING_RATE_SAMPLE_ORDER_PIXEL_MAJOR_NV = 0x95AF, + GL_SHADING_RATE_SAMPLE_ORDER_SAMPLE_MAJOR_NV = 0x95B0; + + static { GL.initialize(); } + + protected NVShadingRateImage() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBindShadingRateImageNV, caps.glShadingRateImagePaletteNV, caps.glGetShadingRateImagePaletteNV, caps.glShadingRateImageBarrierNV, + caps.glShadingRateSampleOrderNV, caps.glShadingRateSampleOrderCustomNV, caps.glGetShadingRateSampleLocationivNV + ); + } + + // --- [ glBindShadingRateImageNV ] --- + + public static native void glBindShadingRateImageNV(@NativeType("GLuint") int texture); + + // --- [ glShadingRateImagePaletteNV ] --- + + public static native void nglShadingRateImagePaletteNV(int viewport, int first, int count, long rates); + + public static void glShadingRateImagePaletteNV(@NativeType("GLuint") int viewport, @NativeType("GLuint") int first, @NativeType("GLenum const *") IntBuffer rates) { + nglShadingRateImagePaletteNV(viewport, first, rates.remaining(), memAddress(rates)); + } + + // --- [ glGetShadingRateImagePaletteNV ] --- + + public static native void nglGetShadingRateImagePaletteNV(int viewport, int entry, long rate); + + public static void glGetShadingRateImagePaletteNV(@NativeType("GLuint") int viewport, @NativeType("GLuint") int entry, @NativeType("GLenum *") IntBuffer rate) { + if (CHECKS) { + check(rate, 1); + } + nglGetShadingRateImagePaletteNV(viewport, entry, memAddress(rate)); + } + + // --- [ glShadingRateImageBarrierNV ] --- + + public static native void glShadingRateImageBarrierNV(@NativeType("GLboolean") boolean synchronize); + + // --- [ glShadingRateSampleOrderNV ] --- + + public static native void glShadingRateSampleOrderNV(@NativeType("GLenum") int order); + + // --- [ glShadingRateSampleOrderCustomNV ] --- + + public static native void nglShadingRateSampleOrderCustomNV(int rate, int samples, long locations); + + public static void glShadingRateSampleOrderCustomNV(@NativeType("GLenum") int rate, @NativeType("GLuint") int samples, @NativeType("GLint const *") IntBuffer locations) { + nglShadingRateSampleOrderCustomNV(rate, samples, memAddress(locations)); + } + + // --- [ glGetShadingRateSampleLocationivNV ] --- + + public static native void nglGetShadingRateSampleLocationivNV(int rate, int samples, int index, long location); + + public static void glGetShadingRateSampleLocationivNV(@NativeType("GLenum") int rate, @NativeType("GLuint") int samples, @NativeType("GLuint") int index, @NativeType("GLint *") IntBuffer location) { + if (CHECKS) { + check(location, 3); + } + nglGetShadingRateSampleLocationivNV(rate, samples, index, memAddress(location)); + } + + /** Array version of: {@link #glShadingRateImagePaletteNV ShadingRateImagePaletteNV} */ + public static void glShadingRateImagePaletteNV(@NativeType("GLuint") int viewport, @NativeType("GLuint") int first, @NativeType("GLenum const *") int[] rates) { + long __functionAddress = GL.getICD().glShadingRateImagePaletteNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(viewport, first, rates.length, rates, __functionAddress); + } + + /** Array version of: {@link #glGetShadingRateImagePaletteNV GetShadingRateImagePaletteNV} */ + public static void glGetShadingRateImagePaletteNV(@NativeType("GLuint") int viewport, @NativeType("GLuint") int entry, @NativeType("GLenum *") int[] rate) { + long __functionAddress = GL.getICD().glGetShadingRateImagePaletteNV; + if (CHECKS) { + check(__functionAddress); + check(rate, 1); + } + callPV(viewport, entry, rate, __functionAddress); + } + + /** Array version of: {@link #glShadingRateSampleOrderCustomNV ShadingRateSampleOrderCustomNV} */ + public static void glShadingRateSampleOrderCustomNV(@NativeType("GLenum") int rate, @NativeType("GLuint") int samples, @NativeType("GLint const *") int[] locations) { + long __functionAddress = GL.getICD().glShadingRateSampleOrderCustomNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(rate, samples, locations, __functionAddress); + } + + /** Array version of: {@link #glGetShadingRateSampleLocationivNV GetShadingRateSampleLocationivNV} */ + public static void glGetShadingRateSampleLocationivNV(@NativeType("GLenum") int rate, @NativeType("GLuint") int samples, @NativeType("GLuint") int index, @NativeType("GLint *") int[] location) { + long __functionAddress = GL.getICD().glGetShadingRateSampleLocationivNV; + if (CHECKS) { + check(__functionAddress); + check(location, 3); + } + callPV(rate, samples, index, location, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTexgenReflection.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTexgenReflection.java new file mode 100644 index 00000000..db6691b1 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTexgenReflection.java @@ -0,0 +1,22 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_texgen_reflection extension. + * + *This extension provides two new texture coordinate generation modes that are useful texture-based lighting and environment mapping.
+ */ +public final class NVTexgenReflection { + + /** Accepted by the {@code param} parameter of TexGend, TexGenf, TexGeni when {@code pname} parameter is TEXTURE_GEN_MODE */ + public static final int + GL_NORMAL_MAP_NV = 0x8511, + GL_REFLECTION_MAP_NV = 0x8512; + + private NVTexgenReflection() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTextureBarrier.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTextureBarrier.java new file mode 100644 index 00000000..f2d21413 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTextureBarrier.java @@ -0,0 +1,36 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the NV_texture_barrier extension. + * + *This extension relaxes the restrictions on rendering to a currently bound texture and provides a mechanism to avoid read-after-write hazards.
+ */ +public class NVTextureBarrier { + + static { GL.initialize(); } + + protected NVTextureBarrier() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glTextureBarrierNV + ); + } + + // --- [ glTextureBarrierNV ] --- + + /** Guarantees that writes have completed and caches have been invalidated before subsequent Draws are executed. */ + public static native void glTextureBarrierNV(); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTextureMultisample.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTextureMultisample.java new file mode 100644 index 00000000..7b02a9a4 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTextureMultisample.java @@ -0,0 +1,64 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the NV_texture_multisample extension. + * + *This specification extends NV_gpu_program4 to support per-sample fetching from multisample textures described in + * {@link ARBTextureMultisample ARB_texture_multisample}.
+ * + *Requires {@link GL20 OpenGL 2.0}, {@link ARBTextureMultisample ARB_texture_multisample}.
+ */ +public class NVTextureMultisample { + + /** Accepted by the {@code pname} parameter of GetTexLevelParameter. */ + public static final int + GL_TEXTURE_COVERAGE_SAMPLES_NV = 0x9045, + GL_TEXTURE_COLOR_SAMPLES_NV = 0x9046; + + static { GL.initialize(); } + + protected NVTextureMultisample() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glTexImage2DMultisampleCoverageNV, caps.glTexImage3DMultisampleCoverageNV, caps.glTextureImage2DMultisampleNV, + caps.glTextureImage3DMultisampleNV, caps.glTextureImage2DMultisampleCoverageNV, caps.glTextureImage3DMultisampleCoverageNV + ); + } + + // --- [ glTexImage2DMultisampleCoverageNV ] --- + + public static native void glTexImage2DMultisampleCoverageNV(@NativeType("GLenum") int target, @NativeType("GLsizei") int coverageSamples, @NativeType("GLsizei") int colorSamples, @NativeType("GLint") int internalFormat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLboolean") boolean fixedSampleLocations); + + // --- [ glTexImage3DMultisampleCoverageNV ] --- + + public static native void glTexImage3DMultisampleCoverageNV(@NativeType("GLenum") int target, @NativeType("GLsizei") int coverageSamples, @NativeType("GLsizei") int colorSamples, @NativeType("GLint") int internalFormat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth, @NativeType("GLboolean") boolean fixedSampleLocations); + + // --- [ glTextureImage2DMultisampleNV ] --- + + public static native void glTextureImage2DMultisampleNV(@NativeType("GLuint") int texture, @NativeType("GLenum") int target, @NativeType("GLsizei") int samples, @NativeType("GLint") int internalFormat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLboolean") boolean fixedSampleLocations); + + // --- [ glTextureImage3DMultisampleNV ] --- + + public static native void glTextureImage3DMultisampleNV(@NativeType("GLuint") int texture, @NativeType("GLenum") int target, @NativeType("GLsizei") int samples, @NativeType("GLint") int internalFormat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth, @NativeType("GLboolean") boolean fixedSampleLocations); + + // --- [ glTextureImage2DMultisampleCoverageNV ] --- + + public static native void glTextureImage2DMultisampleCoverageNV(@NativeType("GLuint") int texture, @NativeType("GLenum") int target, @NativeType("GLsizei") int coverageSamples, @NativeType("GLsizei") int colorSamples, @NativeType("GLint") int internalFormat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLboolean") boolean fixedSampleLocations); + + // --- [ glTextureImage3DMultisampleCoverageNV ] --- + + public static native void glTextureImage3DMultisampleCoverageNV(@NativeType("GLuint") int texture, @NativeType("GLenum") int target, @NativeType("GLsizei") int coverageSamples, @NativeType("GLsizei") int colorSamples, @NativeType("GLint") int internalFormat, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth, @NativeType("GLboolean") boolean fixedSampleLocations); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTransformFeedback.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTransformFeedback.java new file mode 100644 index 00000000..fe86f27e --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTransformFeedback.java @@ -0,0 +1,295 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_transform_feedback extension. + * + *This extension provides a new mode to the GL, called transform feedback, which records vertex attributes of the primitives processed by the GL. The + * selected attributes are written into buffer objects, and can be written with each attribute in a separate buffer object or with all attributes + * interleaved into a single buffer object. If a geometry program or shader is active, the primitives recorded are those emitted by the geometry program. + * Otherwise, transform feedback captures primitives whose vertex are transformed by a vertex program or shader, or by fixed-function vertex processing. + * In either case, the primitives captured are those generated prior to clipping. Transform feedback mode is capable of capturing transformed vertex data + * generated by fixed-function vertex processing, outputs from assembly vertex or geometry programs, or varying variables emitted from GLSL vertex or + * geometry shaders.
+ * + *The vertex data recorded in transform feedback mode is stored into buffer objects as an array of vertex attributes. The regular representation and the + * use of buffer objects allows the recorded data to be processed directly by the GL without requiring CPU intervention to copy data. In particular, + * transform feedback data can be used for vertex arrays (via vertex buffer objects), as the source for pixel data (via pixel buffer objects), as program + * constant data (via the NV_parameter_buffer_object or EXT_bindable_uniform extension), or via any other extension that makes use of buffer objects.
+ * + *This extension introduces new query object support to allow transform feedback mode to operate asynchronously. Query objects allow applications to + * determine when transform feedback results are complete, as well as the number of primitives processed and written back to buffer objects while in + * transform feedback mode. This extension also provides a new rasterizer discard enable, which allows applications to use transform feedback to capture + * vertex attributes without rendering anything.
+ * + *Requires {@link GL15 OpenGL 1.5}.
+ */ +public class NVTransformFeedback { + + /** + * Accepted by the {@code target} parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, GetBufferPointerv, + * BindBufferRangeNV, BindBufferOffsetNV and BindBufferBaseNV. + */ + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_NV = 0x8C8E; + + /** Accepted by the {@code param} parameter of GetIntegerIndexedvEXT and GetBooleanIndexedvEXT. */ + public static final int + GL_TRANSFORM_FEEDBACK_BUFFER_START_NV = 0x8C84, + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = 0x8C85, + GL_TRANSFORM_FEEDBACK_RECORD_NV = 0x8C86; + + /** + * Accepted by the {@code param} parameter of GetIntegerIndexedvEXT and GetBooleanIndexedvEXT, and by the {@code pname} parameter of GetBooleanv, + * GetDoublev, GetIntegerv, and GetFloatv. + */ + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 0x8C8F; + + /** Accepted by the {@code bufferMode} parameter of TransformFeedbackAttribsNV and TransformFeedbackVaryingsNV. */ + public static final int + GL_INTERLEAVED_ATTRIBS_NV = 0x8C8C, + GL_SEPARATE_ATTRIBS_NV = 0x8C8D; + + /** Accepted by the {@code target} parameter of BeginQuery, EndQuery, and GetQueryiv. */ + public static final int + GL_PRIMITIVES_GENERATED_NV = 0x8C87, + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 0x8C88; + + /** + * Accepted by the {@code cap} parameter of Enable, Disable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev. + */ + public static final int GL_RASTERIZER_DISCARD_NV = 0x8C89; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV = 0x8C8A, + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = 0x8C8B, + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 0x8C80, + GL_TRANSFORM_FEEDBACK_ATTRIBS_NV = 0x8C7E; + + /** Accepted by the {@code pname} parameter of GetProgramiv. */ + public static final int + GL_ACTIVE_VARYINGS_NV = 0x8C81, + GL_ACTIVE_VARYING_MAX_LENGTH_NV = 0x8C82, + GL_TRANSFORM_FEEDBACK_VARYINGS_NV = 0x8C83; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, GetFloatv, and GetProgramiv. */ + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 0x8C7F; + + /** Accepted by the {@code attribs} parameter of TransformFeedbackAttribsNV. */ + public static final int + GL_BACK_PRIMARY_COLOR_NV = 0x8C77, + GL_BACK_SECONDARY_COLOR_NV = 0x8C78, + GL_TEXTURE_COORD_NV = 0x8C79, + GL_CLIP_DISTANCE_NV = 0x8C7A, + GL_VERTEX_ID_NV = 0x8C7B, + GL_PRIMITIVE_ID_NV = 0x8C7C, + GL_GENERIC_ATTRIB_NV = 0x8C7D, + GL_SECONDARY_COLOR_NV = 0x852D, + GL_LAYER_NV = 0x8DAA; + + static { GL.initialize(); } + + protected NVTransformFeedback() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBeginTransformFeedbackNV, caps.glEndTransformFeedbackNV, caps.glTransformFeedbackAttribsNV, caps.glBindBufferRangeNV, + caps.glBindBufferOffsetNV, caps.glBindBufferBaseNV, caps.glTransformFeedbackVaryingsNV, caps.glActiveVaryingNV, caps.glGetVaryingLocationNV, + caps.glGetActiveVaryingNV, caps.glGetTransformFeedbackVaryingNV, caps.glTransformFeedbackStreamAttribsNV + ); + } + + // --- [ glBeginTransformFeedbackNV ] --- + + public static native void glBeginTransformFeedbackNV(@NativeType("GLenum") int primitiveMode); + + // --- [ glEndTransformFeedbackNV ] --- + + public static native void glEndTransformFeedbackNV(); + + // --- [ glTransformFeedbackAttribsNV ] --- + + public static native void nglTransformFeedbackAttribsNV(int count, long attribs, int bufferMode); + + public static void glTransformFeedbackAttribsNV(@NativeType("GLint const *") IntBuffer attribs, @NativeType("GLenum") int bufferMode) { + nglTransformFeedbackAttribsNV(attribs.remaining(), memAddress(attribs), bufferMode); + } + + // --- [ glBindBufferRangeNV ] --- + + public static native void glBindBufferRangeNV(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLuint") int buffer, @NativeType("GLintptr") long offset, @NativeType("GLsizeiptr") long size); + + // --- [ glBindBufferOffsetNV ] --- + + public static native void glBindBufferOffsetNV(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLuint") int buffer, @NativeType("GLintptr") long offset); + + // --- [ glBindBufferBaseNV ] --- + + public static native void glBindBufferBaseNV(@NativeType("GLenum") int target, @NativeType("GLuint") int index, @NativeType("GLuint") int buffer); + + // --- [ glTransformFeedbackVaryingsNV ] --- + + public static native void nglTransformFeedbackVaryingsNV(int program, int count, long locations, int bufferMode); + + public static void glTransformFeedbackVaryingsNV(@NativeType("GLuint") int program, @NativeType("GLint const *") IntBuffer locations, @NativeType("GLenum") int bufferMode) { + nglTransformFeedbackVaryingsNV(program, locations.remaining(), memAddress(locations), bufferMode); + } + + // --- [ glActiveVaryingNV ] --- + + public static native void nglActiveVaryingNV(int program, long name); + + public static void glActiveVaryingNV(@NativeType("GLuint") int program, @NativeType("GLchar const *") ByteBuffer name) { + if (CHECKS) { + checkNT1(name); + } + nglActiveVaryingNV(program, memAddress(name)); + } + + public static void glActiveVaryingNV(@NativeType("GLuint") int program, @NativeType("GLchar const *") CharSequence name) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nASCII(name, true); + long nameEncoded = stack.getPointerAddress(); + nglActiveVaryingNV(program, nameEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetVaryingLocationNV ] --- + + public static native int nglGetVaryingLocationNV(int program, long name); + + @NativeType("GLint") + public static int glGetVaryingLocationNV(@NativeType("GLuint") int program, @NativeType("GLchar const *") ByteBuffer name) { + if (CHECKS) { + checkNT1(name); + } + return nglGetVaryingLocationNV(program, memAddress(name)); + } + + @NativeType("GLint") + public static int glGetVaryingLocationNV(@NativeType("GLuint") int program, @NativeType("GLchar const *") CharSequence name) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nASCII(name, true); + long nameEncoded = stack.getPointerAddress(); + return nglGetVaryingLocationNV(program, nameEncoded); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGetActiveVaryingNV ] --- + + public static native void nglGetActiveVaryingNV(int program, int index, int bufSize, long length, long size, long type, long name); + + public static void glGetActiveVaryingNV(@NativeType("GLuint") int program, @NativeType("GLuint") int index, @Nullable @NativeType("GLsizei *") IntBuffer length, @NativeType("GLsizei *") IntBuffer size, @NativeType("GLenum *") IntBuffer type, @NativeType("GLchar *") ByteBuffer name) { + if (CHECKS) { + checkSafe(length, 1); + check(size, 1); + check(type, 1); + } + nglGetActiveVaryingNV(program, index, name.remaining(), memAddressSafe(length), memAddress(size), memAddress(type), memAddress(name)); + } + + // --- [ glGetTransformFeedbackVaryingNV ] --- + + public static native void nglGetTransformFeedbackVaryingNV(int program, int index, long location); + + public static void glGetTransformFeedbackVaryingNV(@NativeType("GLuint") int program, @NativeType("GLuint") int index, @NativeType("GLint *") IntBuffer location) { + if (CHECKS) { + check(location, 1); + } + nglGetTransformFeedbackVaryingNV(program, index, memAddress(location)); + } + + @NativeType("void") + public static int glGetTransformFeedbackVaryingNV(@NativeType("GLuint") int program, @NativeType("GLuint") int index) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer location = stack.callocInt(1); + nglGetTransformFeedbackVaryingNV(program, index, memAddress(location)); + return location.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glTransformFeedbackStreamAttribsNV ] --- + + public static native void nglTransformFeedbackStreamAttribsNV(int count, long attribs, int nbuffers, long bufstreams, int bufferMode); + + public static void glTransformFeedbackStreamAttribsNV(@NativeType("GLint const *") IntBuffer attribs, @NativeType("GLint const *") IntBuffer bufstreams, @NativeType("GLenum") int bufferMode) { + nglTransformFeedbackStreamAttribsNV(attribs.remaining(), memAddress(attribs), bufstreams.remaining(), memAddress(bufstreams), bufferMode); + } + + /** Array version of: {@link #glTransformFeedbackAttribsNV TransformFeedbackAttribsNV} */ + public static void glTransformFeedbackAttribsNV(@NativeType("GLint const *") int[] attribs, @NativeType("GLenum") int bufferMode) { + long __functionAddress = GL.getICD().glTransformFeedbackAttribsNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(attribs.length, attribs, bufferMode, __functionAddress); + } + + /** Array version of: {@link #glTransformFeedbackVaryingsNV TransformFeedbackVaryingsNV} */ + public static void glTransformFeedbackVaryingsNV(@NativeType("GLuint") int program, @NativeType("GLint const *") int[] locations, @NativeType("GLenum") int bufferMode) { + long __functionAddress = GL.getICD().glTransformFeedbackVaryingsNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(program, locations.length, locations, bufferMode, __functionAddress); + } + + /** Array version of: {@link #glGetActiveVaryingNV GetActiveVaryingNV} */ + public static void glGetActiveVaryingNV(@NativeType("GLuint") int program, @NativeType("GLuint") int index, @Nullable @NativeType("GLsizei *") int[] length, @NativeType("GLsizei *") int[] size, @NativeType("GLenum *") int[] type, @NativeType("GLchar *") ByteBuffer name) { + long __functionAddress = GL.getICD().glGetActiveVaryingNV; + if (CHECKS) { + check(__functionAddress); + checkSafe(length, 1); + check(size, 1); + check(type, 1); + } + callPPPPV(program, index, name.remaining(), length, size, type, memAddress(name), __functionAddress); + } + + /** Array version of: {@link #glGetTransformFeedbackVaryingNV GetTransformFeedbackVaryingNV} */ + public static void glGetTransformFeedbackVaryingNV(@NativeType("GLuint") int program, @NativeType("GLuint") int index, @NativeType("GLint *") int[] location) { + long __functionAddress = GL.getICD().glGetTransformFeedbackVaryingNV; + if (CHECKS) { + check(__functionAddress); + check(location, 1); + } + callPV(program, index, location, __functionAddress); + } + + /** Array version of: {@link #glTransformFeedbackStreamAttribsNV TransformFeedbackStreamAttribsNV} */ + public static void glTransformFeedbackStreamAttribsNV(@NativeType("GLint const *") int[] attribs, @NativeType("GLint const *") int[] bufstreams, @NativeType("GLenum") int bufferMode) { + long __functionAddress = GL.getICD().glTransformFeedbackStreamAttribsNV; + if (CHECKS) { + check(__functionAddress); + } + callPPV(attribs.length, attribs, bufstreams.length, bufstreams, bufferMode, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTransformFeedback2.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTransformFeedback2.java new file mode 100644 index 00000000..5540b8a8 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVTransformFeedback2.java @@ -0,0 +1,140 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_transform_feedback2 extension. + * + *The NV_transform_feedback and EXT_transform_feedback extensions allow applications to capture primitives to one or more buffer objects when transformed + * by the GL. This extension provides a few additional capabilities to these extensions, making transform feedback mode more useful.
+ * + *First, it provides transform feedback objects encapsulating transform feedback-related state, allowing applications to replace the entire transform + * feedback configuration in a single bind call. Second, it provides the ability to pause and resume transform feedback operations. When transform + * feedback is paused, applications may render without transform feedback or may use transform feedback with different state and a different transform + * feedback object. When transform feedback is resumed, additional primitives are captured and appended to previously captured primitives for the object.
+ * + *Additionally, this extension provides the ability to draw primitives captured in transform feedback mode without querying the captured primitive count.
+ * The command DrawTransformFeedbackNV() is equivalent to {@code glDrawArrays(
Requires {@link GL15 OpenGL 1.5} and {@link NVTransformFeedback NV_transform_feedback} or {@link EXTTransformFeedback EXT_transform_feedback}.
+ */ +public class NVTransformFeedback2 { + + /** Accepted by the {@code target} parameter of BindTransformFeedbackNV. */ + public static final int GL_TRANSFORM_FEEDBACK_NV = 0x8E22; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetDoublev, GetIntegerv, and GetFloatv. */ + public static final int + GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = 0x8E23, + GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = 0x8E24, + GL_TRANSFORM_FEEDBACK_BINDING_NV = 0x8E25; + + static { GL.initialize(); } + + protected NVTransformFeedback2() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBindTransformFeedbackNV, caps.glDeleteTransformFeedbacksNV, caps.glGenTransformFeedbacksNV, caps.glIsTransformFeedbackNV, + caps.glPauseTransformFeedbackNV, caps.glResumeTransformFeedbackNV, caps.glDrawTransformFeedbackNV + ); + } + + // --- [ glBindTransformFeedbackNV ] --- + + public static native void glBindTransformFeedbackNV(@NativeType("GLenum") int target, @NativeType("GLuint") int id); + + // --- [ glDeleteTransformFeedbacksNV ] --- + + public static native void nglDeleteTransformFeedbacksNV(int n, long ids); + + public static void glDeleteTransformFeedbacksNV(@NativeType("GLuint const *") IntBuffer ids) { + nglDeleteTransformFeedbacksNV(ids.remaining(), memAddress(ids)); + } + + public static void glDeleteTransformFeedbacksNV(@NativeType("GLuint const *") int id) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer ids = stack.ints(id); + nglDeleteTransformFeedbacksNV(1, memAddress(ids)); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glGenTransformFeedbacksNV ] --- + + public static native void nglGenTransformFeedbacksNV(int n, long ids); + + public static void glGenTransformFeedbacksNV(@NativeType("GLuint *") IntBuffer ids) { + if (CHECKS) { + check(ids, 1); + } + nglGenTransformFeedbacksNV(ids.remaining(), memAddress(ids)); + } + + @NativeType("void") + public static int glGenTransformFeedbacksNV() { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + IntBuffer ids = stack.callocInt(1); + nglGenTransformFeedbacksNV(1, memAddress(ids)); + return ids.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ glIsTransformFeedbackNV ] --- + + @NativeType("GLboolean") + public static native boolean glIsTransformFeedbackNV(@NativeType("GLuint") int id); + + // --- [ glPauseTransformFeedbackNV ] --- + + public static native void glPauseTransformFeedbackNV(); + + // --- [ glResumeTransformFeedbackNV ] --- + + public static native void glResumeTransformFeedbackNV(); + + // --- [ glDrawTransformFeedbackNV ] --- + + public static native void glDrawTransformFeedbackNV(@NativeType("GLenum") int mode, @NativeType("GLuint") int id); + + /** Array version of: {@link #glDeleteTransformFeedbacksNV DeleteTransformFeedbacksNV} */ + public static void glDeleteTransformFeedbacksNV(@NativeType("GLuint const *") int[] ids) { + long __functionAddress = GL.getICD().glDeleteTransformFeedbacksNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(ids.length, ids, __functionAddress); + } + + /** Array version of: {@link #glGenTransformFeedbacksNV GenTransformFeedbacksNV} */ + public static void glGenTransformFeedbacksNV(@NativeType("GLuint *") int[] ids) { + long __functionAddress = GL.getICD().glGenTransformFeedbacksNV; + if (CHECKS) { + check(__functionAddress); + check(ids, 1); + } + callPV(ids.length, ids, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVUniformBufferUnifiedMemory.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVUniformBufferUnifiedMemory.java new file mode 100644 index 00000000..4be20aa2 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVUniformBufferUnifiedMemory.java @@ -0,0 +1,34 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_uniform_buffer_unified_memory extension. + * + *This extension provides a mechanism to specify uniform buffers + * using GPU addresses.
+ * + *Binding uniform buffers is one of the most frequent and expensive + * operations in many GL applications, due to the cost of chasing + * pointers and binding objects described in the overview of + * NV_shader_buffer_load. The intent of this extension is to enable a + * way for the application to specify uniform buffer state that alleviates + * the overhead of object binds and driver memory management.
+ */ +public final class NVUniformBufferUnifiedMemory { + + /** Accepted by the {@code cap} parameter of DisableClientState, EnableClientState, IsEnabled. */ + public static final int GL_UNIFORM_BUFFER_UNIFIED_NV = 0x936E; + + /** Accepted by the {@code pname} parameter of BufferAddressRangeNV and the {@code value} parameter of GetIntegerui64i_vNV. */ + public static final int GL_UNIFORM_BUFFER_ADDRESS_NV = 0x936F; + + /** Accepted by the {@code target} parameter of GetIntegeri_vNV. */ + public static final int GL_UNIFORM_BUFFER_LENGTH_NV = 0x9370; + + private NVUniformBufferUnifiedMemory() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVVertexArrayRange.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVVertexArrayRange.java new file mode 100644 index 00000000..63e60405 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVVertexArrayRange.java @@ -0,0 +1,59 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_vertex_array_range extension. + * + *The goal of this extension is to permit extremely high vertex processing rates via OpenGL vertex arrays even when the CPU lacks the necessary data + * movement bandwidth to keep up with the rate at which the vertex engine can consume vertices.
+ */ +public class NVVertexArrayRange { + + /** Accepted by the {@code cap} parameter of EnableClientState, DisableClientState, and IsEnabled. */ + public static final int GL_VERTEX_ARRAY_RANGE_NV = 0x851D; + + /** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + GL_VERTEX_ARRAY_RANGE_LENGTH_NV = 0x851E, + GL_VERTEX_ARRAY_RANGE_VALID_NV = 0x851F, + GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 0x8520; + + /** Accepted by the {@code pname} parameter of GetPointerv. */ + public static final int GL_VERTEX_ARRAY_RANGE_POINTER_NV = 0x8521; + + static { GL.initialize(); } + + protected NVVertexArrayRange() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glVertexArrayRangeNV, caps.glFlushVertexArrayRangeNV + ); + } + + // --- [ glVertexArrayRangeNV ] --- + + public static native void nglVertexArrayRangeNV(int length, long pointer); + + public static void glVertexArrayRangeNV(@NativeType("void *") ByteBuffer pointer) { + nglVertexArrayRangeNV(pointer.remaining(), memAddress(pointer)); + } + + // --- [ glFlushVertexArrayRangeNV ] --- + + public static native void glFlushVertexArrayRangeNV(); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVVertexArrayRange2.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVVertexArrayRange2.java new file mode 100644 index 00000000..4c3a2f05 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVVertexArrayRange2.java @@ -0,0 +1,27 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NV_vertex_array_range2 extension. + * + *Enabling and disabling the vertex array range is specified by the original NV_vertex_array_range extension specification to flush the vertex array + * range implicitly. In retrospect, this semantic is extremely misconceived and creates terrible performance problems for any application that wishes to + * mix conventional vertex arrays with vertex arrange range-enabled vertex arrays.
+ * + *This extension provides a new token for enabling/disabling the vertex array range that does NOT perform an implicit vertex array range flush when the + * enable/disable is performed.
+ * + *Requires {@link NVVertexArrayRange NV_vertex_array_range}.
+ */ +public final class NVVertexArrayRange2 { + + /** Accepted by the {@code cap} parameter of EnableClientState, DisableClientState. */ + public static final int GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 0x8533; + + private NVVertexArrayRange2() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVVertexAttribInteger64bit.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVVertexAttribInteger64bit.java new file mode 100644 index 00000000..ccb127a5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVVertexAttribInteger64bit.java @@ -0,0 +1,321 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NV_vertex_attrib_integer_64bit extension. + * + *This extension provides support for specifying vertex attributes with 64-bit integer components, analagous to the 64-bit floating point support added + * in EXT_vertex_attrib_64bit.
+ * + *Additionally, it provides the VertexAttribLFormatNV entry point to specify bindless vertex attribute arrays with 64-bit integer or floating-point + * components in conjunction with the NV_vertex_buffer_unified_memory extension.
+ * + *Requires {@link GL30 OpenGL 3.0}, GLSL 1.30, {@link NVGPUShader5 NV_gpu_shader5} or equivalent functionality and {@link EXTVertexAttrib64bit EXT_vertex_attrib_64bit}.
+ */ +public class NVVertexAttribInteger64bit { + + /** Accepted by the {@code type} parameter of VertexAttribLPointerEXT, VertexArrayVertexAttribLOffsetEXT, and VertexAttribLFormatNV. */ + public static final int + GL_INT64_NV = 0x140E, + GL_UNSIGNED_INT64_NV = 0x140F; + + static { GL.initialize(); } + + protected NVVertexAttribInteger64bit() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetThis extension provides a mechanism to specify vertex attrib and element array locations using GPU addresses.
+ * + *Binding vertex buffers is one of the most frequent and expensive operations in many GL applications, due to the cost of chasing pointers and binding + * objects described in the Overview of {@link NVShaderBufferLoad NV_shader_buffer_load}. The intent of this extension is to enable a way for the application to specify + * vertex attrib state that alleviates the overhead of object binds and driver memory management.
+ */ +public class NVVertexBufferUnifiedMemory { + + /** Accepted by the {@code cap} parameter of DisableClientState, EnableClientState, IsEnabled. */ + public static final int + GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV = 0x8F1E, + GL_ELEMENT_ARRAY_UNIFIED_NV = 0x8F1F; + + /** Accepted by the {@code pname} parameter of BufferAddressRangeNV and the {@code value} parameter of GetIntegerui64i_vNV. */ + public static final int + GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV = 0x8F20, + GL_TEXTURE_COORD_ARRAY_ADDRESS_NV = 0x8F25; + + /** Accepted by the {@code pname} parameter of BufferAddressRangeNV and the {@code value} parameter of GetIntegerui64vNV. */ + public static final int + GL_VERTEX_ARRAY_ADDRESS_NV = 0x8F21, + GL_NORMAL_ARRAY_ADDRESS_NV = 0x8F22, + GL_COLOR_ARRAY_ADDRESS_NV = 0x8F23, + GL_INDEX_ARRAY_ADDRESS_NV = 0x8F24, + GL_EDGE_FLAG_ARRAY_ADDRESS_NV = 0x8F26, + GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV = 0x8F27, + GL_FOG_COORD_ARRAY_ADDRESS_NV = 0x8F28, + GL_ELEMENT_ARRAY_ADDRESS_NV = 0x8F29; + + /** Accepted by the {@code target} parameter of GetIntegeri_vNV. */ + public static final int + GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV = 0x8F2A, + GL_TEXTURE_COORD_ARRAY_LENGTH_NV = 0x8F2F; + + /** Accepted by the {@code value} parameter of GetIntegerv. */ + public static final int + GL_VERTEX_ARRAY_LENGTH_NV = 0x8F2B, + GL_NORMAL_ARRAY_LENGTH_NV = 0x8F2C, + GL_COLOR_ARRAY_LENGTH_NV = 0x8F2D, + GL_INDEX_ARRAY_LENGTH_NV = 0x8F2E, + GL_EDGE_FLAG_ARRAY_LENGTH_NV = 0x8F30, + GL_SECONDARY_COLOR_ARRAY_LENGTH_NV = 0x8F31, + GL_FOG_COORD_ARRAY_LENGTH_NV = 0x8F32, + GL_ELEMENT_ARRAY_LENGTH_NV = 0x8F33; + + static { GL.initialize(); } + + protected NVVertexBufferUnifiedMemory() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBufferAddressRangeNV, caps.glVertexFormatNV, caps.glNormalFormatNV, caps.glColorFormatNV, caps.glIndexFormatNV, caps.glTexCoordFormatNV, + caps.glEdgeFlagFormatNV, caps.glSecondaryColorFormatNV, caps.glFogCoordFormatNV, caps.glVertexAttribFormatNV, caps.glVertexAttribIFormatNV, + caps.glGetIntegerui64i_vNV + ); + } + + // --- [ glBufferAddressRangeNV ] --- + + public static native void glBufferAddressRangeNV(@NativeType("GLenum") int pname, @NativeType("GLuint") int index, @NativeType("GLuint64EXT") long address, @NativeType("GLsizeiptr") long length); + + // --- [ glVertexFormatNV ] --- + + public static native void glVertexFormatNV(@NativeType("GLint") int size, @NativeType("GLenum") int type, @NativeType("GLsizei") int stride); + + // --- [ glNormalFormatNV ] --- + + public static native void glNormalFormatNV(@NativeType("GLenum") int type, @NativeType("GLsizei") int stride); + + // --- [ glColorFormatNV ] --- + + public static native void glColorFormatNV(@NativeType("GLint") int size, @NativeType("GLenum") int type, @NativeType("GLsizei") int stride); + + // --- [ glIndexFormatNV ] --- + + public static native void glIndexFormatNV(@NativeType("GLenum") int type, @NativeType("GLsizei") int stride); + + // --- [ glTexCoordFormatNV ] --- + + public static native void glTexCoordFormatNV(@NativeType("GLint") int size, @NativeType("GLenum") int type, @NativeType("GLsizei") int stride); + + // --- [ glEdgeFlagFormatNV ] --- + + public static native void glEdgeFlagFormatNV(@NativeType("GLsizei") int stride); + + // --- [ glSecondaryColorFormatNV ] --- + + public static native void glSecondaryColorFormatNV(@NativeType("GLint") int size, @NativeType("GLenum") int type, @NativeType("GLsizei") int stride); + + // --- [ glFogCoordFormatNV ] --- + + public static native void glFogCoordFormatNV(@NativeType("GLenum") int type, @NativeType("GLsizei") int stride); + + // --- [ glVertexAttribFormatNV ] --- + + public static native void glVertexAttribFormatNV(@NativeType("GLuint") int index, @NativeType("GLint") int size, @NativeType("GLenum") int type, @NativeType("GLboolean") boolean normalized, @NativeType("GLsizei") int stride); + + // --- [ glVertexAttribIFormatNV ] --- + + public static native void glVertexAttribIFormatNV(@NativeType("GLuint") int index, @NativeType("GLint") int size, @NativeType("GLenum") int type, @NativeType("GLsizei") int stride); + + // --- [ glGetIntegerui64i_vNV ] --- + + public static native void nglGetIntegerui64i_vNV(int value, int index, long result); + + public static void glGetIntegerui64i_vNV(@NativeType("GLenum") int value, @NativeType("GLuint") int index, @NativeType("GLuint64EXT *") LongBuffer result) { + if (CHECKS) { + check(result, 1); + } + nglGetIntegerui64i_vNV(value, index, memAddress(result)); + } + + @NativeType("void") + public static long glGetIntegerui64iNV(@NativeType("GLenum") int value, @NativeType("GLuint") int index) { + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + LongBuffer result = stack.callocLong(1); + nglGetIntegerui64i_vNV(value, index, memAddress(result)); + return result.get(0); + } finally { + stack.setPointer(stackPointer); + } + } + + /** Array version of: {@link #glGetIntegerui64i_vNV GetIntegerui64i_vNV} */ + public static void glGetIntegerui64i_vNV(@NativeType("GLenum") int value, @NativeType("GLuint") int index, @NativeType("GLuint64EXT *") long[] result) { + long __functionAddress = GL.getICD().glGetIntegerui64i_vNV; + if (CHECKS) { + check(__functionAddress); + check(result, 1); + } + callPV(value, index, result, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVViewportSwizzle.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVViewportSwizzle.java new file mode 100644 index 00000000..f21c2de6 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVViewportSwizzle.java @@ -0,0 +1,69 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the NV_viewport_swizzle extension. + * + *This extension provides a new per-viewport swizzle that can modify the position of primitives sent to each viewport. New viewport swizzle state is + * added for each viewport, and a new position vector is computed for each vertex by selecting from and optionally negating any of the four components of + * the original position vector.
+ * + *This new viewport swizzle is useful for a number of algorithms, including single-pass cubemap rendering (broadcasting a primitive to multiple faces and + * reorienting the vertex position for each face) and voxel rasterization. The per-viewport component remapping and negation provided by the swizzle + * allows application code to re-orient three-dimensional geometry with a view along any of the X, Y, or Z axes. If a perspective projection and depth + * buffering is required, 1/W buffering should be used, as described in the single-pass cubemap rendering example in the "Issues" section below.
+ */ +public class NVViewportSwizzle { + + /** Accepted by the {@code swizzlex}, {@code swizzley}, {@code swizzlez}, and {@code swizzlew} parameters of ViewportSwizzleNV. */ + public static final int + GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV = 0x9350, + GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV = 0x9351, + GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV = 0x9352, + GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV = 0x9353, + GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV = 0x9354, + GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV = 0x9355, + GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV = 0x9356, + GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV = 0x9357; + + /** Accepted by the {@code pname} parameter of GetBooleani_v, GetDoublei_v, GetIntegeri_v, GetFloati_v, and GetInteger64i_v. */ + public static final int + GL_VIEWPORT_SWIZZLE_X_NV = 0x9358, + GL_VIEWPORT_SWIZZLE_Y_NV = 0x9359, + GL_VIEWPORT_SWIZZLE_Z_NV = 0x935A, + GL_VIEWPORT_SWIZZLE_W_NV = 0x935B; + + static { GL.initialize(); } + + protected NVViewportSwizzle() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glViewportSwizzleNV + ); + } + + // --- [ glViewportSwizzleNV ] --- + + /** + * Sets the swizzle state for the specified viewport. + * + * @param index the viewport index + * @param swizzlex the x swizzle state. One of:| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV VIEWPORT_SWIZZLE_POSITIVE_X_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV VIEWPORT_SWIZZLE_NEGATIVE_X_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV VIEWPORT_SWIZZLE_POSITIVE_Y_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV VIEWPORT_SWIZZLE_NEGATIVE_Y_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV VIEWPORT_SWIZZLE_POSITIVE_Z_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV VIEWPORT_SWIZZLE_NEGATIVE_Z_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV VIEWPORT_SWIZZLE_POSITIVE_W_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV VIEWPORT_SWIZZLE_NEGATIVE_W_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV VIEWPORT_SWIZZLE_POSITIVE_X_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV VIEWPORT_SWIZZLE_NEGATIVE_X_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV VIEWPORT_SWIZZLE_POSITIVE_Y_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV VIEWPORT_SWIZZLE_NEGATIVE_Y_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV VIEWPORT_SWIZZLE_POSITIVE_Z_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV VIEWPORT_SWIZZLE_NEGATIVE_Z_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV VIEWPORT_SWIZZLE_POSITIVE_W_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV VIEWPORT_SWIZZLE_NEGATIVE_W_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV VIEWPORT_SWIZZLE_POSITIVE_X_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV VIEWPORT_SWIZZLE_NEGATIVE_X_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV VIEWPORT_SWIZZLE_POSITIVE_Y_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV VIEWPORT_SWIZZLE_NEGATIVE_Y_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV VIEWPORT_SWIZZLE_POSITIVE_Z_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV VIEWPORT_SWIZZLE_NEGATIVE_Z_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV VIEWPORT_SWIZZLE_POSITIVE_W_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV VIEWPORT_SWIZZLE_NEGATIVE_W_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV VIEWPORT_SWIZZLE_POSITIVE_X_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV VIEWPORT_SWIZZLE_NEGATIVE_X_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV VIEWPORT_SWIZZLE_POSITIVE_Y_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV VIEWPORT_SWIZZLE_NEGATIVE_Y_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV VIEWPORT_SWIZZLE_POSITIVE_Z_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV VIEWPORT_SWIZZLE_NEGATIVE_Z_NV} |
| {@link #GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV VIEWPORT_SWIZZLE_POSITIVE_W_NV} | {@link #GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV VIEWPORT_SWIZZLE_NEGATIVE_W_NV} |
This extension provides support for conditional rendering based on the + * results of an occlusion query. This mechanism allows an application to + * potentially reduce the latency between the completion of an occlusion + * query and the rendering commands depending on its result. It additionally + * allows the decision of whether to render to be made without application + * intervention.
+ * + *Requires {@link GL15 OpenGL 1.5} or {@link ARBOcclusionQuery ARB_occlusion_query}
+ */ +public class NVXConditionalRender { + + static { GL.initialize(); } + + protected NVXConditionalRender() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glBeginConditionalRenderNVX, caps.glEndConditionalRenderNVX + ); + } + + // --- [ glBeginConditionalRenderNVX ] --- + + public static native void glBeginConditionalRenderNVX(@NativeType("GLuint") int id); + + // --- [ glEndConditionalRenderNVX ] --- + + public static native void glEndConditionalRenderNVX(); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVXGPUMemoryInfo.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVXGPUMemoryInfo.java new file mode 100644 index 00000000..3f0e79b7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVXGPUMemoryInfo.java @@ -0,0 +1,28 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the NVX_gpu_memory_info extension. + * + *GL_NVX_gpu_memory_info provides applications visibility into GPU hardware memory utilization in order to allow the application to effectively manage + * its resource allocations in the scope of the current available GPU memory.
+ * + *Requires {@link GL20 OpenGL 2.0}
+ */ +public final class NVXGPUMemoryInfo { + + /** Accepted by the {@code param} parameter of GetIntegerv. */ + public static final int + GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX = 0x9047, + GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX = 0x9048, + GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX = 0x9049, + GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX = 0x904A, + GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX = 0x904B; + + private NVXGPUMemoryInfo() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVXGpuMulticast2.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVXGpuMulticast2.java new file mode 100644 index 00000000..36eab626 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVXGpuMulticast2.java @@ -0,0 +1,130 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NVX_gpu_multicast2 extension. + * + *This extension provides additional mechanisms that influence multicast rendering which is simultaneous rendering to multiple GPUs.
+ * + *Requires {@link NVGPUMulticast NV_gpu_multicast}, {@code EXT_device_group}, {@code NV_viewport_array}, {@link NVClipSpaceWScaling NV_clip_space_w_scaling} and {@link NVXProgressFence NVX_progress_fence}.
+ */ +public class NVXGpuMulticast2 { + + static { GL.initialize(); } + + protected NVXGpuMulticast2() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glAsyncCopyImageSubDataNVX, caps.glAsyncCopyBufferSubDataNVX, caps.glUploadGpuMaskNVX, caps.glMulticastViewportArrayvNVX, + caps.glMulticastScissorArrayvNVX, caps.glMulticastViewportPositionWScaleNVX + ); + } + + // --- [ glAsyncCopyImageSubDataNVX ] --- + + public static native int nglAsyncCopyImageSubDataNVX(int waitSemaphoreCount, long waitSemaphoreArray, long waitValueArray, int srcGpu, int dstGpuMask, int srcName, int srcTarget, int srcLevel, int srcX, int srcY, int srcZ, int dstName, int dstTarget, int dstLevel, int dstX, int dstY, int dstZ, int srcWidth, int srcHeight, int srcDepth, int signalSemaphoreCount, long signalSemaphoreArray, long signalValueArray); + + @NativeType("GLuint") + public static int glAsyncCopyImageSubDataNVX(@NativeType("GLuint const *") IntBuffer waitSemaphoreArray, @NativeType("GLuint64 const *") LongBuffer waitValueArray, @NativeType("GLuint") int srcGpu, @NativeType("GLbitfield") int dstGpuMask, @NativeType("GLuint") int srcName, @NativeType("GLenum") int srcTarget, @NativeType("GLint") int srcLevel, @NativeType("GLint") int srcX, @NativeType("GLint") int srcY, @NativeType("GLint") int srcZ, @NativeType("GLuint") int dstName, @NativeType("GLenum") int dstTarget, @NativeType("GLint") int dstLevel, @NativeType("GLint") int dstX, @NativeType("GLint") int dstY, @NativeType("GLint") int dstZ, @NativeType("GLsizei") int srcWidth, @NativeType("GLsizei") int srcHeight, @NativeType("GLsizei") int srcDepth, @NativeType("GLuint const *") IntBuffer signalSemaphoreArray, @NativeType("GLuint64 const *") LongBuffer signalValueArray) { + if (CHECKS) { + check(waitValueArray, waitSemaphoreArray.remaining()); + check(signalValueArray, signalSemaphoreArray.remaining()); + } + return nglAsyncCopyImageSubDataNVX(waitSemaphoreArray.remaining(), memAddress(waitSemaphoreArray), memAddress(waitValueArray), srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreArray.remaining(), memAddress(signalSemaphoreArray), memAddress(signalValueArray)); + } + + // --- [ glAsyncCopyBufferSubDataNVX ] --- + + public static native long nglAsyncCopyBufferSubDataNVX(int waitSemaphoreCount, long waitSemaphoreArray, long fenceValueArray, int readGpu, int writeGpuMask, int readBuffer, int writeBuffer, long readOffset, long writeOffset, long size, int signalSemaphoreCount, long signalSemaphoreArray, long signalValueArray); + + @NativeType("GLsync") + public static long glAsyncCopyBufferSubDataNVX(@NativeType("GLuint const *") IntBuffer waitSemaphoreArray, @NativeType("GLuint64 const *") LongBuffer fenceValueArray, @NativeType("GLuint") int readGpu, @NativeType("GLbitfield") int writeGpuMask, @NativeType("GLuint") int readBuffer, @NativeType("GLuint") int writeBuffer, @NativeType("GLintptr") long readOffset, @NativeType("GLintptr") long writeOffset, @NativeType("GLsizeiptr") long size, @NativeType("GLuint const *") IntBuffer signalSemaphoreArray, @NativeType("GLuint64 const *") LongBuffer signalValueArray) { + if (CHECKS) { + check(fenceValueArray, waitSemaphoreArray.remaining()); + check(signalValueArray, signalSemaphoreArray.remaining()); + } + return nglAsyncCopyBufferSubDataNVX(waitSemaphoreArray.remaining(), memAddress(waitSemaphoreArray), memAddress(fenceValueArray), readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreArray.remaining(), memAddress(signalSemaphoreArray), memAddress(signalValueArray)); + } + + // --- [ glUploadGpuMaskNVX ] --- + + public static native void glUploadGpuMaskNVX(@NativeType("GLbitfield") int mask); + + // --- [ glMulticastViewportArrayvNVX ] --- + + public static native void nglMulticastViewportArrayvNVX(int gpu, int first, int count, long v); + + public static void glMulticastViewportArrayvNVX(@NativeType("GLuint") int gpu, @NativeType("GLuint") int first, @NativeType("GLfloat const *") FloatBuffer v) { + nglMulticastViewportArrayvNVX(gpu, first, v.remaining() >> 2, memAddress(v)); + } + + // --- [ glMulticastScissorArrayvNVX ] --- + + public static native void nglMulticastScissorArrayvNVX(int gpu, int first, int count, long v); + + public static void glMulticastScissorArrayvNVX(@NativeType("GLuint") int gpu, @NativeType("GLuint") int first, @NativeType("GLint const *") IntBuffer v) { + nglMulticastScissorArrayvNVX(gpu, first, v.remaining() >> 2, memAddress(v)); + } + + // --- [ glMulticastViewportPositionWScaleNVX ] --- + + public static native void glMulticastViewportPositionWScaleNVX(@NativeType("GLuint") int gpu, @NativeType("GLuint") int index, @NativeType("GLfloat") float xcoeff, @NativeType("GLfloat") float ycoeff); + + /** Array version of: {@link #glAsyncCopyImageSubDataNVX AsyncCopyImageSubDataNVX} */ + @NativeType("GLuint") + public static int glAsyncCopyImageSubDataNVX(@NativeType("GLuint const *") int[] waitSemaphoreArray, @NativeType("GLuint64 const *") long[] waitValueArray, @NativeType("GLuint") int srcGpu, @NativeType("GLbitfield") int dstGpuMask, @NativeType("GLuint") int srcName, @NativeType("GLenum") int srcTarget, @NativeType("GLint") int srcLevel, @NativeType("GLint") int srcX, @NativeType("GLint") int srcY, @NativeType("GLint") int srcZ, @NativeType("GLuint") int dstName, @NativeType("GLenum") int dstTarget, @NativeType("GLint") int dstLevel, @NativeType("GLint") int dstX, @NativeType("GLint") int dstY, @NativeType("GLint") int dstZ, @NativeType("GLsizei") int srcWidth, @NativeType("GLsizei") int srcHeight, @NativeType("GLsizei") int srcDepth, @NativeType("GLuint const *") int[] signalSemaphoreArray, @NativeType("GLuint64 const *") long[] signalValueArray) { + long __functionAddress = GL.getICD().glAsyncCopyImageSubDataNVX; + if (CHECKS) { + check(__functionAddress); + check(waitValueArray, waitSemaphoreArray.length); + check(signalValueArray, signalSemaphoreArray.length); + } + return callPPPPI(waitSemaphoreArray.length, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreArray.length, signalSemaphoreArray, signalValueArray, __functionAddress); + } + + /** Array version of: {@link #glAsyncCopyBufferSubDataNVX AsyncCopyBufferSubDataNVX} */ + @NativeType("GLsync") + public static long glAsyncCopyBufferSubDataNVX(@NativeType("GLuint const *") int[] waitSemaphoreArray, @NativeType("GLuint64 const *") long[] fenceValueArray, @NativeType("GLuint") int readGpu, @NativeType("GLbitfield") int writeGpuMask, @NativeType("GLuint") int readBuffer, @NativeType("GLuint") int writeBuffer, @NativeType("GLintptr") long readOffset, @NativeType("GLintptr") long writeOffset, @NativeType("GLsizeiptr") long size, @NativeType("GLuint const *") int[] signalSemaphoreArray, @NativeType("GLuint64 const *") long[] signalValueArray) { + long __functionAddress = GL.getICD().glAsyncCopyBufferSubDataNVX; + if (CHECKS) { + check(__functionAddress); + check(fenceValueArray, waitSemaphoreArray.length); + check(signalValueArray, signalSemaphoreArray.length); + } + return callPPPPPPPP(waitSemaphoreArray.length, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreArray.length, signalSemaphoreArray, signalValueArray, __functionAddress); + } + + /** Array version of: {@link #glMulticastViewportArrayvNVX MulticastViewportArrayvNVX} */ + public static void glMulticastViewportArrayvNVX(@NativeType("GLuint") int gpu, @NativeType("GLuint") int first, @NativeType("GLfloat const *") float[] v) { + long __functionAddress = GL.getICD().glMulticastViewportArrayvNVX; + if (CHECKS) { + check(__functionAddress); + } + callPV(gpu, first, v.length >> 2, v, __functionAddress); + } + + /** Array version of: {@link #glMulticastScissorArrayvNVX MulticastScissorArrayvNVX} */ + public static void glMulticastScissorArrayvNVX(@NativeType("GLuint") int gpu, @NativeType("GLuint") int first, @NativeType("GLint const *") int[] v) { + long __functionAddress = GL.getICD().glMulticastScissorArrayvNVX; + if (CHECKS) { + check(__functionAddress); + } + callPV(gpu, first, v.length >> 2, v, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVXProgressFence.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVXProgressFence.java new file mode 100644 index 00000000..bd46a8c3 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/NVXProgressFence.java @@ -0,0 +1,114 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the NVX_progress_fence extension. + * + *This extension uses the concept of GL semaphores as defined in {@link EXTSemaphore EXT_semaphore} to better coordinate operations between multiple GPU command + * streams. A semaphore type called "progress fence" is derived from the GL semaphore. The progress fence semaphore is created by + * {@link #glCreateProgressFenceNVX CreateProgressFenceNVX}) returning the name of a newly created semaphore object. Like other semaphores, these are signaled by the GL server. Each + * signal operation is queued in the GPU command stream with an associated fence value that is written to the semaphore at the completion of a signal + * operation.
+ * + *A GL server wait can be added to the command stream using {@link #glWaitSemaphoreui64NVX WaitSemaphoreui64NVX}. This blocks the GPU until the progress fence semaphore reaches or + * exceeds the specified fence value.
+ * + *A GL client wait can be initiated using {@link #glClientWaitSemaphoreui64NVX ClientWaitSemaphoreui64NVX}. This blocks the CPU until the specified fence value is reached.
+ * + *Requires {@code EXT_external_objects} and {@code EXT_external_objects_win32}.
+ */ +public class NVXProgressFence { + + static { GL.initialize(); } + + protected NVXProgressFence() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps) { + return checkFunctions( + caps.glCreateProgressFenceNVX, caps.glSignalSemaphoreui64NVX, caps.glWaitSemaphoreui64NVX, caps.glClientWaitSemaphoreui64NVX + ); + } + + // --- [ glCreateProgressFenceNVX ] --- + + @NativeType("GLuint") + public static native int glCreateProgressFenceNVX(); + + // --- [ glSignalSemaphoreui64NVX ] --- + + public static native void nglSignalSemaphoreui64NVX(int signalGpu, int fenceObjectCount, long semaphoreArray, long fenceValueArray); + + public static void glSignalSemaphoreui64NVX(@NativeType("GLuint") int signalGpu, @NativeType("GLuint const *") IntBuffer semaphoreArray, @NativeType("GLuint64 const *") LongBuffer fenceValueArray) { + if (CHECKS) { + check(fenceValueArray, semaphoreArray.remaining()); + } + nglSignalSemaphoreui64NVX(signalGpu, semaphoreArray.remaining(), memAddress(semaphoreArray), memAddress(fenceValueArray)); + } + + // --- [ glWaitSemaphoreui64NVX ] --- + + public static native void nglWaitSemaphoreui64NVX(int waitGpu, int fenceObjectCount, long semaphoreArray, long fenceValueArray); + + public static void glWaitSemaphoreui64NVX(@NativeType("GLuint") int waitGpu, @NativeType("GLuint const *") IntBuffer semaphoreArray, @NativeType("GLuint64 const *") LongBuffer fenceValueArray) { + if (CHECKS) { + check(fenceValueArray, semaphoreArray.remaining()); + } + nglWaitSemaphoreui64NVX(waitGpu, semaphoreArray.remaining(), memAddress(semaphoreArray), memAddress(fenceValueArray)); + } + + // --- [ glClientWaitSemaphoreui64NVX ] --- + + public static native void nglClientWaitSemaphoreui64NVX(int fenceObjectCount, long semaphoreArray, long fenceValueArray); + + public static void glClientWaitSemaphoreui64NVX(@NativeType("GLuint const *") IntBuffer semaphoreArray, @NativeType("GLuint64 const *") LongBuffer fenceValueArray) { + if (CHECKS) { + check(fenceValueArray, semaphoreArray.remaining()); + } + nglClientWaitSemaphoreui64NVX(semaphoreArray.remaining(), memAddress(semaphoreArray), memAddress(fenceValueArray)); + } + + /** Array version of: {@link #glSignalSemaphoreui64NVX SignalSemaphoreui64NVX} */ + public static void glSignalSemaphoreui64NVX(@NativeType("GLuint") int signalGpu, @NativeType("GLuint const *") int[] semaphoreArray, @NativeType("GLuint64 const *") long[] fenceValueArray) { + long __functionAddress = GL.getICD().glSignalSemaphoreui64NVX; + if (CHECKS) { + check(__functionAddress); + check(fenceValueArray, semaphoreArray.length); + } + callPPV(signalGpu, semaphoreArray.length, semaphoreArray, fenceValueArray, __functionAddress); + } + + /** Array version of: {@link #glWaitSemaphoreui64NVX WaitSemaphoreui64NVX} */ + public static void glWaitSemaphoreui64NVX(@NativeType("GLuint") int waitGpu, @NativeType("GLuint const *") int[] semaphoreArray, @NativeType("GLuint64 const *") long[] fenceValueArray) { + long __functionAddress = GL.getICD().glWaitSemaphoreui64NVX; + if (CHECKS) { + check(__functionAddress); + check(fenceValueArray, semaphoreArray.length); + } + callPPV(waitGpu, semaphoreArray.length, semaphoreArray, fenceValueArray, __functionAddress); + } + + /** Array version of: {@link #glClientWaitSemaphoreui64NVX ClientWaitSemaphoreui64NVX} */ + public static void glClientWaitSemaphoreui64NVX(@NativeType("GLuint const *") int[] semaphoreArray, @NativeType("GLuint64 const *") long[] fenceValueArray) { + long __functionAddress = GL.getICD().glClientWaitSemaphoreui64NVX; + if (CHECKS) { + check(__functionAddress); + check(fenceValueArray, semaphoreArray.length); + } + callPPV(semaphoreArray.length, semaphoreArray, fenceValueArray, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/OVRMultiview.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/OVRMultiview.java new file mode 100644 index 00000000..497893fe --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/OVRMultiview.java @@ -0,0 +1,128 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; + +/** + * Native bindings to the OVR_multiview extension. + * + *The method of stereo rendering supported in OpenGL is currently achieved by rendering to the two eye buffers sequentially. This typically incurs double + * the application and driver overhead, despite the fact that the command streams and render states are almost identical.
+ * + *This extension seeks to address the inefficiency of sequential multiview rendering by adding a means to render to multiple elements of a 2D texture + * array simultaneously. In multiview rendering, draw calls are instanced into each corresponding element of the texture array. The vertex program uses a + * new {@code gl_ViewID_OVR} variable to compute per-view values, typically the vertex position and view-dependent variables like reflection.
+ * + *The formulation of this extension is high level in order to allow implementation freedom. On existing hardware, applications and drivers can realize + * the benefits of a single scene traversal, even if all GPU work is fully duplicated per-view. But future support could enable simultaneous rendering via + * multi-GPU, tile-based architectures could sort geometry into tiles for multiple views in a single pass, and the implementation could even choose to + * interleave at the fragment level for better texture cache utilization and more coherent fragment shader branching.
+ * + *The most obvious use case in this model is to support two simultaneous views: one view for each eye. However, we also anticipate a usage where two + * views are rendered per eye, where one has a wide field of view and the other has a narrow one. The nature of wide field of view planar projection is + * that the sample density can become unacceptably low in the view direction. By rendering two inset eye views per eye, we can get the required sample + * density in the center of projection without wasting samples, memory, and time by oversampling in the periphery.
+ * + *Requires {@link GL30 OpenGL 3.0}.
+ */ +public class OVRMultiview { + + /** Accepted by the {@code pname} parameter of {@link GL30C#glGetFramebufferAttachmentParameteriv GetFramebufferAttachmentParameteriv}. */ + public static final int + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR = 0x9630, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR = 0x9632; + + /** Accepted by the {@code pname} parameter of GetIntegerv. */ + public static final int GL_MAX_VIEWS_OVR = 0x9631; + + /** Returned by {@link GL30C#glCheckFramebufferStatus CheckFramebufferStatus}. */ + public static final int GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR = 0x9633; + + static { GL.initialize(); } + + protected OVRMultiview() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(GLCapabilities caps, java.util.SetThe command
+ * + *
+ * View( uint id );does not exist in the GL, but is used here to describe the multiview functionality in this section. The effect of this hypothetical function is to set + * the value of the shader built-in input {@code gl_ViewID_OVR}.
+ * + *When multiview rendering is enabled, the {@code Clear}, {@code ClearBuffer*}, {@code Draw*}, and {@code Dispatch*} commands have the same effect as:
+ * + *
+ * for( int i = 0; i < numViews; i++ ) {
+ * FramebufferTextureLayer( target, attachment, texture, level, baseViewIndex + i );
+ * View( i );
+ * <drawing-command>
+ * }The result is that every drawing command is broadcast into every active view. The shader uses {@code gl_ViewID_OVR} to compute view dependent outputs.
+ * + *The number of views, as specified by {@code numViews}, must be the same for all framebuffer attachments points where the value of + * {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE} is not {@link GL11#GL_NONE NONE} or the framebuffer is incomplete.
+ * + *If {@code texture} is non-zero and the command does not result in an error, the framebuffer attachment state corresponding to {@code attachment} is + * updated as in the {@link GL30C#glFramebufferTextureLayer FramebufferTextureLayer} command, except that the values of {@link GL30#GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER} and + * {@link #GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR} are is set to {@code baseViewIndex}, and the value of {@link #GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR} + * is set to {@code numViews}.
+ * + *In addition to the corresponding errors for {@link GL30C#glFramebufferTextureLayer FramebufferTextureLayer} when called with the same parameters (other than {@code layer}):
+ * + *An {@link GL11#GL_INVALID_VALUE INVALID_VALUE} error is generated if:
+ * + *An {@link GL11#GL_INVALID_OPERATION INVALID_OPERATION} error is generated if texture is non-zero and is not the name of a two-dimensional array texture.
+ * + * @param target the framebuffer target. One of:| {@link GL30#GL_FRAMEBUFFER FRAMEBUFFER} | {@link GL30#GL_READ_FRAMEBUFFER READ_FRAMEBUFFER} | {@link GL30#GL_DRAW_FRAMEBUFFER DRAW_FRAMEBUFFER} |
| {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
| {@link GL30#GL_COLOR_ATTACHMENT0 COLOR_ATTACHMENT0} | {@link GL30#GL_COLOR_ATTACHMENT1 COLOR_ATTACHMENT1} | {@link GL30#GL_COLOR_ATTACHMENT2 COLOR_ATTACHMENT2} | {@link GL30#GL_COLOR_ATTACHMENT3 COLOR_ATTACHMENT3} |
| {@link GL30#GL_COLOR_ATTACHMENT4 COLOR_ATTACHMENT4} | {@link GL30#GL_COLOR_ATTACHMENT5 COLOR_ATTACHMENT5} | {@link GL30#GL_COLOR_ATTACHMENT6 COLOR_ATTACHMENT6} | {@link GL30#GL_COLOR_ATTACHMENT7 COLOR_ATTACHMENT7} |
| {@link GL30#GL_COLOR_ATTACHMENT8 COLOR_ATTACHMENT8} | {@link GL30#GL_COLOR_ATTACHMENT9 COLOR_ATTACHMENT9} | {@link GL30#GL_COLOR_ATTACHMENT10 COLOR_ATTACHMENT10} | {@link GL30#GL_COLOR_ATTACHMENT11 COLOR_ATTACHMENT11} |
| {@link GL30#GL_COLOR_ATTACHMENT12 COLOR_ATTACHMENT12} | {@link GL30#GL_COLOR_ATTACHMENT13 COLOR_ATTACHMENT13} | {@link GL30#GL_COLOR_ATTACHMENT14 COLOR_ATTACHMENT14} | {@link GL30#GL_COLOR_ATTACHMENT15 COLOR_ATTACHMENT15} |
| {@link GL30#GL_COLOR_ATTACHMENT16 COLOR_ATTACHMENT16} | {@link GL30#GL_COLOR_ATTACHMENT17 COLOR_ATTACHMENT17} | {@link GL30#GL_COLOR_ATTACHMENT18 COLOR_ATTACHMENT18} | {@link GL30#GL_COLOR_ATTACHMENT19 COLOR_ATTACHMENT19} |
| {@link GL30#GL_COLOR_ATTACHMENT20 COLOR_ATTACHMENT20} | {@link GL30#GL_COLOR_ATTACHMENT21 COLOR_ATTACHMENT21} | {@link GL30#GL_COLOR_ATTACHMENT22 COLOR_ATTACHMENT22} | {@link GL30#GL_COLOR_ATTACHMENT23 COLOR_ATTACHMENT23} |
| {@link GL30#GL_COLOR_ATTACHMENT24 COLOR_ATTACHMENT24} | {@link GL30#GL_COLOR_ATTACHMENT25 COLOR_ATTACHMENT25} | {@link GL30#GL_COLOR_ATTACHMENT26 COLOR_ATTACHMENT26} | {@link GL30#GL_COLOR_ATTACHMENT27 COLOR_ATTACHMENT27} |
| {@link GL30#GL_COLOR_ATTACHMENT28 COLOR_ATTACHMENT28} | {@link GL30#GL_COLOR_ATTACHMENT29 COLOR_ATTACHMENT29} | {@link GL30#GL_COLOR_ATTACHMENT30 COLOR_ATTACHMENT30} | {@link GL30#GL_COLOR_ATTACHMENT31 COLOR_ATTACHMENT31} |
| {@link GL30#GL_DEPTH_ATTACHMENT DEPTH_ATTACHMENT} | {@link GL30#GL_STENCIL_ATTACHMENT STENCIL_ATTACHMENT} | {@link GL30#GL_DEPTH_STENCIL_ATTACHMENT DEPTH_STENCIL_ATTACHMENT} |
There currently is no way for applications to efficiently use GPU resources in systems that contain more than one GPU. Vendors have provided methods + * that attempt to split the workload for an application among the available GPU resources. This has proven to be very inefficient because most + * applications were never written with these sorts of optimizations in mind.
+ * + *This extension provides a mechanism for applications to explicitly use the GPU resources on a given system individually. By providing this + * functionality, a driver allows applications to make appropriate decisions regarding where and when to distribute rendering tasks.
+ * + *Requires {@link WGLARBExtensionsString WGL_ARB_extensions_string} and {@link EXTFramebufferObject EXT_framebuffer_object}.
+ */ +public class WGLAMDGPUAssociation { + + /** Accepted by the {@code property} parameter of {@link #wglGetGPUInfoAMD GetGPUInfoAMD}. */ + public static final int + WGL_GPU_VENDOR_AMD = 0x1F00, + WGL_GPU_RENDERER_STRING_AMD = 0x1F01, + WGL_GPU_OPENGL_VERSION_STRING_AMD = 0x1F02, + WGL_GPU_FASTEST_TARGET_GPUS_AMD = 0x21A2, + WGL_GPU_RAM_AMD = 0x21A3, + WGL_GPU_CLOCK_AMD = 0x21A4, + WGL_GPU_NUM_PIPES_AMD = 0x21A5, + WGL_GPU_NUM_SIMD_AMD = 0x21A6, + WGL_GPU_NUM_RB_AMD = 0x21A7, + WGL_GPU_NUM_SPI_AMD = 0x21A8; + + protected WGLAMDGPUAssociation() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglGetGPUIDsAMD, caps.wglGetGPUInfoAMD, caps.wglGetContextGPUIDAMD, caps.wglCreateAssociatedContextAMD, + caps.wglCreateAssociatedContextAttribsAMD, caps.wglDeleteAssociatedContextAMD, caps.wglMakeAssociatedContextCurrentAMD, + caps.wglGetCurrentAssociatedContextAMD + ); + } + + // --- [ wglGetGPUIDsAMD ] --- + + /** + * Unsafe version of: {@link #wglGetGPUIDsAMD GetGPUIDsAMD} + * + * @param maxCount the max number of IDs that can be returned + */ + public static int nwglGetGPUIDsAMD(int maxCount, long ids) { + long __functionAddress = GL.getCapabilitiesWGL().wglGetGPUIDsAMD; + if (CHECKS) { + check(__functionAddress); + } + return callPI(maxCount, ids, __functionAddress); + } + + /** + * Returns the IDs for available GPUs. + * + *If the function succeeds, the return value is the number of total GPUs available. The value 0 is returned if no GPUs are available or if the call has + * failed. The ID 0 is reserved and will not be retuned as a valid GPU ID. If the array {@code ids} is {@code NULL}, the function will only return the total + * number of GPUs. {@code ids} will be tightly packed with no 0 values between valid ids.
+ * + * @param ids the array of returned IDs + */ + @NativeType("UINT") + public static int wglGetGPUIDsAMD(@Nullable @NativeType("UINT *") IntBuffer ids) { + return nwglGetGPUIDsAMD(remainingSafe(ids), memAddressSafe(ids)); + } + + // --- [ wglGetGPUInfoAMD ] --- + + /** + * Unsafe version of: {@link #wglGetGPUInfoAMD GetGPUInfoAMD} + * + * @param size the size of the {@code data} buffer + */ + public static int nwglGetGPUInfoAMD(int id, int property, int dataType, int size, long data) { + long __functionAddress = GL.getCapabilitiesWGL().wglGetGPUInfoAMD; + if (CHECKS) { + check(__functionAddress); + } + return callPI(id, property, dataType, size, data, __functionAddress); + } + + /** + * Each GPU in a system may have different properties, performance characteristics and different supported OpenGL versions. Use this function to determine + * which GPU is best suited for a specific task. + * + *For a string, {@code size} will be the number of characters allocated and will include {@code NULL} termination. For arrays of type GL_UNSIGNED_INT, GL_INT, + * and GL_FLOAT {@code size} will be the array depth. If the function succeeds, the number of values written will be returned. If the number of values + * written is equal to {@code size}, the query should be repeated with a larger {@code data} buffer. Strings should be queried using the GL_UNSIGNED_BYTE + * type, are UTF-8 encoded and will be {@code NULL} terminated. If the function fails, -1 will be returned.
+ * + * @param id a GPU id obtained from calling {@link #wglGetGPUIDsAMD GetGPUIDsAMD} + * @param property the information being queried. One of:| {@link #WGL_GPU_VENDOR_AMD GPU_VENDOR_AMD} | {@link #WGL_GPU_RENDERER_STRING_AMD GPU_RENDERER_STRING_AMD} | {@link #WGL_GPU_OPENGL_VERSION_STRING_AMD GPU_OPENGL_VERSION_STRING_AMD} | {@link #WGL_GPU_FASTEST_TARGET_GPUS_AMD GPU_FASTEST_TARGET_GPUS_AMD} |
| {@link #WGL_GPU_RAM_AMD GPU_RAM_AMD} | {@link #WGL_GPU_CLOCK_AMD GPU_CLOCK_AMD} | {@link #WGL_GPU_NUM_PIPES_AMD GPU_NUM_PIPES_AMD} | {@link #WGL_GPU_NUM_SIMD_AMD GPU_NUM_SIMD_AMD} |
| {@link #WGL_GPU_NUM_RB_AMD GPU_NUM_RB_AMD} | {@link #WGL_GPU_NUM_SPI_AMD GPU_NUM_SPI_AMD} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} |
For a string, {@code size} will be the number of characters allocated and will include {@code NULL} termination. For arrays of type GL_UNSIGNED_INT, GL_INT, + * and GL_FLOAT {@code size} will be the array depth. If the function succeeds, the number of values written will be returned. If the number of values + * written is equal to {@code size}, the query should be repeated with a larger {@code data} buffer. Strings should be queried using the GL_UNSIGNED_BYTE + * type, are UTF-8 encoded and will be {@code NULL} terminated. If the function fails, -1 will be returned.
+ * + * @param id a GPU id obtained from calling {@link #wglGetGPUIDsAMD GetGPUIDsAMD} + * @param property the information being queried. One of:| {@link #WGL_GPU_VENDOR_AMD GPU_VENDOR_AMD} | {@link #WGL_GPU_RENDERER_STRING_AMD GPU_RENDERER_STRING_AMD} | {@link #WGL_GPU_OPENGL_VERSION_STRING_AMD GPU_OPENGL_VERSION_STRING_AMD} | {@link #WGL_GPU_FASTEST_TARGET_GPUS_AMD GPU_FASTEST_TARGET_GPUS_AMD} |
| {@link #WGL_GPU_RAM_AMD GPU_RAM_AMD} | {@link #WGL_GPU_CLOCK_AMD GPU_CLOCK_AMD} | {@link #WGL_GPU_NUM_PIPES_AMD GPU_NUM_PIPES_AMD} | {@link #WGL_GPU_NUM_SIMD_AMD GPU_NUM_SIMD_AMD} |
| {@link #WGL_GPU_NUM_RB_AMD GPU_NUM_RB_AMD} | {@link #WGL_GPU_NUM_SPI_AMD GPU_NUM_SPI_AMD} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} |
For a string, {@code size} will be the number of characters allocated and will include {@code NULL} termination. For arrays of type GL_UNSIGNED_INT, GL_INT, + * and GL_FLOAT {@code size} will be the array depth. If the function succeeds, the number of values written will be returned. If the number of values + * written is equal to {@code size}, the query should be repeated with a larger {@code data} buffer. Strings should be queried using the GL_UNSIGNED_BYTE + * type, are UTF-8 encoded and will be {@code NULL} terminated. If the function fails, -1 will be returned.
+ * + * @param id a GPU id obtained from calling {@link #wglGetGPUIDsAMD GetGPUIDsAMD} + * @param property the information being queried. One of:| {@link #WGL_GPU_VENDOR_AMD GPU_VENDOR_AMD} | {@link #WGL_GPU_RENDERER_STRING_AMD GPU_RENDERER_STRING_AMD} | {@link #WGL_GPU_OPENGL_VERSION_STRING_AMD GPU_OPENGL_VERSION_STRING_AMD} | {@link #WGL_GPU_FASTEST_TARGET_GPUS_AMD GPU_FASTEST_TARGET_GPUS_AMD} |
| {@link #WGL_GPU_RAM_AMD GPU_RAM_AMD} | {@link #WGL_GPU_CLOCK_AMD GPU_CLOCK_AMD} | {@link #WGL_GPU_NUM_PIPES_AMD GPU_NUM_PIPES_AMD} | {@link #WGL_GPU_NUM_SIMD_AMD GPU_NUM_SIMD_AMD} |
| {@link #WGL_GPU_NUM_RB_AMD GPU_NUM_RB_AMD} | {@link #WGL_GPU_NUM_SPI_AMD GPU_NUM_SPI_AMD} |
| {@link GL11#GL_UNSIGNED_INT UNSIGNED_INT} | {@link GL11#GL_INT INT} | {@link GL11#GL_FLOAT FLOAT} | {@link GL11#GL_UNSIGNED_BYTE UNSIGNED_BYTE} |
Unassociated contexts are created by calling {@link WGL#wglCreateContext CreateContext}. Although these contexts are unassociated, their use will still be tied to a single + * GPU in most cases. For this reason it is advantageous to be able to query the GPU an existing unassociated context resides on. If multiple GPUs are + * available, it would be undesirable to use one for rendering to visible surfaces and then chose the same one for off-screen rendering.
+ * + * @param hglrc the context for which the GPU id will be returned + */ + @NativeType("UINT") + public static int wglGetContextGPUIDAMD(@NativeType("HGLRC") long hglrc) { + long __functionAddress = GL.getCapabilitiesWGL().wglGetContextGPUIDAMD; + if (CHECKS) { + check(__functionAddress); + check(hglrc); + } + return callPI(hglrc, __functionAddress); + } + + // --- [ wglCreateAssociatedContextAMD ] --- + + /** + * Creates an associated context. Upon successful creation, no pixel format is tied to an associated context. + * + * @param id a valid GPU id + */ + @NativeType("HGLRC") + public static long wglCreateAssociatedContextAMD(@NativeType("UINT") int id) { + long __functionAddress = GL.getCapabilitiesWGL().wglCreateAssociatedContextAMD; + if (CHECKS) { + check(__functionAddress); + } + return callP(id, __functionAddress); + } + + // --- [ wglCreateAssociatedContextAttribsAMD ] --- + + /** Unsafe version of: {@link #wglCreateAssociatedContextAttribsAMD CreateAssociatedContextAttribsAMD} */ + public static long nwglCreateAssociatedContextAttribsAMD(int id, long shareContext, long attribList) { + long __functionAddress = GL.getCapabilitiesWGL().wglCreateAssociatedContextAttribsAMD; + if (CHECKS) { + check(__functionAddress); + } + return callPPP(id, shareContext, attribList, __functionAddress); + } + + /** + * Create an associated context with a specific GL version. + * + *All capabilities and limitations of {@link WGLARBCreateContext#wglCreateContextAttribsARB CreateContextAttribsARB} apply to {@code CreateAssociatedContextAttribsAMD}.
+ * + * @param id a valid GPU id + * @param shareContext must either be {@code NULL} or that of an associated context created with the same GPU ID as {@code id} + * @param attribList a 0-terminated list of attributes for the context + */ + @NativeType("HGLRC") + public static long wglCreateAssociatedContextAttribsAMD(@NativeType("UINT") int id, @NativeType("HGLRC") long shareContext, @Nullable @NativeType("int const *") IntBuffer attribList) { + if (CHECKS) { + checkNTSafe(attribList); + } + return nwglCreateAssociatedContextAttribsAMD(id, shareContext, memAddressSafe(attribList)); + } + + // --- [ wglDeleteAssociatedContextAMD ] --- + + /** + * Deletes an associated context. An associated context cannot be deleted by calling {@link WGL#wglDeleteContext DeleteContext}. + * + * @param hglrc a valid associated context created by calling {@link #wglCreateAssociatedContextAMD CreateAssociatedContextAMD} + */ + @NativeType("BOOL") + public static boolean wglDeleteAssociatedContextAMD(@NativeType("HGLRC") long hglrc) { + long __functionAddress = GL.getCapabilitiesWGL().wglDeleteAssociatedContextAMD; + if (CHECKS) { + check(__functionAddress); + check(hglrc); + } + return callPI(hglrc, __functionAddress) != 0; + } + + // --- [ wglMakeAssociatedContextCurrentAMD ] --- + + /** + * Makes an associated context current in the current thread. + * + * @param hglrc a context handle created by calling {@link #wglCreateAssociatedContextAMD CreateAssociatedContextAMD} + */ + @NativeType("BOOL") + public static boolean wglMakeAssociatedContextCurrentAMD(@NativeType("HGLRC") long hglrc) { + long __functionAddress = GL.getCapabilitiesWGL().wglMakeAssociatedContextCurrentAMD; + if (CHECKS) { + check(__functionAddress); + check(hglrc); + } + return callPI(hglrc, __functionAddress) != 0; + } + + // --- [ wglGetCurrentAssociatedContextAMD ] --- + + /** Returns the current associated context in the current thread. */ + @NativeType("HGLRC") + public static long wglGetCurrentAssociatedContextAMD() { + long __functionAddress = GL.getCapabilitiesWGL().wglGetCurrentAssociatedContextAMD; + if (CHECKS) { + check(__functionAddress); + } + return callP(__functionAddress); + } + + // --- [ wglBlitContextFramebufferAMD ] --- + + /** + * Blits data from one context to another. This facilitates high performance data communication between multiple contexts. + * + * @param dstCtx the context handle for the write context + * @param srcX0 the source x0 coordinate + * @param srcY0 the source Y0 coordinate + * @param srcX1 the source X1 coordinate + * @param srcY1 the source Y1 coordinate + * @param dstX0 the destination X0 coordinate + * @param dstY0 the destination Y0 coordinate + * @param dstX1 the destination X1 coordinate + * @param dstY1 the destination Y1 coordinate + * @param mask the bitwise OR of a number of values indicating which buffers are to be copied. One or more of:| {@link GL11#GL_COLOR_BUFFER_BIT COLOR_BUFFER_BIT} | {@link GL11#GL_DEPTH_BUFFER_BIT DEPTH_BUFFER_BIT} | {@link GL11#GL_STENCIL_BUFFER_BIT STENCIL_BUFFER_BIT} |
| {@link GL11#GL_LINEAR LINEAR} | {@link GL11#GL_NEAREST NEAREST} |
The buffer region extension is a mechanism that allows an area of an OpenGL window to be saved in off-screen memory for quick restores. The off-screen + * memory can either be frame buffer memory or system memory, although frame buffer memory might offer optimal performance.
+ * + *A buffer region can be created for the front color, back color, depth, and/or stencil buffer. Multiple buffer regions for the same buffer type can + * exist.
+ */ +public class WGLARBBufferRegion { + + /** Accepted by the {@code type} parameter of {@link #wglCreateBufferRegionARB CreateBufferRegionARB}. */ + public static final int + WGL_FRONT_COLOR_BUFFER_BIT_ARB = 0x1, + WGL_BACK_COLOR_BUFFER_BIT_ARB = 0x2, + WGL_DEPTH_BUFFER_BIT_ARB = 0x4, + WGL_STENCIL_BUFFER_BIT_ARB = 0x8; + + protected WGLARBBufferRegion() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglCreateBufferRegionARB, caps.wglDeleteBufferRegionARB, caps.wglSaveBufferRegionARB, caps.wglRestoreBufferRegionARB + ); + } + + // --- [ wglCreateBufferRegionARB ] --- + + /** + * Creates a buffer region and returns a handle associated with it. + * + * @param hdc the device context for the device on which the buffer region is created + * @param layerPlane the layer plane. Positive values identify overlay planes, negative values identify underlay planes. A value of 0 identifies the main plane. + * @param type a bitwise OR of any of the following values indicating which buffers can be saved or restored. Multiple bits can be set and may result in better + * performance if multiple buffers are saved or restored. One of:| {@link #WGL_FRONT_COLOR_BUFFER_BIT_ARB FRONT_COLOR_BUFFER_BIT_ARB} | {@link #WGL_BACK_COLOR_BUFFER_BIT_ARB BACK_COLOR_BUFFER_BIT_ARB} | {@link #WGL_DEPTH_BUFFER_BIT_ARB DEPTH_BUFFER_BIT_ARB} |
| {@link #WGL_STENCIL_BUFFER_BIT_ARB STENCIL_BUFFER_BIT_ARB} |
Data outside the window for the specified rectangle is undefined. The OpenGL coordinate system is used for specifying the rectangle ({@code x} and + * {@code y} specify the lower-left corner of the rectangle).
+ * + *If an RC is current to the calling thread, a flush will occur before the save operation.
+ * + *The saved buffer region area can be freed by calling {@code wglSaveBufferRegionARB} with {@code width} or {@code height} set to a value of 0.
+ * + * @param region a handle to a buffer region previously created with {@link #wglCreateBufferRegionARB CreateBufferRegionARB}. + * @param x the window x-coordinate for the source rectangle + * @param y the window y-coordinate for the source rectangle + * @param width the source rectangle width + * @param height the source rectangle height + */ + @NativeType("BOOL") + public static boolean wglSaveBufferRegionARB(@NativeType("HANDLE") long region, int x, int y, int width, int height) { + long __functionAddress = GL.getCapabilitiesWGL().wglSaveBufferRegionARB; + if (CHECKS) { + check(__functionAddress); + check(region); + } + return callPI(region, x, y, width, height, __functionAddress) != 0; + } + + // --- [ wglRestoreBufferRegionARB ] --- + + /** + * Restores a previously saved buffer region. + * + * @param region a handle to a buffer region previously created with {@link #wglCreateBufferRegionARB CreateBufferRegionARB}. + * @param x the window x-coordinate for the destination rectangle + * @param y the window y-coordinate for the destination rectangle + * @param width the destination rectangle width + * @param height the destination rectangle height + * @param xSrc the buffer region x-coordinate for the source of the data + * @param ySrc the buffer region y-coordinate for the source of the data + */ + @NativeType("BOOL") + public static boolean wglRestoreBufferRegionARB(@NativeType("HANDLE") long region, int x, int y, int width, int height, int xSrc, int ySrc) { + long __functionAddress = GL.getCapabilitiesWGL().wglRestoreBufferRegionARB; + if (CHECKS) { + check(__functionAddress); + check(region); + } + return callPI(region, x, y, width, height, xSrc, ySrc, __functionAddress) != 0; + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBContextFlushControl.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBContextFlushControl.java new file mode 100644 index 00000000..95b25ff0 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBContextFlushControl.java @@ -0,0 +1,29 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_ARB_context_flush_control extension. + * + *The WGL version of {@link KHRContextFlushControl}. This extension adds new context creation parameters the allow an application to specify the behavior + * that is desired when a context is made non-current, and specifically to opt out of the implicit flush behavior.
+ */ +public final class WGLARBContextFlushControl { + + /** Accepted as an attribute name in the {@code *attrib_list} argument to {@link WGLARBCreateContext#wglCreateContextAttribsARB CreateContextAttribsARB}. */ + public static final int WGL_CONTEXT_RELEASE_BEHAVIOR_ARB = 0x2097; + + /** + * Accepted as an attribute value for {@link #WGL_CONTEXT_RELEASE_BEHAVIOR_ARB CONTEXT_RELEASE_BEHAVIOR_ARB} in the {@code *attrib_list} argument to + * {@link WGLARBCreateContext#wglCreateContextAttribsARB CreateContextAttribsARB}. + */ + public static final int + WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB = 0x0, + WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB = 0x2098; + + private WGLARBContextFlushControl() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBCreateContext.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBCreateContext.java new file mode 100644 index 00000000..fcf41111 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBCreateContext.java @@ -0,0 +1,96 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the WGL_ARB_create_context extension. + * + *With the advent of new versions of OpenGL which deprecate features and/or break backward compatibility with older versions, there is a need and desire + * to indicate at context creation which interface will be used. This extension add a new context creation routine with attributes specifying the GL + * version and context properties requested for the context.
+ * + *Requires {@link WGLARBExtensionsString WGL_ARB_extensions_string}.
+ */ +public class WGLARBCreateContext { + + /** Accepted as an attribute name in {@code attribList}. */ + public static final int + WGL_CONTEXT_MAJOR_VERSION_ARB = 0x2091, + WGL_CONTEXT_MINOR_VERSION_ARB = 0x2092, + WGL_CONTEXT_LAYER_PLANE_ARB = 0x2093, + WGL_CONTEXT_FLAGS_ARB = 0x2094; + + /** Accepted as bits in the attribute value for {@link #WGL_CONTEXT_FLAGS_ARB CONTEXT_FLAGS_ARB} in {@code attribList}. */ + public static final int + WGL_CONTEXT_DEBUG_BIT_ARB = 0x1, + WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = 0x2; + + /** New errors returned by {@link org.lwjgl.system.windows.WinBase#GetLastError}. */ + public static final int ERROR_INVALID_VERSION_ARB = 0x2095; + + protected WGLARBCreateContext() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglCreateContextAttribsARB + ); + } + + // --- [ wglCreateContextAttribsARB ] --- + + /** Unsafe version of: {@link #wglCreateContextAttribsARB CreateContextAttribsARB} */ + public static long nwglCreateContextAttribsARB(long hdc, long shareContext, long attribList) { + long __functionAddress = GL.getCapabilitiesWGL().wglCreateContextAttribsARB; + if (CHECKS) { + check(__functionAddress); + check(hdc); + } + return callPPPP(hdc, shareContext, attribList, __functionAddress); + } + + /** + * Creates an OpenGL context. + * + *If {@code shareContext} is not {@code NULL}, then all shareable data (excluding OpenGL texture objects named 0) will be shared by {@code shareContext}, all + * other contexts {@code shareContext} already shares with, and the newly created context. An arbitrary number of contexts can share data in this fashion.
+ * + * @param attribList a list of attributes for the context. The list consists of a sequence of <name, value> pairs terminated by the value 0. If an attribute is not + * specified in {@code attribList}, then the default value is used instead. If an attribute is specified more than once, then the last value specified + * is used. + */ + @NativeType("HGLRC") + public static long wglCreateContextAttribsARB(@NativeType("HDC") long hdc, @NativeType("HGLRC") long shareContext, @Nullable @NativeType("int const *") IntBuffer attribList) { + if (CHECKS) { + checkNTSafe(attribList); + } + return nwglCreateContextAttribsARB(hdc, shareContext, memAddressSafe(attribList)); + } + + /** Array version of: {@link #wglCreateContextAttribsARB CreateContextAttribsARB} */ + @NativeType("HGLRC") + public static long wglCreateContextAttribsARB(@NativeType("HDC") long hdc, @NativeType("HGLRC") long shareContext, @Nullable @NativeType("int const *") int[] attribList) { + long __functionAddress = GL.getCapabilitiesWGL().wglCreateContextAttribsARB; + if (CHECKS) { + check(__functionAddress); + check(hdc); + checkNTSafe(attribList); + } + return callPPPP(hdc, shareContext, attribList, __functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBCreateContextNoError.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBCreateContextNoError.java new file mode 100644 index 00000000..1f453d17 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBCreateContextNoError.java @@ -0,0 +1,23 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_ARB_create_context_no_error extension. + * + *This extension allows the creation of an OpenGL or OpenGL ES context that doesn't generate errors if the context supports a no error mode. The + * implications of this feature are discussed in the {@link KHRNoError KHR_no_error} extension.
+ * + *Requires {@link WGLARBCreateContext WGL_ARB_create_context}.
+ */ +public final class WGLARBCreateContextNoError { + + /** Accepted as an attribute name in the {@code *attrib_list} argument to {@link WGLARBCreateContext#wglCreateContextAttribsARB CreateContextAttribsARB}. */ + public static final int WGL_CONTEXT_OPENGL_NO_ERROR_ARB = 0x31B3; + + private WGLARBCreateContextNoError() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBCreateContextProfile.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBCreateContextProfile.java new file mode 100644 index 00000000..8385886f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBCreateContextProfile.java @@ -0,0 +1,30 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_ARB_create_context_profile extension. + * + *Adds an attribute to {@link WGLARBCreateContext}, specifying the GL profile requested for a context of OpenGL 3.2 or later.
+ * + *Requires {@link WGLARBExtensionsString WGL_ARB_extensions_string} and {@link GL32 OpenGL 3.2}.
+ */ +public final class WGLARBCreateContextProfile { + + /** Accepted as an attribute name in {@code attribList}. */ + public static final int WGL_CONTEXT_PROFILE_MASK_ARB = 0x9126; + + /** Accepted as bits in the attribute value for {@link #WGL_CONTEXT_PROFILE_MASK_ARB CONTEXT_PROFILE_MASK_ARB} in {@code attribList}. */ + public static final int + WGL_CONTEXT_CORE_PROFILE_BIT_ARB = 0x1, + WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = 0x2; + + /** New errors returned by {@link org.lwjgl.system.windows.WinBase#GetLastError}. */ + public static final int ERROR_INVALID_PROFILE_ARB = 0x2096; + + private WGLARBCreateContextProfile() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBCreateContextRobustness.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBCreateContextRobustness.java new file mode 100644 index 00000000..31ca8252 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBCreateContextRobustness.java @@ -0,0 +1,36 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_ARB_create_context_robustness extension. + * + *This extension allows creating an OpenGL context supporting robust buffer access behavior and a specified graphics reset notification behavior.
+ * + *Requires {@link WGLARBExtensionsString WGL_ARB_extensions_string}, {@link WGLARBCreateContext WGL_ARB_create_context} and {@link ARBRobustness ARB_robustness}.
+ */ +public final class WGLARBCreateContextRobustness { + + /** + * Accepted as a bit in the attribute value for {@link WGLARBCreateContext#WGL_CONTEXT_FLAGS_ARB CONTEXT_FLAGS_ARB} in the {@code attrib_list} argument to + * {@link WGLARBCreateContext#wglCreateContextAttribsARB CreateContextAttribsARB}. + */ + public static final int WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB = 0x4; + + /** Accepted as an attribute name in the {@code attrib_list} argument to {@link WGLARBCreateContext#wglCreateContextAttribsARB CreateContextAttribsARB}. */ + public static final int WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = 0x8256; + + /** + * Accepted as an attribute value for {@link #WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB} in the {@code attrib_list} argument to + * {@link WGLARBCreateContext#wglCreateContextAttribsARB CreateContextAttribsARB}. + */ + public static final int + WGL_NO_RESET_NOTIFICATION_ARB = 0x8261, + WGL_LOSE_CONTEXT_ON_RESET_ARB = 0x8252; + + private WGLARBCreateContextRobustness() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBExtensionsString.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBExtensionsString.java new file mode 100644 index 00000000..42ffbfb8 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBExtensionsString.java @@ -0,0 +1,60 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the WGL_ARB_extensions_string extension. + * + *This extension provides a way for applications to determine which WGL extensions are supported by a device. This is the foundation upon which other WGL + * extensions are built.
+ */ +public class WGLARBExtensionsString { + + protected WGLARBExtensionsString() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglGetExtensionsStringARB + ); + } + + // --- [ wglGetExtensionsStringARB ] --- + + /** Unsafe version of: {@link #wglGetExtensionsStringARB GetExtensionsStringARB} */ + public static long nwglGetExtensionsStringARB(long hdc) { + long __functionAddress = GL.getCapabilitiesWGL().wglGetExtensionsStringARB; + if (CHECKS) { + check(__functionAddress); + check(hdc); + } + return callPP(hdc, __functionAddress); + } + + /** + * Returns a list of supported extensions to WGL. Although the contents of the string is implementation specific, the string will be {@code NULL} terminated and + * will contain a space-separated list of extension names. (The extension names themselves do not contain spaces.) If there are no extensions then the + * empty string is returned. + * + * @param hdc the device context to query extensions for + */ + @Nullable + @NativeType("char const *") + public static String wglGetExtensionsStringARB(@NativeType("HDC") long hdc) { + long __result = nwglGetExtensionsStringARB(hdc); + return memASCIISafe(__result); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBFramebufferSRGB.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBFramebufferSRGB.java new file mode 100644 index 00000000..4f60b44f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBFramebufferSRGB.java @@ -0,0 +1,25 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_ARB_framebuffer_sRGB extension. + * + *WGL functionality for {@link ARBFramebufferSRGB ARB_framebuffer_sRGB}.
+ * + *Requires {@link WGLEXTExtensionsString WGL_EXT_extensions_string}, {@link WGLARBPixelFormat WGL_ARB_pixel_format} and {@link ARBFramebufferObject ARB_framebuffer_object}.
+ */ +public final class WGLARBFramebufferSRGB { + + /** + * Accepted by the {@code attributes} parameter of {@link WGLARBPixelFormat#wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB} and the {@code attribIList} of + * {@link WGLARBPixelFormat#wglChoosePixelFormatARB ChoosePixelFormatARB}. + */ + public static final int WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB = 0x20A9; + + private WGLARBFramebufferSRGB() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBMakeCurrentRead.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBMakeCurrentRead.java new file mode 100644 index 00000000..decc401f --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBMakeCurrentRead.java @@ -0,0 +1,91 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** + * Native bindings to the WGL_ARB_make_current_read extension. + * + *The association of a separate "read" and "draw" DC with the current context allows for preprocessing of image data in an "off screen" DC which is then + * read into a visible DC for final display.
+ * + *Requires {@link WGLARBExtensionsString WGL_ARB_extensions_string}.
+ */ +public class WGLARBMakeCurrentRead { + + /** New errors returned by {@link org.lwjgl.system.windows.WinBase#GetLastError}. */ + public static final int + ERROR_INVALID_PIXEL_TYPE_ARB = 0x2043, + ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = 0x2054; + + protected WGLARBMakeCurrentRead() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglMakeContextCurrentARB, caps.wglGetCurrentReadDCARB + ); + } + + // --- [ wglMakeContextCurrentARB ] --- + + /** + * Associates the context {@code hglrc} with the device {@code drawDC} for draws and the device {@code readDC} for reads. All subsequent OpenGL calls made + * by the calling thread are drawn on the device identified by {@code drawDC} and read on the device identified by {@code readDC}. + * + *The {@code drawDC} and {@code readDC} parameters must refer to drawing surfaces supported by OpenGL. These parameters need not be the same {@code hdc} + * that was passed to {@link WGL#wglCreateContext CreateContext} when {@code hglrc} was created. {@code drawDC} must have the same pixel format and be created on the same + * physical device as the {@code hdc} that was passed into wglCreateContext. {@code readDC} must be created on the same device as the {@code hdc} that was + * passed to wglCreateContext and it must support the same pixel type as the pixel format of the {@code hdc} that was passed to wglCreateContext.
+ * + *If {@code wglMakeContextCurrentARB} is used to associate a different device for reads than for draws, the "read" device will be used for the following + * OpenGL operations:
+ * + *These frame buffer values are taken from the surface associated with the device context specified by {@code readDC}.
+ * + * @param drawDC the "draw" device context + * @param readDC the "read" device context + * @param hglrc the OpenGL context + */ + @NativeType("BOOL") + public static boolean wglMakeContextCurrentARB(@NativeType("HDC") long drawDC, @NativeType("HDC") long readDC, @NativeType("HGLRC") long hglrc) { + long __functionAddress = GL.getCapabilitiesWGL().wglMakeContextCurrentARB; + if (CHECKS) { + check(__functionAddress); + check(drawDC); + check(readDC); + check(hglrc); + } + return callPPPI(drawDC, readDC, hglrc, __functionAddress) != 0; + } + + // --- [ wglGetCurrentReadDCARB ] --- + + /** Returns the "read" device context for the current OpenGL context. */ + @NativeType("HDC") + public static long wglGetCurrentReadDCARB() { + long __functionAddress = GL.getCapabilitiesWGL().wglGetCurrentReadDCARB; + if (CHECKS) { + check(__functionAddress); + } + return callP(__functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBMultisample.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBMultisample.java new file mode 100644 index 00000000..ffa0fc52 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBMultisample.java @@ -0,0 +1,28 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_ARB_multisample extension. + * + *See {@link ARBMultisample} for details.
+ * + *Requires {@link WGLEXTExtensionsString WGL_EXT_extensions_string} and {@link WGLARBPixelFormat WGL_ARB_pixel_format}.
+ */ +public final class WGLARBMultisample { + + /** + * Accepted by the {@code attributes} parameter of {@link WGLARBPixelFormat#wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB}, + * {@link WGLARBPixelFormat#wglGetPixelFormatAttribfvARB GetPixelFormatAttribfvARB}, and the {@code attribIList} and {@code attribFList} of + * {@link WGLARBPixelFormat#wglChoosePixelFormatARB ChoosePixelFormatARB}. + */ + public static final int + WGL_SAMPLE_BUFFERS_ARB = 0x2041, + WGL_SAMPLES_ARB = 0x2042; + + private WGLARBMultisample() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBPbuffer.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBPbuffer.java new file mode 100644 index 00000000..76a40b61 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBPbuffer.java @@ -0,0 +1,212 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the WGL_ARB_pbuffer extension. + * + *This extension defines pixel buffers (pbuffer for short). Pbuffers are additional non-visible rendering buffers for an OpenGL renderer. Pbuffers are + * equivalent to a window that has the same pixel format descriptor with the following exceptions:
+ * + *The intent of the pbuffer semantics is to enable implementations to allocate pbuffers in non-visible frame buffer memory. These pbuffers are intended to + * be "static" resources in that a program will typically allocate them only once rather than as a part of its rendering loop. (Pbuffers should be + * deallocated when the program is no longer using them -- for example, if the program is iconified.)
+ * + *The frame buffer resources that are associated with a pbuffer are also static and are deallocated when the pbuffer is destroyed or possibly when a + * display mode change occurs.
+ * + *Requires {@link WGLARBExtensionsString WGL_ARB_extensions_string} and {@link WGLARBPixelFormat WGL_ARB_pixel_format}.
+ */ +public class WGLARBPbuffer { + + /** + * Accepted by the {@code attribIList} parameter of {@link WGLARBPixelFormat#wglChoosePixelFormatARB ChoosePixelFormatARB} and the {@code attributes} parameter of + * {@link WGLARBPixelFormat#wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB}. + */ + public static final int WGL_DRAW_TO_PBUFFER_ARB = 0x202D; + + /** Accepted by the {@code attributes} parameter of {@link WGLARBPixelFormat#wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB}. */ + public static final int + WGL_MAX_PBUFFER_PIXELS_ARB = 0x202E, + WGL_MAX_PBUFFER_WIDTH_ARB = 0x202F, + WGL_MAX_PBUFFER_HEIGHT_ARB = 0x2030; + + /** Accepted by the {@code attribList} parameter of {@link #wglCreatePbufferARB CreatePbufferARB}. */ + public static final int WGL_PBUFFER_LARGEST_ARB = 0x2033; + + /** Accepted by the {@code attribute} parameter of {@link #wglQueryPbufferARB QueryPbufferARB}. */ + public static final int + WGL_PBUFFER_WIDTH_ARB = 0x2034, + WGL_PBUFFER_HEIGHT_ARB = 0x2035, + WGL_PBUFFER_LOST_ARB = 0x2036; + + protected WGLARBPbuffer() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglCreatePbufferARB, caps.wglGetPbufferDCARB, caps.wglReleasePbufferDCARB, caps.wglDestroyPbufferARB, caps.wglQueryPbufferARB + ); + } + + // --- [ wglCreatePbufferARB ] --- + + /** Unsafe version of: {@link #wglCreatePbufferARB CreatePbufferARB} */ + public static long nwglCreatePbufferARB(long hdc, int pixelFormat, int width, int height, long attribList) { + long __functionAddress = GL.getCapabilitiesWGL().wglCreatePbufferARB; + if (CHECKS) { + check(__functionAddress); + check(hdc); + } + return callPPP(hdc, pixelFormat, width, height, attribList, __functionAddress); + } + + /** + * Creates a pixel buffer (pbuffer) and returns a handle to it. + * + *Support for pbuffers may be restricted to specific pixel formats. Use {@link WGLARBPixelFormat#wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB} to query the {@link #WGL_DRAW_TO_PBUFFER_ARB DRAW_TO_PBUFFER_ARB} + * attribute to determine which pixel formats support the creation of pbuffers.
+ * + * @param hdc a device context for the device on which the pbuffer is created + * @param pixelFormat a non-generic pixel format descriptor index + * @param width the pixel width of the rectangular pbuffer + * @param height the pixel height of the rectangular pbuffer + * @param attribList a 0-terminated list of attributes {type, value} pairs containing integer attribute values + */ + @NativeType("HPBUFFERARB") + public static long wglCreatePbufferARB(@NativeType("HDC") long hdc, int pixelFormat, int width, int height, @Nullable @NativeType("int const *") IntBuffer attribList) { + if (CHECKS) { + checkNTSafe(attribList); + } + return nwglCreatePbufferARB(hdc, pixelFormat, width, height, memAddressSafe(attribList)); + } + + // --- [ wglGetPbufferDCARB ] --- + + /** + * Creates a device context for the pbuffer. + * + * @param pbuffer a pbuffer handle returned from a previous call to {@link #wglCreatePbufferARB CreatePbufferARB} + */ + @NativeType("HDC") + public static long wglGetPbufferDCARB(@NativeType("HPBUFFERARB") long pbuffer) { + long __functionAddress = GL.getCapabilitiesWGL().wglGetPbufferDCARB; + if (CHECKS) { + check(__functionAddress); + check(pbuffer); + } + return callPP(pbuffer, __functionAddress); + } + + // --- [ wglReleasePbufferDCARB ] --- + + /** + * Releases a device context obtained from a previous call to {@link #wglGetPbufferDCARB GetPbufferDCARB}. + * + * @param pbuffer a pbuffer handle + * @param hdc a device context handle + */ + public static int wglReleasePbufferDCARB(@NativeType("HPBUFFERARB") long pbuffer, @NativeType("HDC") long hdc) { + long __functionAddress = GL.getCapabilitiesWGL().wglReleasePbufferDCARB; + if (CHECKS) { + check(__functionAddress); + check(pbuffer); + check(hdc); + } + return callPPI(pbuffer, hdc, __functionAddress); + } + + // --- [ wglDestroyPbufferARB ] --- + + /** + * Destroys a pbuffer. + * + *The pbuffer is destroyed once it is no longer current to any rendering context. When a pbuffer is destroyed, any memory resources that are attached to + * it are freed and its handle is no longer valid.
+ * + * @param pbuffer a pbuffer handle + */ + @NativeType("BOOL") + public static boolean wglDestroyPbufferARB(@NativeType("HPBUFFERARB") long pbuffer) { + long __functionAddress = GL.getCapabilitiesWGL().wglDestroyPbufferARB; + if (CHECKS) { + check(__functionAddress); + check(pbuffer); + } + return callPI(pbuffer, __functionAddress) != 0; + } + + // --- [ wglQueryPbufferARB ] --- + + /** Unsafe version of: {@link #wglQueryPbufferARB QueryPbufferARB} */ + public static int nwglQueryPbufferARB(long pbuffer, int attribute, long value) { + long __functionAddress = GL.getCapabilitiesWGL().wglQueryPbufferARB; + if (CHECKS) { + check(__functionAddress); + check(pbuffer); + } + return callPPI(pbuffer, attribute, value, __functionAddress); + } + + /** + * Queries an attribute associated with a specific pbuffer. + * + * @param pbuffer a pbuffer handle + * @param attribute the attribute to query. One of:| {@link #WGL_PBUFFER_WIDTH_ARB PBUFFER_WIDTH_ARB} | {@link #WGL_PBUFFER_HEIGHT_ARB PBUFFER_HEIGHT_ARB} | {@link #WGL_PBUFFER_LOST_ARB PBUFFER_LOST_ARB} |
This extension adds functions to query pixel format attributes and to choose from the list of supported pixel formats.
+ * + *These functions treat pixel formats as opaque types: attributes are specified by name rather than by accessing them directly as fields in a structure. + * Thus the list of attributes can be easily extended.
+ * + *Requires {@link WGLARBExtensionsString WGL_ARB_extensions_string}.
+ */ +public class WGLARBPixelFormat { + + /** + * Accepted in the {@code attributes} parameter array of {@link #wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB}, and {@link #wglGetPixelFormatAttribfvARB GetPixelFormatAttribfvARB}, and as a type in + * the {@code attribIList} and {@code attribFList} parameter arrays of {@link #wglChoosePixelFormatARB ChoosePixelFormatARB}. + */ + public static final int + WGL_NUMBER_PIXEL_FORMATS_ARB = 0x2000, + WGL_DRAW_TO_WINDOW_ARB = 0x2001, + WGL_DRAW_TO_BITMAP_ARB = 0x2002, + WGL_ACCELERATION_ARB = 0x2003, + WGL_NEED_PALETTE_ARB = 0x2004, + WGL_NEED_SYSTEM_PALETTE_ARB = 0x2005, + WGL_SWAP_LAYER_BUFFERS_ARB = 0x2006, + WGL_SWAP_METHOD_ARB = 0x2007, + WGL_NUMBER_OVERLAYS_ARB = 0x2008, + WGL_NUMBER_UNDERLAYS_ARB = 0x2009, + WGL_TRANSPARENT_ARB = 0x200A, + WGL_TRANSPARENT_RED_VALUE_ARB = 0x2037, + WGL_TRANSPARENT_GREEN_VALUE_ARB = 0x2038, + WGL_TRANSPARENT_BLUE_VALUE_ARB = 0x2039, + WGL_TRANSPARENT_ALPHA_VALUE_ARB = 0x203A, + WGL_TRANSPARENT_INDEX_VALUE_ARB = 0x203B, + WGL_SHARE_DEPTH_ARB = 0x200C, + WGL_SHARE_STENCIL_ARB = 0x200D, + WGL_SHARE_ACCUM_ARB = 0x200E, + WGL_SUPPORT_GDI_ARB = 0x200F, + WGL_SUPPORT_OPENGL_ARB = 0x2010, + WGL_DOUBLE_BUFFER_ARB = 0x2011, + WGL_STEREO_ARB = 0x2012, + WGL_PIXEL_TYPE_ARB = 0x2013, + WGL_COLOR_BITS_ARB = 0x2014, + WGL_RED_BITS_ARB = 0x2015, + WGL_RED_SHIFT_ARB = 0x2016, + WGL_GREEN_BITS_ARB = 0x2017, + WGL_GREEN_SHIFT_ARB = 0x2018, + WGL_BLUE_BITS_ARB = 0x2019, + WGL_BLUE_SHIFT_ARB = 0x201A, + WGL_ALPHA_BITS_ARB = 0x201B, + WGL_ALPHA_SHIFT_ARB = 0x201C, + WGL_ACCUM_BITS_ARB = 0x201D, + WGL_ACCUM_RED_BITS_ARB = 0x201E, + WGL_ACCUM_GREEN_BITS_ARB = 0x201F, + WGL_ACCUM_BLUE_BITS_ARB = 0x2020, + WGL_ACCUM_ALPHA_BITS_ARB = 0x2021, + WGL_DEPTH_BITS_ARB = 0x2022, + WGL_STENCIL_BITS_ARB = 0x2023, + WGL_AUX_BUFFERS_ARB = 0x2024; + + /** + * Accepted as a value in the {@code attribIList} and {@code attribFList} parameter arrays of {@link #wglChoosePixelFormatARB ChoosePixelFormatARB}, and returned in the + * {@code values} parameter array of {@link #wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB} and {@link #wglGetPixelFormatAttribfvARB GetPixelFormatAttribfvARB}. + */ + public static final int + WGL_NO_ACCELERATION_ARB = 0x2025, + WGL_GENERIC_ACCELERATION_ARB = 0x2026, + WGL_FULL_ACCELERATION_ARB = 0x2027, + WGL_SWAP_EXCHANGE_ARB = 0x2028, + WGL_SWAP_COPY_ARB = 0x2029, + WGL_SWAP_UNDEFINED_ARB = 0x202A, + WGL_TYPE_RGBA_ARB = 0x202B, + WGL_TYPE_COLORINDEX_ARB = 0x202C; + + protected WGLARBPixelFormat() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglGetPixelFormatAttribivARB, caps.wglGetPixelFormatAttribfvARB, caps.wglChoosePixelFormatARB + ); + } + + // --- [ wglGetPixelFormatAttribivARB ] --- + + /** + * Unsafe version of: {@link #wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB} + * + * @param n the number of attributes being queried + */ + public static int nwglGetPixelFormatAttribivARB(long hdc, int pixelFormat, int layerPlane, int n, long attributes, long values) { + long __functionAddress = GL.getCapabilitiesWGL().wglGetPixelFormatAttribivARB; + if (CHECKS) { + check(__functionAddress); + check(hdc); + } + return callPPPI(hdc, pixelFormat, layerPlane, n, attributes, values, __functionAddress); + } + + /** + * @param hdc the device context on which the pixel format is supported + * @param pixelFormat an index that specifies the pixel format + * @param layerPlane the plane being queried + * @param attributes an array of pixel format attribute identifiers which specify the attributes to be queried. One of:| {@link #WGL_NUMBER_PIXEL_FORMATS_ARB NUMBER_PIXEL_FORMATS_ARB} | {@link #WGL_DRAW_TO_WINDOW_ARB DRAW_TO_WINDOW_ARB} | {@link #WGL_DRAW_TO_BITMAP_ARB DRAW_TO_BITMAP_ARB} | {@link #WGL_ACCELERATION_ARB ACCELERATION_ARB} |
| {@link #WGL_NEED_PALETTE_ARB NEED_PALETTE_ARB} | {@link #WGL_NEED_SYSTEM_PALETTE_ARB NEED_SYSTEM_PALETTE_ARB} | {@link #WGL_SWAP_LAYER_BUFFERS_ARB SWAP_LAYER_BUFFERS_ARB} | {@link #WGL_SWAP_METHOD_ARB SWAP_METHOD_ARB} |
| {@link #WGL_NUMBER_OVERLAYS_ARB NUMBER_OVERLAYS_ARB} | {@link #WGL_NUMBER_UNDERLAYS_ARB NUMBER_UNDERLAYS_ARB} | {@link #WGL_TRANSPARENT_ARB TRANSPARENT_ARB} | {@link #WGL_TRANSPARENT_RED_VALUE_ARB TRANSPARENT_RED_VALUE_ARB} |
| {@link #WGL_TRANSPARENT_GREEN_VALUE_ARB TRANSPARENT_GREEN_VALUE_ARB} | {@link #WGL_TRANSPARENT_BLUE_VALUE_ARB TRANSPARENT_BLUE_VALUE_ARB} | {@link #WGL_TRANSPARENT_ALPHA_VALUE_ARB TRANSPARENT_ALPHA_VALUE_ARB} | {@link #WGL_TRANSPARENT_INDEX_VALUE_ARB TRANSPARENT_INDEX_VALUE_ARB} |
| {@link #WGL_SHARE_DEPTH_ARB SHARE_DEPTH_ARB} | {@link #WGL_SHARE_STENCIL_ARB SHARE_STENCIL_ARB} | {@link #WGL_SHARE_ACCUM_ARB SHARE_ACCUM_ARB} | {@link #WGL_SUPPORT_GDI_ARB SUPPORT_GDI_ARB} |
| {@link #WGL_SUPPORT_OPENGL_ARB SUPPORT_OPENGL_ARB} | {@link #WGL_DOUBLE_BUFFER_ARB DOUBLE_BUFFER_ARB} | {@link #WGL_STEREO_ARB STEREO_ARB} | {@link #WGL_PIXEL_TYPE_ARB PIXEL_TYPE_ARB} |
| {@link #WGL_COLOR_BITS_ARB COLOR_BITS_ARB} | {@link #WGL_RED_BITS_ARB RED_BITS_ARB} | {@link #WGL_RED_SHIFT_ARB RED_SHIFT_ARB} | {@link #WGL_GREEN_BITS_ARB GREEN_BITS_ARB} |
| {@link #WGL_GREEN_SHIFT_ARB GREEN_SHIFT_ARB} | {@link #WGL_BLUE_BITS_ARB BLUE_BITS_ARB} | {@link #WGL_BLUE_SHIFT_ARB BLUE_SHIFT_ARB} | {@link #WGL_ALPHA_BITS_ARB ALPHA_BITS_ARB} |
| {@link #WGL_ALPHA_SHIFT_ARB ALPHA_SHIFT_ARB} | {@link #WGL_ACCUM_BITS_ARB ACCUM_BITS_ARB} | {@link #WGL_ACCUM_RED_BITS_ARB ACCUM_RED_BITS_ARB} | {@link #WGL_ACCUM_GREEN_BITS_ARB ACCUM_GREEN_BITS_ARB} |
| {@link #WGL_ACCUM_BLUE_BITS_ARB ACCUM_BLUE_BITS_ARB} | {@link #WGL_ACCUM_ALPHA_BITS_ARB ACCUM_ALPHA_BITS_ARB} | {@link #WGL_DEPTH_BITS_ARB DEPTH_BITS_ARB} | {@link #WGL_STENCIL_BITS_ARB STENCIL_BITS_ARB} |
| {@link #WGL_AUX_BUFFERS_ARB AUX_BUFFERS_ARB} |
| {@link #WGL_NUMBER_PIXEL_FORMATS_ARB NUMBER_PIXEL_FORMATS_ARB} | {@link #WGL_DRAW_TO_WINDOW_ARB DRAW_TO_WINDOW_ARB} | {@link #WGL_DRAW_TO_BITMAP_ARB DRAW_TO_BITMAP_ARB} | {@link #WGL_ACCELERATION_ARB ACCELERATION_ARB} |
| {@link #WGL_NEED_PALETTE_ARB NEED_PALETTE_ARB} | {@link #WGL_NEED_SYSTEM_PALETTE_ARB NEED_SYSTEM_PALETTE_ARB} | {@link #WGL_SWAP_LAYER_BUFFERS_ARB SWAP_LAYER_BUFFERS_ARB} | {@link #WGL_SWAP_METHOD_ARB SWAP_METHOD_ARB} |
| {@link #WGL_NUMBER_OVERLAYS_ARB NUMBER_OVERLAYS_ARB} | {@link #WGL_NUMBER_UNDERLAYS_ARB NUMBER_UNDERLAYS_ARB} | {@link #WGL_TRANSPARENT_ARB TRANSPARENT_ARB} | {@link #WGL_TRANSPARENT_RED_VALUE_ARB TRANSPARENT_RED_VALUE_ARB} |
| {@link #WGL_TRANSPARENT_GREEN_VALUE_ARB TRANSPARENT_GREEN_VALUE_ARB} | {@link #WGL_TRANSPARENT_BLUE_VALUE_ARB TRANSPARENT_BLUE_VALUE_ARB} | {@link #WGL_TRANSPARENT_ALPHA_VALUE_ARB TRANSPARENT_ALPHA_VALUE_ARB} | {@link #WGL_TRANSPARENT_INDEX_VALUE_ARB TRANSPARENT_INDEX_VALUE_ARB} |
| {@link #WGL_SHARE_DEPTH_ARB SHARE_DEPTH_ARB} | {@link #WGL_SHARE_STENCIL_ARB SHARE_STENCIL_ARB} | {@link #WGL_SHARE_ACCUM_ARB SHARE_ACCUM_ARB} | {@link #WGL_SUPPORT_GDI_ARB SUPPORT_GDI_ARB} |
| {@link #WGL_SUPPORT_OPENGL_ARB SUPPORT_OPENGL_ARB} | {@link #WGL_DOUBLE_BUFFER_ARB DOUBLE_BUFFER_ARB} | {@link #WGL_STEREO_ARB STEREO_ARB} | {@link #WGL_PIXEL_TYPE_ARB PIXEL_TYPE_ARB} |
| {@link #WGL_COLOR_BITS_ARB COLOR_BITS_ARB} | {@link #WGL_RED_BITS_ARB RED_BITS_ARB} | {@link #WGL_RED_SHIFT_ARB RED_SHIFT_ARB} | {@link #WGL_GREEN_BITS_ARB GREEN_BITS_ARB} |
| {@link #WGL_GREEN_SHIFT_ARB GREEN_SHIFT_ARB} | {@link #WGL_BLUE_BITS_ARB BLUE_BITS_ARB} | {@link #WGL_BLUE_SHIFT_ARB BLUE_SHIFT_ARB} | {@link #WGL_ALPHA_BITS_ARB ALPHA_BITS_ARB} |
| {@link #WGL_ALPHA_SHIFT_ARB ALPHA_SHIFT_ARB} | {@link #WGL_ACCUM_BITS_ARB ACCUM_BITS_ARB} | {@link #WGL_ACCUM_RED_BITS_ARB ACCUM_RED_BITS_ARB} | {@link #WGL_ACCUM_GREEN_BITS_ARB ACCUM_GREEN_BITS_ARB} |
| {@link #WGL_ACCUM_BLUE_BITS_ARB ACCUM_BLUE_BITS_ARB} | {@link #WGL_ACCUM_ALPHA_BITS_ARB ACCUM_ALPHA_BITS_ARB} | {@link #WGL_DEPTH_BITS_ARB DEPTH_BITS_ARB} | {@link #WGL_STENCIL_BITS_ARB STENCIL_BITS_ARB} |
| {@link #WGL_AUX_BUFFERS_ARB AUX_BUFFERS_ARB} |
This extension adds pixel formats with floating-point RGBA color components.
+ * + *Requires {@link WGLARBPixelFormat WGL_ARB_pixel_format} and {@link GL15 OpenGL 1.5}.
+ */ +public final class WGLARBPixelFormatFloat { + + /** + * Accepted as a value in the {@code attribIList} parameter array of {@link WGLARBPixelFormat#wglChoosePixelFormatARB ChoosePixelFormatARB}, and returned in the {@code values} + * parameter array of {@link WGLARBPixelFormat#wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB}. + */ + public static final int WGL_TYPE_RGBA_FLOAT_ARB = 0x21A0; + + private WGLARBPixelFormatFloat() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBRenderTexture.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBRenderTexture.java new file mode 100644 index 00000000..33bbb4da --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLARBRenderTexture.java @@ -0,0 +1,198 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the WGL_ARB_render_texture extension. + * + *This extension allows a color buffer to be used for both rendering and texturing. When a color buffer is bound to a texture target it cannot be + * rendered to. Once it has been released from the texture it can be rendered to once again.
+ * + *This extension may provide a performance boost and reduce memory requirements on architectures that support rendering to the same memory where textures + * reside and in the same memory format and layout required by texturing. The functionality is similar to CopyTexImage1D and CopyTexImage2D. However, some + * changes were made to make it easier to avoid copying data:
+ * + *Requires {@link WGLARBExtensionsString WGL_ARB_extensions_string}, {@link WGLARBPixelFormat WGL_ARB_pixel_format}, {@link WGLARBPbuffer WGL_ARB_pbuffer}.
+ */ +public class WGLARBRenderTexture { + + /** + * Accepted by the {@code attributes} parameter of {@link WGLARBPixelFormat#wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB}, and the {@code attribIList} parameters of + * {@link WGLARBPixelFormat#wglChoosePixelFormatARB ChoosePixelFormatARB}. + */ + public static final int + WGL_BIND_TO_TEXTURE_RGB_ARB = 0x2070, + WGL_BIND_TO_TEXTURE_RGBA_ARB = 0x2071; + + /** Accepted by the {@code attribList} parameter of {@link WGLARBPbuffer#wglCreatePbufferARB CreatePbufferARB} and by the {@code attribute} parameter of {@link WGLARBPbuffer#wglQueryPbufferARB QueryPbufferARB}. */ + public static final int + WGL_TEXTURE_FORMAT_ARB = 0x2072, + WGL_TEXTURE_TARGET_ARB = 0x2073, + WGL_MIPMAP_TEXTURE_ARB = 0x2074; + + /** + * Accepted as a value in the {@code attribList} parameter of {@link WGLARBPbuffer#wglCreatePbufferARB CreatePbufferARB} and returned in the value parameter of {@link WGLARBPbuffer#wglQueryPbufferARB QueryPbufferARB} when + * {@code attribute} is {@link #WGL_TEXTURE_FORMAT_ARB TEXTURE_FORMAT_ARB}. + */ + public static final int + WGL_TEXTURE_RGB_ARB = 0x2075, + WGL_TEXTURE_RGBA_ARB = 0x2076, + WGL_NO_TEXTURE_ARB = 0x2077; + + /** + * Accepted as a value in the {@code attribList} parameter of {@link WGLARBPbuffer#wglCreatePbufferARB CreatePbufferARB} and returned in the value parameter of {@link WGLARBPbuffer#wglQueryPbufferARB QueryPbufferARB} when + * {@code attribute} is {@link #WGL_TEXTURE_TARGET_ARB TEXTURE_TARGET_ARB}. + */ + public static final int + WGL_TEXTURE_CUBE_MAP_ARB = 0x2078, + WGL_TEXTURE_1D_ARB = 0x2079, + WGL_TEXTURE_2D_ARB = 0x207A; + + /** Accepted by the {@code attribList} parameter of {@link #wglSetPbufferAttribARB SetPbufferAttribARB} and by the {@code attribute} parameter of {@link WGLARBPbuffer#wglQueryPbufferARB QueryPbufferARB}. */ + public static final int + WGL_MIPMAP_LEVEL_ARB = 0x207B, + WGL_CUBE_MAP_FACE_ARB = 0x207C; + + /** + * Accepted as a value in the {@code attribList} parameter of {@link #wglSetPbufferAttribARB SetPbufferAttribARB} and returned in the value parameter of {@link WGLARBPbuffer#wglQueryPbufferARB QueryPbufferARB} when + * {@code attribute} is {@link #WGL_CUBE_MAP_FACE_ARB CUBE_MAP_FACE_ARB}. + */ + public static final int + WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x207D, + WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x207E, + WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x207F, + WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x2080, + WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x2081, + WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x2082; + + /** Accepted by the {@code buffer} parameter of {@link #wglBindTexImageARB BindTexImageARB} and {@link #wglReleaseTexImageARB ReleaseTexImageARB}. */ + public static final int + WGL_FRONT_LEFT_ARB = 0x2083, + WGL_FRONT_RIGHT_ARB = 0x2084, + WGL_BACK_LEFT_ARB = 0x2085, + WGL_BACK_RIGHT_ARB = 0x2086, + WGL_AUX0_ARB = 0x2087, + WGL_AUX1_ARB = 0x2088, + WGL_AUX2_ARB = 0x2089, + WGL_AUX3_ARB = 0x208A, + WGL_AUX4_ARB = 0x208B, + WGL_AUX5_ARB = 0x208C, + WGL_AUX6_ARB = 0x208D, + WGL_AUX7_ARB = 0x208E, + WGL_AUX8_ARB = 0x208F, + WGL_AUX9_ARB = 0x2090; + + protected WGLARBRenderTexture() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglBindTexImageARB, caps.wglReleaseTexImageARB, caps.wglSetPbufferAttribARB + ); + } + + // --- [ wglBindTexImageARB ] --- + + /** + * Defines a one-dimensional texture image or two-dimensional texture image or a set of two-dimensional cube map texture images. The texture image or + * images consist of the image data in {@code buffer} for the specified {@code pbuffer} and need not be copied. The texture target, the texture format and + * the size of the texture components are derived from attributes of pbuffer specified by {@code pbuffer}. + * + * @param pbuffer a pbuffer handle + * @param buffer the target buffer. One of:| {@link #WGL_FRONT_LEFT_ARB FRONT_LEFT_ARB} | {@link #WGL_FRONT_RIGHT_ARB FRONT_RIGHT_ARB} | {@link #WGL_BACK_LEFT_ARB BACK_LEFT_ARB} | {@link #WGL_BACK_RIGHT_ARB BACK_RIGHT_ARB} | {@link #WGL_AUX0_ARB AUX0_ARB} | WGL_AUX[1-9]_ARB |
| {@link #WGL_FRONT_LEFT_ARB FRONT_LEFT_ARB} | {@link #WGL_FRONT_RIGHT_ARB FRONT_RIGHT_ARB} | {@link #WGL_BACK_LEFT_ARB BACK_LEFT_ARB} | {@link #WGL_BACK_RIGHT_ARB BACK_RIGHT_ARB} | {@link #WGL_AUX0_ARB AUX0_ARB} | WGL_AUX[1-9]_ARB |
GL_ARB_robustness and WGL_ARB_create_context_robustness allow creating an OpenGL context supporting graphics reset notification behavior. + * WGL_ARB_robustness_application_isolation provides stronger guarantees about the possible side-effects of a graphics reset.
+ * + *If the graphics driver advertises the WGL_ARB_robustness_application_isolation extension string, then the driver guarantees that if a particular + * application causes a graphics reset to occur:
+ * + *Requires {@link WGLARBExtensionsString WGL_ARB_extensions_string} and {@link WGLARBCreateContextRobustness WGL_ARB_create_context_robustness}.
+ */ +public final class WGLARBRobustnessApplicationIsolation { + + /** + * Accepted as a bit in the attribute value for {@link WGLARBCreateContext#WGL_CONTEXT_FLAGS_ARB CONTEXT_FLAGS_ARB} in the {@code attribList} argument to + * {@link WGLARBCreateContext#wglCreateContextAttribsARB CreateContextAttribsARB}. + */ + public static final int WGL_CONTEXT_RESET_ISOLATION_BIT_ARB = 0x8; + + private WGLARBRobustnessApplicationIsolation() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLATIPixelFormatFloat.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLATIPixelFormatFloat.java new file mode 100644 index 00000000..15e57538 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLATIPixelFormatFloat.java @@ -0,0 +1,37 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_ATI_pixel_format_float extension. + * + *This extension adds pixel formats with floating-point RGBA color components.
+ * + *The size of each float components is specified using the same WGL_RED_BITS_ARB, WGL_GREEN_BITS_ARB, WGL_BLUE_BITS_ARB and WGL_ALPHA_BITS_ARB pixel + * format attributes that are used for defining the size of fixed-point components. 32 bit floating- point components are in the standard IEEE float + * format. 16 bit floating-point components have 1 sign bit, 5 exponent bits, and 10 mantissa bits.
+ * + *In standard OpenGL RGBA color components are normally clamped to the range [0,1]. The color components of a float buffer are clamped to the limits of + * the range representable by their format.
+ * + *Requires {@link WGLARBPixelFormat WGL_ARB_pixel_format}.
+ */ +public final class WGLATIPixelFormatFloat { + + /** Accepted by the {@code pname} parameters of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */ + public static final int + WGL_RGBA_FLOAT_MODE_ATI = 0x8820, + WGL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 0x8835; + + /** + * Accepted as a value in the {@code piAttribIList} and {@code pfAttribFList} parameter arrays of wglChoosePixelFormatARB, and returned in the + * {@code piValues} parameter array of wglGetPixelFormatAttribivARB, and the {@code pfValues} parameter array of wglGetPixelFormatAttribfvARB. + */ + public static final int WGL_TYPE_RGBA_FLOAT_ATI = 0x21A0; + + private WGLATIPixelFormatFloat() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLATIRenderTextureRectangle.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLATIRenderTextureRectangle.java new file mode 100644 index 00000000..920a80f8 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLATIRenderTextureRectangle.java @@ -0,0 +1,25 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_ATI_render_texture_rectangle extension. + * + *This extension builds upon {@link WGLARBRenderTexture WGL_ARB_render_texture} and allows a pbuffer to be bound to a texture rectangle target.
+ * + *Requires {@link WGLARBRenderTexture WGL_ARB_render_texture} and {@link ARBTextureRectangle ARB_texture_rectangle}.
+ */ +public final class WGLATIRenderTextureRectangle { + + /** + * Accepted as a value in the {@code piAttribList} parameter of wglCreatePbufferARB and returned in the value parameter of wglQueryPbufferARB when + * {@code iAttribute} is WGL_TEXTURE_TARGET_ARB. + */ + public static final int WGL_TEXTURE_RECTANGLE_ATI = 0x21A5; + + private WGLATIRenderTextureRectangle() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLCapabilities.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLCapabilities.java new file mode 100644 index 00000000..34c92fe0 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLCapabilities.java @@ -0,0 +1,289 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; +import java.util.Set; + +import static org.lwjgl.system.APIUtil.*; + +/** Defines the WGL capabilities of an OpenGL device. */ +public final class WGLCapabilities { + + public final long + wglGetGPUIDsAMD, + wglGetGPUInfoAMD, + wglGetContextGPUIDAMD, + wglCreateAssociatedContextAMD, + wglCreateAssociatedContextAttribsAMD, + wglDeleteAssociatedContextAMD, + wglMakeAssociatedContextCurrentAMD, + wglGetCurrentAssociatedContextAMD, + wglBlitContextFramebufferAMD, + wglCreateBufferRegionARB, + wglDeleteBufferRegionARB, + wglSaveBufferRegionARB, + wglRestoreBufferRegionARB, + wglCreateContextAttribsARB, + wglGetExtensionsStringARB, + wglMakeContextCurrentARB, + wglGetCurrentReadDCARB, + wglCreatePbufferARB, + wglGetPbufferDCARB, + wglReleasePbufferDCARB, + wglDestroyPbufferARB, + wglQueryPbufferARB, + wglGetPixelFormatAttribivARB, + wglGetPixelFormatAttribfvARB, + wglChoosePixelFormatARB, + wglBindTexImageARB, + wglReleaseTexImageARB, + wglSetPbufferAttribARB, + wglGetExtensionsStringEXT, + wglSwapIntervalEXT, + wglGetSwapIntervalEXT, + wglCopyImageSubDataNV, + wglDelayBeforeSwapNV, + wglDXSetResourceShareHandleNV, + wglDXOpenDeviceNV, + wglDXCloseDeviceNV, + wglDXRegisterObjectNV, + wglDXUnregisterObjectNV, + wglDXObjectAccessNV, + wglDXLockObjectsNV, + wglDXUnlockObjectsNV, + wglEnumGpusNV, + wglEnumGpuDevicesNV, + wglCreateAffinityDCNV, + wglEnumGpusFromAffinityDCNV, + wglDeleteDCNV, + wglJoinSwapGroupNV, + wglBindSwapBarrierNV, + wglQuerySwapGroupNV, + wglQueryMaxSwapGroupsNV, + wglQueryFrameCountNV, + wglResetFrameCountNV, + wglAllocateMemoryNV, + wglFreeMemoryNV; + + /** When true, {@link WGLAMDGPUAssociation} is supported. */ + public final boolean WGL_AMD_gpu_association; + /** When true, {@link WGLARBBufferRegion} is supported. */ + public final boolean WGL_ARB_buffer_region; + /** When true, {@link WGLARBContextFlushControl} is supported. */ + public final boolean WGL_ARB_context_flush_control; + /** When true, {@link WGLARBCreateContext} is supported. */ + public final boolean WGL_ARB_create_context; + /** When true, {@link WGLARBCreateContextNoError} is supported. */ + public final boolean WGL_ARB_create_context_no_error; + /** When true, {@link WGLARBCreateContextProfile} is supported. */ + public final boolean WGL_ARB_create_context_profile; + /** When true, {@link WGLARBCreateContextRobustness} is supported. */ + public final boolean WGL_ARB_create_context_robustness; + /** When true, {@link WGLARBExtensionsString} is supported. */ + public final boolean WGL_ARB_extensions_string; + /** When true, {@link WGLARBFramebufferSRGB} is supported. */ + public final boolean WGL_ARB_framebuffer_sRGB; + /** When true, {@link WGLARBMakeCurrentRead} is supported. */ + public final boolean WGL_ARB_make_current_read; + /** When true, {@link WGLARBMultisample} is supported. */ + public final boolean WGL_ARB_multisample; + /** When true, {@link WGLARBPbuffer} is supported. */ + public final boolean WGL_ARB_pbuffer; + /** When true, {@link WGLARBPixelFormat} is supported. */ + public final boolean WGL_ARB_pixel_format; + /** When true, {@link WGLARBPixelFormatFloat} is supported. */ + public final boolean WGL_ARB_pixel_format_float; + /** When true, {@link WGLARBRenderTexture} is supported. */ + public final boolean WGL_ARB_render_texture; + /** When true, {@link WGLARBRobustnessApplicationIsolation} is supported. */ + public final boolean WGL_ARB_robustness_application_isolation; + /** + * Native bindings to the WGL_ARB_robustness_share_group_isolation extension. + * + *GL_ARB_robustness and WGL_ARB_create_context_robustness allow creating an OpenGL context supporting graphics reset notification behavior. + * WGL_ARB_robustness_share_group_isolation provides stronger guarantees about the possible side-effects of a graphics reset.
+ * + *If the graphics driver advertises the WGL_ARB_robustness_share_group_isolation extension string, then the driver guarantees that if a context in a + * particular share group causes a graphics reset to occur:
+ * + *Requires {@link WGLARBExtensionsString WGL_ARB_extensions_string} and {@link WGLARBCreateContextRobustness WGL_ARB_create_context_robustness}.
+ */ + public final boolean WGL_ARB_robustness_share_group_isolation; + /** When true, {@link WGLATIPixelFormatFloat} is supported. */ + public final boolean WGL_ATI_pixel_format_float; + /** When true, {@link WGLATIRenderTextureRectangle} is supported. */ + public final boolean WGL_ATI_render_texture_rectangle; + /** When true, {@link WGLEXTColorspace} is supported. */ + public final boolean WGL_EXT_colorspace; + /** When true, {@link WGLEXTCreateContextES2Profile} is supported. */ + public final boolean WGL_EXT_create_context_es2_profile; + /** When true, {@link WGLEXTCreateContextESProfile} is supported. */ + public final boolean WGL_EXT_create_context_es_profile; + /** When true, {@link WGLEXTDepthFloat} is supported. */ + public final boolean WGL_EXT_depth_float; + /** When true, {@link WGLEXTExtensionsString} is supported. */ + public final boolean WGL_EXT_extensions_string; + /** When true, {@link WGLEXTFramebufferSRGB} is supported. */ + public final boolean WGL_EXT_framebuffer_sRGB; + /** When true, {@link WGLEXTPixelFormatPackedFloat} is supported. */ + public final boolean WGL_EXT_pixel_format_packed_float; + /** When true, {@link WGLEXTSwapControl} is supported. */ + public final boolean WGL_EXT_swap_control; + /** + * When true, the WGL_EXT_swap_control_tear extension is supported. + * + *This extension extends the existing {@link WGLEXTSwapControl WGL_EXT_swap_control} extension by allowing a negative {@code interval} parameter to + * {@link WGLEXTSwapControl#wglSwapIntervalEXT SwapIntervalEXT}. The negative {@code interval} allows late swaps to occur without synchronization to the video frame. This + * reduces the visual stutter on late frames and reduces the stall on subsequent frames.
+ */ + public final boolean WGL_EXT_swap_control_tear; + /** When true, {@link WGLNVCopyImage} is supported. */ + public final boolean WGL_NV_copy_image; + /** When true, {@link WGLNVDelayBeforeSwap} is supported. */ + public final boolean WGL_NV_delay_before_swap; + /** When true, {@link WGLNVDXInterop} is supported. */ + public final boolean WGL_NV_DX_interop; + /** + * When true, the WGL_NV_DX_interop2 extension is supported. + * + *This extension expands on the specification of {@link WGLNVDXInterop WGL_NV_DX_interop} to add support for DirectX version 10, 10.1 and 11 resources.
+ * + *Requires {@link GL20 OpenGL 2.0} and {@link WGLNVDXInterop WGL_NV_DX_interop}.
+ */ + public final boolean WGL_NV_DX_interop2; + /** When true, {@link WGLNVFloatBuffer} is supported. */ + public final boolean WGL_NV_float_buffer; + /** When true, {@link WGLNVGPUAffinity} is supported. */ + public final boolean WGL_NV_gpu_affinity; + /** When true, {@link WGLNVMultigpuContext} is supported. */ + public final boolean WGL_NV_multigpu_context; + /** When true, {@link WGLNVMultisampleCoverage} is supported. */ + public final boolean WGL_NV_multisample_coverage; + /** When true, {@link WGLNVRenderDepthTexture} is supported. */ + public final boolean WGL_NV_render_depth_texture; + /** When true, {@link WGLNVRenderTextureRectangle} is supported. */ + public final boolean WGL_NV_render_texture_rectangle; + /** When true, {@link WGLNVSwapGroup} is supported. */ + public final boolean WGL_NV_swap_group; + /** When true, {@code WGL_NV_vertex_array_range} is supported. */ + public final boolean WGL_NV_vertex_array_range; + + WGLCapabilities(FunctionProvider provider, SetApplications may wish to use sRGB format default framebuffers to more easily achieve sRGB rendering to display devices. This extension allows creating + * pixel formats which will be rendered to in sRGB by OpenGL/ES contexts supporting that capability.
+ * + *Requires {@link GL30 OpenGL 3.0}.
+ */ +public final class WGLEXTColorspace { + + /** Accepted as an attribute name by {@link WGLARBPixelFormat#wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB}, {@link WGLARBPixelFormat#wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB} and {@link WGLARBPixelFormat#wglChoosePixelFormatARB ChoosePixelFormatARB}. */ + public static final int WGL_COLORSPACE_EXT = 0x309D; + + /** Accepted as attribute values for {@link #WGL_COLORSPACE_EXT COLORSPACE_EXT} by {@link WGLARBPixelFormat#wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB}, {@link WGLARBPixelFormat#wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB} and {@link WGLARBPixelFormat#wglChoosePixelFormatARB ChoosePixelFormatARB}. */ + public static final int + WGL_COLORSPACE_SRGB_EXT = 0x3089, + WGL_COLORSPACE_LINEAR_EXT = 0x308A; + + private WGLEXTColorspace() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTCreateContextES2Profile.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTCreateContextES2Profile.java new file mode 100644 index 00000000..fc92dbb9 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTCreateContextES2Profile.java @@ -0,0 +1,22 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_EXT_create_context_es2_profile extension. + * + *This extension allows creating an OpenGL ES context.
+ * + *Requires {@link WGLARBExtensionsString WGL_ARB_extensions_string}, {@link WGLARBCreateContext WGL_ARB_create_context}, {@link WGLARBCreateContextProfile WGL_ARB_create_context_profile} and an OpenGL ES implementation.
+ */ +public final class WGLEXTCreateContextES2Profile { + + /** Accepted as a bit in the attribute value for {@link WGLARBCreateContextProfile#WGL_CONTEXT_PROFILE_MASK_ARB CONTEXT_PROFILE_MASK_ARB} in {@code attribList}. */ + public static final int WGL_CONTEXT_ES2_PROFILE_BIT_EXT = 0x4; + + private WGLEXTCreateContextES2Profile() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTCreateContextESProfile.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTCreateContextESProfile.java new file mode 100644 index 00000000..6a83f009 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTCreateContextESProfile.java @@ -0,0 +1,22 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_EXT_create_context_es_profile extension. + * + *This extension allows creating an OpenGL ES context.
+ * + *Requires {@link WGLARBExtensionsString WGL_ARB_extensions_string}, {@link WGLARBCreateContext WGL_ARB_create_context}, {@link WGLARBCreateContextProfile WGL_ARB_create_context_profile} and an OpenGL ES implementation.
+ */ +public final class WGLEXTCreateContextESProfile { + + /** Accepted as a bit in the attribute value for {@link WGLARBCreateContextProfile#WGL_CONTEXT_PROFILE_MASK_ARB CONTEXT_PROFILE_MASK_ARB} in {@code attribList}. */ + public static final int WGL_CONTEXT_ES_PROFILE_BIT_EXT = 0x4; + + private WGLEXTCreateContextESProfile() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTDepthFloat.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTDepthFloat.java new file mode 100644 index 00000000..1768de77 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTDepthFloat.java @@ -0,0 +1,27 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_EXT_depth_float extension. + * + *For perspective scenes, the density of objects (vertices) increases as the distance from the eye increases. For a linear depth buffer, this means that + * objects (vertices) are sparse for a large portion of the depth range and are dense for a small portion of the depth buffer.
+ * + *This behavior is obvious if you consider standing in a boat looking at the shore. The near objects include only the boat while the far objects include + * the entire shoreline which may include an entire city.
+ * + *A non-linear (floating-point) depth buffer helps this problem. If the near clipping plane is set to 1.0, and the far clipping plane is set to 0.0, a + * much greater resolution of objects can occur.
+ */ +public final class WGLEXTDepthFloat { + + /** Accepted by the {@code attribute} parameter of wglGetPixelFormatAttribivEXT, wglGetPixelFormatAttribfvEXT, and wglChoosePixelFormatExEXT. */ + public static final int WGL_DEPTH_FLOAT_EXT = 0x2040; + + private WGLEXTDepthFloat() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTExtensionsString.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTExtensionsString.java new file mode 100644 index 00000000..5b58d464 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTExtensionsString.java @@ -0,0 +1,52 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** Native bindings to the WGL_EXT_extensions_string extension. */ +public class WGLEXTExtensionsString { + + protected WGLEXTExtensionsString() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglGetExtensionsStringEXT + ); + } + + // --- [ wglGetExtensionsStringEXT ] --- + + /** Unsafe version of: {@link #wglGetExtensionsStringEXT GetExtensionsStringEXT} */ + public static long nwglGetExtensionsStringEXT() { + long __functionAddress = GL.getCapabilitiesWGL().wglGetExtensionsStringEXT; + if (CHECKS) { + check(__functionAddress); + } + return callP(__functionAddress); + } + + /** + * Returns a list of supported extensions to WGL. Although the contents of the string is implementation specific, the string will be {@code NULL} terminated and + * will contain a space-separated list of extension names. (The extension names themselves do not contain spaces.) If there are no extensions then the + * empty string is returned. + */ + @Nullable + @NativeType("char const *") + public static String wglGetExtensionsStringEXT() { + long __result = nwglGetExtensionsStringEXT(); + return memASCIISafe(__result); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTFramebufferSRGB.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTFramebufferSRGB.java new file mode 100644 index 00000000..c075e1f9 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTFramebufferSRGB.java @@ -0,0 +1,25 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_EXT_framebuffer_sRGB extension. + * + *WGL functionality for {@link EXTFramebufferSRGB EXT_framebuffer_sRGB}.
+ * + *Requires {@link WGLEXTExtensionsString WGL_EXT_extensions_string} and {@link WGLARBPixelFormat WGL_ARB_pixel_format}.
+ */ +public final class WGLEXTFramebufferSRGB { + + /** + * Accepted by the {@code piAttributes} parameter of wglGetPixelFormatAttribivEXT, wglGetPixelFormatAttribfvEXT, and the {@code piAttribIList} and + * {@code pfAttribIList} of wglChoosePixelFormatEXT. + */ + public static final int WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x20A9; + + private WGLEXTFramebufferSRGB() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTPixelFormatPackedFloat.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTPixelFormatPackedFloat.java new file mode 100644 index 00000000..81b8d313 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTPixelFormatPackedFloat.java @@ -0,0 +1,26 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_EXT_pixel_format_packed_float extension. + * + *This extension provides support for rendering into an unsigned floating-point rendering format with the assumption that the texture format described in + * {@link EXTPackedFloat} could also be advertised as an unsigned floating-point format for rendering.
+ * + *Requires {@link WGLARBPixelFormat WGL_ARB_pixel_format}.
+ */ +public final class WGLEXTPixelFormatPackedFloat { + + /** + * Accepted as a value in the {@code attribIList} parameter array of {@link WGLARBPixelFormat#wglChoosePixelFormatARB ChoosePixelFormatARB}, and returned in the {@code values} + * parameter array of {@link WGLARBPixelFormat#wglGetPixelFormatAttribivARB GetPixelFormatAttribivARB}. + */ + public static final int WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT = 0x20A8; + + private WGLEXTPixelFormatPackedFloat() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTSwapControl.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTSwapControl.java new file mode 100644 index 00000000..b5fa5b48 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLEXTSwapControl.java @@ -0,0 +1,69 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** + * Native bindings to the WGL_EXT_swap_control extension. + * + *This extension allows an application to specify a minimum periodicity of color buffer swaps, measured in video frame periods.
+ * + *Requires {@link WGLEXTExtensionsString WGL_EXT_extensions_string}.
+ */ +public class WGLEXTSwapControl { + + protected WGLEXTSwapControl() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglSwapIntervalEXT, caps.wglGetSwapIntervalEXT + ); + } + + // --- [ wglSwapIntervalEXT ] --- + + /** + * Specifies the minimum number of video frame periods per buffer swap for the window associated with the current context. The interval takes effect when + * {@link org.lwjgl.system.windows.GDI32#SwapBuffers} or wglSwapLayerBuffer is first called subsequent to the {@code wglSwapIntervalEXT} call. + * + *A video frame period is the time required by the monitor to display a full frame of video data. In the case of an interlaced monitor, this is typically + * the time required to display both the even and odd fields of a frame of video data. An interval set to a value of 2 means that the color buffers will + * be swapped at most every other video frame.
+ * + *If {@code interval} is set to a value of 0, buffer swaps are not synchronized to a video frame. The {@code interval} value is silently clamped to the + * maximum implementation-dependent value supported before being stored.
+ * + *The swap interval is not part of the render context state. It cannot be pushed or popped. The default swap interval is 1.
+ * + * @param interval the minimum number of video frames that are displayed before a buffer swap will occur + */ + @NativeType("BOOL") + public static boolean wglSwapIntervalEXT(int interval) { + long __functionAddress = GL.getCapabilitiesWGL().wglSwapIntervalEXT; + if (CHECKS) { + check(__functionAddress); + } + return callI(interval, __functionAddress) != 0; + } + + // --- [ wglGetSwapIntervalEXT ] --- + + /** Returns the current swap interval for the window associated with the current context. */ + public static int wglGetSwapIntervalEXT() { + long __functionAddress = GL.getCapabilitiesWGL().wglGetSwapIntervalEXT; + if (CHECKS) { + check(__functionAddress); + } + return callI(__functionAddress); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVCopyImage.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVCopyImage.java new file mode 100644 index 00000000..85886c08 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVCopyImage.java @@ -0,0 +1,68 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +/** + * Native bindings to the WGL_NV_copy_image extension. + * + *This extension enables efficient image data transfer between image objects (i.e. textures and renderbuffers) without the need to bind the objects or + * otherwise configure the rendering pipeline. The WGL version allows copying between images in different contexts, even if those contexts are in + * different sharelists or even on different physical devices.
+ */ +public class WGLNVCopyImage { + + protected WGLNVCopyImage() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglCopyImageSubDataNV + ); + } + + // --- [ wglCopyImageSubDataNV ] --- + + /** + * Behaves identically to the core function {@link #wglCopyImageSubDataNV CopyImageSubDataNV}, except that the {@code srcRC} and {@code dstRC} parameters specify + * the contexts in which to look up the source and destination objects, respectively. A value of zero indicates that the currently bound context should be + * used instead. + * + * @param srcRC the source OpenGL context + * @param srcName the source object + * @param srcTarget the source object target + * @param srcLevel the source level-of-detail number + * @param srcX the source texel x coordinate + * @param srcY the source texel y coordinate + * @param srcZ the source texel z coordinate + * @param dstRC the destination OpenGL context + * @param dstName the destination object + * @param dstTarget the destination object target + * @param dstLevel the destination level-of-detail number + * @param dstX the destination texel x coordinate + * @param dstY the destination texel y coordinate + * @param dstZ the destination texel z coordinate + * @param width the number of texels to copy in the x-dimension + * @param height the number of texels to copy in the y-dimension + * @param depth the number of texels to copy in the z-dimension + */ + @NativeType("BOOL") + public static boolean wglCopyImageSubDataNV(@NativeType("HGLRC") long srcRC, @NativeType("GLuint") int srcName, @NativeType("GLenum") int srcTarget, @NativeType("GLint") int srcLevel, @NativeType("GLint") int srcX, @NativeType("GLint") int srcY, @NativeType("GLint") int srcZ, @NativeType("HGLRC") long dstRC, @NativeType("GLuint") int dstName, @NativeType("GLenum") int dstTarget, @NativeType("GLint") int dstLevel, @NativeType("GLint") int dstX, @NativeType("GLint") int dstY, @NativeType("GLint") int dstZ, @NativeType("GLsizei") int width, @NativeType("GLsizei") int height, @NativeType("GLsizei") int depth) { + long __functionAddress = GL.getCapabilitiesWGL().wglCopyImageSubDataNV; + if (CHECKS) { + check(__functionAddress); + check(srcRC); + check(dstRC); + } + return callPPI(srcRC, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstRC, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth, __functionAddress) != 0; + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVDXInterop.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVDXInterop.java new file mode 100644 index 00000000..b110b388 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVDXInterop.java @@ -0,0 +1,203 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the WGL_NV_DX_interop extension. + * + *This extension allows OpenGL to directly access DirectX buffers and surfaces. A DirectX vertex buffer may be shared as an OpenGL buffer object and a + * DirectX surface may be shared as an OpenGL texture or renderbuffer object.
+ * + *Requires {@link GL21 OpenGL 2.1}.
+ */ +public class WGLNVDXInterop { + + /** Accepted by the {@code access} parameters of {@link #wglDXRegisterObjectNV DXRegisterObjectNV} and {@link #wglDXObjectAccessNV DXObjectAccessNV}. */ + public static final int + WGL_ACCESS_READ_ONLY_NV = 0x0, + WGL_ACCESS_READ_WRITE_NV = 0x1, + WGL_ACCESS_WRITE_DISCARD_NV = 0x2; + + protected WGLNVDXInterop() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglDXSetResourceShareHandleNV, caps.wglDXOpenDeviceNV, caps.wglDXCloseDeviceNV, caps.wglDXRegisterObjectNV, caps.wglDXUnregisterObjectNV, + caps.wglDXObjectAccessNV, caps.wglDXLockObjectsNV, caps.wglDXUnlockObjectsNV + ); + } + + // --- [ wglDXSetResourceShareHandleNV ] --- + + /** + * @param dxObject a pointer to the DirectX resource that will be shared + * @param shareHandle the share handle that the OS generated for the resource + */ + @NativeType("BOOL") + public static boolean wglDXSetResourceShareHandleNV(@NativeType("void *") long dxObject, @NativeType("HANDLE") long shareHandle) { + long __functionAddress = GL.getCapabilitiesWGL().wglDXSetResourceShareHandleNV; + if (CHECKS) { + check(__functionAddress); + check(dxObject); + check(shareHandle); + } + return callPPI(dxObject, shareHandle, __functionAddress) != 0; + } + + // --- [ wglDXOpenDeviceNV ] --- + + /** + * Prepares a DirectX device for interoperability and returns a handle to a GL/DirectX interop device. + * + * @param dxDevice a pointer to a supported Direct3D device object + */ + @NativeType("HANDLE") + public static long wglDXOpenDeviceNV(@NativeType("void *") long dxDevice) { + long __functionAddress = GL.getCapabilitiesWGL().wglDXOpenDeviceNV; + if (CHECKS) { + check(__functionAddress); + check(dxDevice); + } + return callPP(dxDevice, __functionAddress); + } + + // --- [ wglDXCloseDeviceNV ] --- + + @NativeType("BOOL") + public static boolean wglDXCloseDeviceNV(@NativeType("HANDLE") long device) { + long __functionAddress = GL.getCapabilitiesWGL().wglDXCloseDeviceNV; + if (CHECKS) { + check(__functionAddress); + check(device); + } + return callPI(device, __functionAddress) != 0; + } + + // --- [ wglDXRegisterObjectNV ] --- + + /** + * Prepares a DirectX object for use by the GL and returns a handle to a GL/DirectX interop object. + * + * @param device a GL/DirectX interop device handle, as returned by {@link #wglDXOpenDeviceNV DXOpenDeviceNV} + * @param dxResource a pointer to a DirectX resource to be registered with the GL + * @param name the GL object name to be assigned to the DirectX resource in the namespace of the objects identified by {@code type} in the current GL context + * @param type the GL object type that will map to the DirectX resource being shared + * @param access indicates the intended usage of the resource in GL. One of:| {@link #WGL_ACCESS_READ_ONLY_NV ACCESS_READ_ONLY_NV} | {@link #WGL_ACCESS_READ_WRITE_NV ACCESS_READ_WRITE_NV} | {@link #WGL_ACCESS_WRITE_DISCARD_NV ACCESS_WRITE_DISCARD_NV} |
| {@link #WGL_ACCESS_READ_ONLY_NV ACCESS_READ_ONLY_NV} | {@link #WGL_ACCESS_READ_WRITE_NV ACCESS_READ_WRITE_NV} | {@link #WGL_ACCESS_WRITE_DISCARD_NV ACCESS_WRITE_DISCARD_NV} |
A return value of TRUE indicates that all objects were successfully locked. A return value of FALSE indicates an error. If the function returns FALSE, + * none of the objects will be locked.
+ * + *Attempting to access an interop object via GL when the object is not locked, or attempting to access the DirectX resource through the DirectX API when + * it is locked by GL, will result in undefined behavior and may result in data corruption or program termination. Likewise, passing invalid interop device + * or object handles to this function has undefined results, including program termination.
+ * + * @param device the GL/DirectX interop device handle + * @param objects an array of {@code count} interop objects + */ + @NativeType("BOOL") + public static boolean wglDXLockObjectsNV(@NativeType("HANDLE") long device, @NativeType("HANDLE *") PointerBuffer objects) { + return nwglDXLockObjectsNV(device, objects.remaining(), memAddress(objects)) != 0; + } + + // --- [ wglDXUnlockObjectsNV ] --- + + /** + * Unsafe version of: {@link #wglDXUnlockObjectsNV DXUnlockObjectsNV} + * + * @param count the number of objects to unlock + */ + public static int nwglDXUnlockObjectsNV(long device, int count, long objects) { + long __functionAddress = GL.getCapabilitiesWGL().wglDXUnlockObjectsNV; + if (CHECKS) { + check(__functionAddress); + check(device); + } + return callPPI(device, count, objects, __functionAddress); + } + + /** + * Return control of an object to DirectX. + * + * @param device the GL/DirectX interop device handle + * @param objects an array of {@code count} interop objects + */ + @NativeType("BOOL") + public static boolean wglDXUnlockObjectsNV(@NativeType("HANDLE") long device, @NativeType("HANDLE *") PointerBuffer objects) { + return nwglDXUnlockObjectsNV(device, objects.remaining(), memAddress(objects)) != 0; + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVDelayBeforeSwap.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVDelayBeforeSwap.java new file mode 100644 index 00000000..6fbf00e5 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVDelayBeforeSwap.java @@ -0,0 +1,75 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; + +import org.lwjgl.system.windows.WinBase; + +/** + * Native bindings to the WGL_NV_delay_before_swap extension. + * + *For most interactive applications, the standard rendering loop responding to input events on a frame granularity is sufficient. Some more demanding + * applications may want to exchange performance for the ability to sample input closer to the final frame swap and adjust rendering accordingly. This + * extension adds functionality to allow the application to wait until a specified time before a swapbuffers command would be able to execute.
+ * + *Requires {@link GL21 OpenGL 2.1}.
+ */ +public class WGLNVDelayBeforeSwap { + + protected WGLNVDelayBeforeSwap() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglDelayBeforeSwapNV + ); + } + + // --- [ wglDelayBeforeSwapNV ] --- + + /** + * Blocks the CPU until {@code seconds} seconds before a synchronized swap would occur on the window associated with {@code hDC}. It also returns a boolean + * value equal to {@link WinBase#TRUE} when the implementation had to wait for the synchronized swap and {@link WinBase#FALSE} otherwise. + * + *The parameter {@code hDC} must be a valid device context associated with a graphic adapter. If {@code hDC} is not valid, {@link WinBase#GetLastError} will + * return WGL_INVALID_HDC, {@code DelayBeforeSwapNV} will return FALSE and will not wait for the swap. If {@code hDC} is not associated with a graphic + * adapter, {@code GetLastError} will return ERROR_DC_NOT_FOUND, {@code DelayBeforeSwapNV} will return FALSE and will not wait for the swap.
+ * + *The parameter {@code seconds} accepts positive floating point values not larger than the length in seconds of the swap period on the associated window. + * When buffer swaps are synchronized, the swap period is composed of one or multiple video frame periods. A video frame period is the time required by the + * monitor to display a full frame of video data. A swap interval set to a value of 2 means that the color buffers will be swapped at most every other + * video frame. If {@code seconds} is smaller than 0, {@code GetLastError} will return ERROR_INVALID_DATA, {@code DelayBeforeSwapNV} will return FALSE and + * will not wait for the end of the swap period. If {@code seconds} is greater than a swap period, {@code DelayBeforeSwapNV} will return immediately + * without generating any error and the return value will be FALSE.
+ * + *The application should use a {@code seconds} delay large enough to have time to complete its work before the end of the swap period. If {@code seconds} + * is close to 0.0, the application may miss the end of the swap period and it will have to wait an additional swap period before it can swap.
+ * + *If {@code DelayBeforeSwapNV} detects that there is less than {@code seconds} seconds before the end of the swap period, it will return immediately and + * the return value will be FALSE. The implementation will not wait an additional video frame period to have an exact delay of {@code seconds} seconds.
+ * + *If buffer swaps are unsynchronized, {@code DelayBeforeSwapNV} will return immediately and the return value will be FALSE. It could happen for multiple + * reasons, for example if the swap interval is equal to 0, if the window is in a mode switch or if no monitors are active.
+ * + * @param hDC a handle to the DC + * @param seconds the delay, in seconds + */ + @NativeType("BOOL") + public static boolean wglDelayBeforeSwapNV(@NativeType("HDC") long hDC, @NativeType("GLfloat") float seconds) { + long __functionAddress = GL.getCapabilitiesWGL().wglDelayBeforeSwapNV; + if (CHECKS) { + check(__functionAddress); + check(hDC); + } + return callPI(hDC, seconds, __functionAddress) != 0; + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVFloatBuffer.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVFloatBuffer.java new file mode 100644 index 00000000..9259643c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVFloatBuffer.java @@ -0,0 +1,38 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_NV_float_buffer extension. + * + *WGL functionality for {@link NVFloatBuffer NV_float_buffer}.
+ */ +public final class WGLNVFloatBuffer { + + /** + * Accepted in the {@code piAttributes} array of wglGetPixelFormatAttribivARB and wglGetPixelFormatAttribfvARB and in the {@code piAttribIList} and + * {@code pfAttribFList} arrays of wglChoosePixelFormatARB. + */ + public static final int + WGL_FLOAT_COMPONENTS_NV = 0x20B0, + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV = 0x20B1, + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV = 0x20B2, + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV = 0x20B3, + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = 0x20B4; + + /** + * Accepted in the {@code piAttribIList} array of wglCreatePbufferARB and returned in the {@code value} parameter of wglQueryPbufferARB when + * {@code iAttribute} is TEXTURE_FORMAT_ARB. + */ + public static final int + WGL_TEXTURE_FLOAT_R_NV = 0x20B5, + WGL_TEXTURE_FLOAT_RG_NV = 0x20B6, + WGL_TEXTURE_FLOAT_RGB_NV = 0x20B7, + WGL_TEXTURE_FLOAT_RGBA_NV = 0x20B8; + + private WGLNVFloatBuffer() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVGPUAffinity.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVGPUAffinity.java new file mode 100644 index 00000000..f3dda8e4 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVGPUAffinity.java @@ -0,0 +1,176 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the WGL_NV_gpu_affinity extension. + * + *On systems with more than one GPU it is desirable to be able to select which GPU(s) in the system become the target for OpenGL rendering commands. This + * extension introduces the concept of a GPU affinity mask. OpenGL rendering commands are directed to the GPU(s) specified by the affinity mask. GPU + * affinity is immutable. Once set, it cannot be changed.
+ * + *This extension also introduces the concept called affinity-DC. An affinity-DC is a device context with a GPU affinity mask embedded in it. This + * restricts the device context to only allow OpenGL commands to be sent to the GPU(s) in the affinity mask.
+ * + *Requires {@link WGLARBExtensionsString WGL_ARB_extensions_string}.
+ */ +public class WGLNVGPUAffinity { + + /** New error code set by wglShareLists, wglMakeCurrent and {@link WGLARBMakeCurrentRead#wglMakeContextCurrentARB MakeContextCurrentARB}. */ + public static final int ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV = 0x20D0; + + /** New error code set by {@link WGL#wglMakeCurrent MakeCurrent} and {@link WGLARBMakeCurrentRead#wglMakeContextCurrentARB MakeContextCurrentARB}. */ + public static final int ERROR_MISSING_AFFINITY_MASK_NV = 0x20D1; + + protected WGLNVGPUAffinity() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglEnumGpusNV, caps.wglEnumGpuDevicesNV, caps.wglCreateAffinityDCNV, caps.wglEnumGpusFromAffinityDCNV, caps.wglDeleteDCNV + ); + } + + // --- [ wglEnumGpusNV ] --- + + /** Unsafe version of: {@link #wglEnumGpusNV EnumGpusNV} */ + public static int nwglEnumGpusNV(int gpuIndex, long gpu) { + long __functionAddress = GL.getCapabilitiesWGL().wglEnumGpusNV; + if (CHECKS) { + check(__functionAddress); + } + return callPI(gpuIndex, gpu, __functionAddress); + } + + /** + * Returns the handles for all GPUs in a system. + * + *By looping over {@code wglEnumGpusNV} and incrementing {@code gpuIndex}, starting at index 0, all GPU handles can be queried. If the function succeeds, + * the return value is TRUE. If the function fails, the return value is FALSE and {@code gpu} will be unmodified. The function fails if {@code gpuIndex} is + * greater or equal than the number of GPUs supported by the system.
+ * + * @param gpuIndex an index value that specifies a GPU + * @param gpu returns a handle for GPU number {@code gpuIndex}. The first GPU will be index 0. + */ + @NativeType("BOOL") + public static boolean wglEnumGpusNV(@NativeType("UINT") int gpuIndex, @NativeType("HGPUNV *") PointerBuffer gpu) { + if (CHECKS) { + check(gpu, 1); + } + return nwglEnumGpusNV(gpuIndex, memAddress(gpu)) != 0; + } + + // --- [ wglEnumGpuDevicesNV ] --- + + /** Unsafe version of: {@link #wglEnumGpuDevicesNV EnumGpuDevicesNV} */ + public static int nwglEnumGpuDevicesNV(long gpu, int deviceIndex, long gpuDevice) { + long __functionAddress = GL.getCapabilitiesWGL().wglEnumGpuDevicesNV; + if (CHECKS) { + check(__functionAddress); + check(gpu); + } + return callPPI(gpu, deviceIndex, gpuDevice, __functionAddress); + } + + /** + * Retrieve information about the display devices supported by a GPU. + * + * @param gpu a handle to the GPU to query + * @param deviceIndex an index value that specifies a display device, supported by {@code gpu}, to query. The first display device will be index 0. + * @param gpuDevice a {@link GPU_DEVICE} structure which will receive information about the display device at index {@code deviceIndex}. + */ + @NativeType("BOOL") + public static boolean wglEnumGpuDevicesNV(@NativeType("HGPUNV") long gpu, @NativeType("UINT") int deviceIndex, @NativeType("PGPU_DEVICE") GPU_DEVICE gpuDevice) { + return nwglEnumGpuDevicesNV(gpu, deviceIndex, gpuDevice.address()) != 0; + } + + // --- [ wglCreateAffinityDCNV ] --- + + /** Unsafe version of: {@link #wglCreateAffinityDCNV CreateAffinityDCNV} */ + public static long nwglCreateAffinityDCNV(long gpuList) { + long __functionAddress = GL.getCapabilitiesWGL().wglCreateAffinityDCNV; + if (CHECKS) { + check(__functionAddress); + } + return callPP(gpuList, __functionAddress); + } + + /** + * Creates an affinity-DC. Affinity-DCs, a new type of DC, can be used to direct OpenGL commands to a specific GPU or set of GPUs. An affinity-DC is a + * device context with a GPU affinity mask embedded in it. This restricts the device context to only allow OpenGL commands to be sent to the GPU(s) in the + * affinity mask. An affinity-DC can be created directly, using the new function {@code wglCreateAffinityDCNV} and also indirectly by calling + * {@link WGLARBPbuffer#wglCreatePbufferARB CreatePbufferARB} followed by {@link WGLARBPbuffer#wglGetPbufferDCARB GetPbufferDCARB}. + * + *If successful, the function returns an affinity-DC handle. If it fails, {@code NULL} will be returned.
+ * + * @param gpuList a {@code NULL}-terminated array of GPU handles to which the affinity-DC will be restricted + */ + @NativeType("HDC") + public static long wglCreateAffinityDCNV(@NativeType("HGPUNV const *") PointerBuffer gpuList) { + if (CHECKS) { + checkNT(gpuList); + } + return nwglCreateAffinityDCNV(memAddress(gpuList)); + } + + // --- [ wglEnumGpusFromAffinityDCNV ] --- + + /** Unsafe version of: {@link #wglEnumGpusFromAffinityDCNV EnumGpusFromAffinityDCNV} */ + public static int nwglEnumGpusFromAffinityDCNV(long affinityDC, int gpuIndex, long gpu) { + long __functionAddress = GL.getCapabilitiesWGL().wglEnumGpusFromAffinityDCNV; + if (CHECKS) { + check(__functionAddress); + check(affinityDC); + } + return callPPI(affinityDC, gpuIndex, gpu, __functionAddress); + } + + /** + * Retrieves a list of GPU handles that make up the affinity-mask of an affinity-DC. + * + *By looping over {@code wglEnumGpusFromAffinityDCNV} and incrementing {@code gpuIndex}, starting at index 0, all GPU handles associated with the DC can + * be queried. If the function succeeds, the return value is TRUE. If the function fails, the return value is FALSE and {@code gpu} will be unmodified. The + * function fails if {@code gpuIndex} is greater or equal than the number of GPUs associated with {@code affinityDC}.
+ * + * @param affinityDC a handle of the affinity-DC to query + * @param gpuIndex an index value of the GPU handle in the affinity mask of {@code affinityDC} to query + * @param gpu returns a handle for GPU number {@code gpuIndex}. The first GPU will be at index 0. + */ + @NativeType("BOOL") + public static boolean wglEnumGpusFromAffinityDCNV(@NativeType("HDC") long affinityDC, @NativeType("UINT") int gpuIndex, @NativeType("HGPUNV *") PointerBuffer gpu) { + if (CHECKS) { + check(gpu, 1); + } + return nwglEnumGpusFromAffinityDCNV(affinityDC, gpuIndex, memAddress(gpu)) != 0; + } + + // --- [ wglDeleteDCNV ] --- + + /** + * Deletes an affinity-DC. + * + * @param hdc a handle of an affinity-DC to delete + */ + @NativeType("BOOL") + public static boolean wglDeleteDCNV(@NativeType("HDC") long hdc) { + long __functionAddress = GL.getCapabilitiesWGL().wglDeleteDCNV; + if (CHECKS) { + check(__functionAddress); + check(hdc); + } + return callPI(hdc, __functionAddress) != 0; + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVMultigpuContext.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVMultigpuContext.java new file mode 100644 index 00000000..ebc263c9 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVMultigpuContext.java @@ -0,0 +1,43 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_NV_multigpu_context extension. + * + *This extension allows the creation of an OpenGL context in a multi-GPU environment with a specified multi-GPU strategy (known as SLI mode) which takes + * precedence over process-wide multi-GPU mode settings.
+ * + *The multi-GPU mode denotes vendor specific techniques to allow distributed rendering on multiple GPUs, further called AFR (alternate frame rendering) + * and Multicast (as defined in NV_gpu_multicast).
+ * + *OpenGL supports multiple contexts. The semantics of switching contexts is generally left to window system binding APIs such as WGL, GLX and EGL. The + * extension {@code WGL_NV_multigpu_context} allows to specify a preferred multi-GPU rendering mode per context, thus context switching can also switch + * the current multi-GPU rendering mode.
+ * + *The implementation is platform dependent and the actual multi-GPU rendering mode of the created context may vary on different hardware and operation + * system platforms.
+ * + *Requires {@link WGLARBCreateContext WGL_ARB_create_context}.
+ */ +public final class WGLNVMultigpuContext { + + /** Accepted as an attribute name in the {@code *attrib_list} argument to {@link WGLARBCreateContext#wglCreateContextAttribsARB CreateContextAttribsARB}. */ + public static final int WGL_CONTEXT_MULTIGPU_ATTRIB_NV = 0x20AA; + + /** + * Accepted as an attribute value for {@link #WGL_CONTEXT_MULTIGPU_ATTRIB_NV CONTEXT_MULTIGPU_ATTRIB_NV} in the {@code *attrib_list} argument to + * {@link WGLARBCreateContext#wglCreateContextAttribsARB CreateContextAttribsARB}. + */ + public static final int + WGL_CONTEXT_MULTIGPU_ATTRIB_SINGLE_NV = 0x20AB, + WGL_CONTEXT_MULTIGPU_ATTRIB_AFR_NV = 0x20AC, + WGL_CONTEXT_MULTIGPU_ATTRIB_MULTICAST_NV = 0x20AD, + WGL_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV = 0x20AE; + + private WGLNVMultigpuContext() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVMultisampleCoverage.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVMultisampleCoverage.java new file mode 100644 index 00000000..010c9de6 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVMultisampleCoverage.java @@ -0,0 +1,25 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_NV_multisample_coverage extension. + * + *WGL functionality for {@link NVMultisampleCoverage NV_multisample_coverage}.
+ */ +public final class WGLNVMultisampleCoverage { + + /** + * Accepted by the {@code piAttributes} parameter of wglGetPixelFormatAttribivEXT, wglGetPixelFormatAttribfvEXT, and the + * {@code piAttribIList} and {@code pfAttribIList} of wglChoosePixelFormatEXT. + */ + public static final int + WGL_COVERAGE_SAMPLES_NV = 0x2042, + WGL_COLOR_SAMPLES_NV = 0x20B9; + + private WGLNVMultisampleCoverage() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVRenderDepthTexture.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVRenderDepthTexture.java new file mode 100644 index 00000000..d4fffdcb --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVRenderDepthTexture.java @@ -0,0 +1,40 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_NV_render_depth_texture extension. + * + *This extension allows a depth buffer to be used for both rendering and texturing. It is built upon the ARB_render_texture extension; the only addition + * in this extension is the ability to use a depth buffer as a DEPTH_COMPONENT texture map.
+ */ +public final class WGLNVRenderDepthTexture { + + /** + * Accepted by the {@code piAttributes} parameter of wglGetPixelFormatAttribivARB, wglGetPixelFormatAttribfvARB, and the {@code piAttribIList} and + * {@code pfAttribIList} parameters of wglChoosePixelFormatARB. + */ + public static final int + WGL_BIND_TO_TEXTURE_DEPTH_NV = 0x20A3, + WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = 0x20A4; + + /** Accepted by the {@code piAttribList} parameter of wglCreatePbufferARB and by the {@code iAttribute} parameter of wglQueryPbufferARB. */ + public static final int WGL_DEPTH_TEXTURE_FORMAT_NV = 0x20A5; + + /** + * Accepted as a value in the {@code piAttribList} parameter of wglCreatePbufferARB and returned in the value parameter of wglQueryPbufferARB when + * {@code iAttribute} is WGL_DEPTH_TEXTURE_FORMAT_NV. + */ + public static final int + WGL_TEXTURE_DEPTH_COMPONENT_NV = 0x20A6, + WGL_NO_TEXTURE_ARB = 0x2077; + + /** Accepted by the {@code iBuffer} parameter of wglBindTexImageARB. */ + public static final int WGL_DEPTH_COMPONENT_NV = 0x20A7; + + private WGLNVRenderDepthTexture() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVRenderTextureRectangle.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVRenderTextureRectangle.java new file mode 100644 index 00000000..2824ba16 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVRenderTextureRectangle.java @@ -0,0 +1,33 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +/** + * Native bindings to the WGL_NV_render_texture_rectangle extension. + * + *This extension allows a color buffer with non-power-of-two dimensions to be used for both rendering and texturing. It is built upon the + * ARB_render_texture extension; the only addition in this extension is the ability to bind a texture to a texture rectangle target, as provided through + * the NV_texture_rectangle extension.
+ */ +public final class WGLNVRenderTextureRectangle { + + /** + * Accepted by the {@code piAttributes} parameter of wglGetPixelFormatAttribivARB, wglGetPixelFormatAttribfvARB, and the {@code piAttribIList} and + * {@code pfAttribIList} parameters of wglChoosePixelFormatARB. + */ + public static final int + WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = 0x20A0, + WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = 0x20A1; + + /** + * Accepted as a value in the {@code piAttribList} parameter of wglCreatePbufferARB and returned in the value parameter of wglQueryPbufferARB when + * {@code iAttribute} is WGL_TEXTURE_TARGET_ARB. + */ + public static final int WGL_TEXTURE_RECTANGLE_NV = 0x20A2; + + private WGLNVRenderTextureRectangle() {} + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVSwapGroup.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVSwapGroup.java new file mode 100644 index 00000000..0c42582a --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVSwapGroup.java @@ -0,0 +1,172 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to the WGL_NV_swap_group extension. + * + *This extension provides the capability to synchronize the buffer swaps of a group of OpenGL windows. A swap group is created, and windows are added as + * members to the swap group. Buffer swaps to members of the swap group will then take place concurrently.
+ * + *This extension also provides the capability to sychronize the buffer swaps of different swap groups, which may reside on distributed systems on a + * network. For this purpose swap groups can be bound to a swap barrier.
+ * + *This extension extends the set of conditions that must be met before a buffer swap can take place.
+ */ +public class WGLNVSwapGroup { + + protected WGLNVSwapGroup() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglJoinSwapGroupNV, caps.wglBindSwapBarrierNV, caps.wglQuerySwapGroupNV, caps.wglQueryMaxSwapGroupsNV, caps.wglQueryFrameCountNV, + caps.wglResetFrameCountNV + ); + } + + // --- [ wglJoinSwapGroupNV ] --- + + @NativeType("BOOL") + public static boolean wglJoinSwapGroupNV(@NativeType("HDC") long hDC, @NativeType("GLuint") int group) { + long __functionAddress = GL.getCapabilitiesWGL().wglJoinSwapGroupNV; + if (CHECKS) { + check(__functionAddress); + check(hDC); + } + return callPI(hDC, group, __functionAddress) != 0; + } + + // --- [ wglBindSwapBarrierNV ] --- + + @NativeType("BOOL") + public static boolean wglBindSwapBarrierNV(@NativeType("GLuint") int group, @NativeType("GLuint") int barrier) { + long __functionAddress = GL.getCapabilitiesWGL().wglBindSwapBarrierNV; + if (CHECKS) { + check(__functionAddress); + } + return callI(group, barrier, __functionAddress) != 0; + } + + // --- [ wglQuerySwapGroupNV ] --- + + public static int nwglQuerySwapGroupNV(long hDC, long group, long barrier) { + long __functionAddress = GL.getCapabilitiesWGL().wglQuerySwapGroupNV; + if (CHECKS) { + check(__functionAddress); + check(hDC); + } + return callPPPI(hDC, group, barrier, __functionAddress); + } + + @NativeType("BOOL") + public static boolean wglQuerySwapGroupNV(@NativeType("HDC") long hDC, @NativeType("GLuint *") IntBuffer group, @NativeType("GLuint *") IntBuffer barrier) { + if (CHECKS) { + check(group, 1); + check(barrier, 1); + } + return nwglQuerySwapGroupNV(hDC, memAddress(group), memAddress(barrier)) != 0; + } + + // --- [ wglQueryMaxSwapGroupsNV ] --- + + public static int nwglQueryMaxSwapGroupsNV(long hDC, long maxGroups, long maxBarriers) { + long __functionAddress = GL.getCapabilitiesWGL().wglQueryMaxSwapGroupsNV; + if (CHECKS) { + check(__functionAddress); + check(hDC); + } + return callPPPI(hDC, maxGroups, maxBarriers, __functionAddress); + } + + @NativeType("BOOL") + public static boolean wglQueryMaxSwapGroupsNV(@NativeType("HDC") long hDC, @NativeType("GLuint *") IntBuffer maxGroups, @NativeType("GLuint *") IntBuffer maxBarriers) { + if (CHECKS) { + check(maxGroups, 1); + check(maxBarriers, 1); + } + return nwglQueryMaxSwapGroupsNV(hDC, memAddress(maxGroups), memAddress(maxBarriers)) != 0; + } + + // --- [ wglQueryFrameCountNV ] --- + + public static int nwglQueryFrameCountNV(long hDC, long count) { + long __functionAddress = GL.getCapabilitiesWGL().wglQueryFrameCountNV; + if (CHECKS) { + check(__functionAddress); + check(hDC); + } + return callPPI(hDC, count, __functionAddress); + } + + @NativeType("BOOL") + public static boolean wglQueryFrameCountNV(@NativeType("HDC") long hDC, @NativeType("GLuint *") IntBuffer count) { + if (CHECKS) { + check(count, 1); + } + return nwglQueryFrameCountNV(hDC, memAddress(count)) != 0; + } + + // --- [ wglResetFrameCountNV ] --- + + @NativeType("BOOL") + public static boolean wglResetFrameCountNV(@NativeType("HDC") long hDC) { + long __functionAddress = GL.getCapabilitiesWGL().wglResetFrameCountNV; + if (CHECKS) { + check(__functionAddress); + check(hDC); + } + return callPI(hDC, __functionAddress) != 0; + } + + /** Array version of: {@link #wglQuerySwapGroupNV QuerySwapGroupNV} */ + @NativeType("BOOL") + public static boolean wglQuerySwapGroupNV(@NativeType("HDC") long hDC, @NativeType("GLuint *") int[] group, @NativeType("GLuint *") int[] barrier) { + long __functionAddress = GL.getCapabilitiesWGL().wglQuerySwapGroupNV; + if (CHECKS) { + check(__functionAddress); + check(hDC); + check(group, 1); + check(barrier, 1); + } + return callPPPI(hDC, group, barrier, __functionAddress) != 0; + } + + /** Array version of: {@link #wglQueryMaxSwapGroupsNV QueryMaxSwapGroupsNV} */ + @NativeType("BOOL") + public static boolean wglQueryMaxSwapGroupsNV(@NativeType("HDC") long hDC, @NativeType("GLuint *") int[] maxGroups, @NativeType("GLuint *") int[] maxBarriers) { + long __functionAddress = GL.getCapabilitiesWGL().wglQueryMaxSwapGroupsNV; + if (CHECKS) { + check(__functionAddress); + check(hDC); + check(maxGroups, 1); + check(maxBarriers, 1); + } + return callPPPI(hDC, maxGroups, maxBarriers, __functionAddress) != 0; + } + + /** Array version of: {@link #wglQueryFrameCountNV QueryFrameCountNV} */ + @NativeType("BOOL") + public static boolean wglQueryFrameCountNV(@NativeType("HDC") long hDC, @NativeType("GLuint *") int[] count) { + long __functionAddress = GL.getCapabilitiesWGL().wglQueryFrameCountNV; + if (CHECKS) { + check(__functionAddress); + check(hDC); + check(count, 1); + } + return callPPI(hDC, count, __functionAddress) != 0; + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVVertexArrayRange.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVVertexArrayRange.java new file mode 100644 index 00000000..39b87204 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/WGLNVVertexArrayRange.java @@ -0,0 +1,61 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.opengl; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.JNI.*; +import static org.lwjgl.system.MemoryUtil.*; + +public class WGLNVVertexArrayRange { + + protected WGLNVVertexArrayRange() { + throw new UnsupportedOperationException(); + } + + static boolean isAvailable(WGLCapabilities caps) { + return checkFunctions( + caps.wglAllocateMemoryNV, caps.wglFreeMemoryNV + ); + } + + // --- [ wglAllocateMemoryNV ] --- + + public static long nwglAllocateMemoryNV(int size, float readfreq, float writefreq, float priority) { + long __functionAddress = GL.getCapabilitiesWGL().wglAllocateMemoryNV; + if (CHECKS) { + check(__functionAddress); + } + return callP(size, readfreq, writefreq, priority, __functionAddress); + } + + @Nullable + @NativeType("void *") + public static ByteBuffer wglAllocateMemoryNV(@NativeType("GLsizei") int size, @NativeType("GLfloat") float readfreq, @NativeType("GLfloat") float writefreq, @NativeType("GLfloat") float priority) { + long __result = nwglAllocateMemoryNV(size, readfreq, writefreq, priority); + return memByteBufferSafe(__result, size); + } + + // --- [ wglFreeMemoryNV ] --- + + public static void nwglFreeMemoryNV(long pointer) { + long __functionAddress = GL.getCapabilitiesWGL().wglFreeMemoryNV; + if (CHECKS) { + check(__functionAddress); + } + callPV(pointer, __functionAddress); + } + + public static void wglFreeMemoryNV(@NativeType("void *") ByteBuffer pointer) { + nwglFreeMemoryNV(memAddress(pointer)); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/package-info.java b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/package-info.java new file mode 100644 index 00000000..785eb5f0 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/opengl/package-info.java @@ -0,0 +1,41 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ + +/** + * Contains bindings to the OpenGL cross-platform 2D and 3D rendering API. + * + *The OpenGL registry is a useful online resource that contains the OpenGL and OpenGL + * Shading Language specifications, as well as specifications of OpenGL extensions. + * The OpenGL Reference Pages is another convenient source of documentation.
+ * + *The bindings of the core OpenGL functionality are contained in two distinct class hierarchies:
+ * + *Each of the above classes extends the class of the previous OpenGL version in the corresponding hierarchy.
+ * + *The recommended way to write OpenGL applications with LWJGL is to statically import the class that corresponds to the minimum required OpenGL version. + * This will expose all symbols up to that version. Additional functionality (later core versions or extensions) should be guarded with appropriate checks + * using the {@link org.lwjgl.opengl.GLCapabilities GLCapabilities} instance of the OpenGL context.
+ * + *The Compatibility Profile and Core Profile class hierarchies should not be mixed with static imports, as that would result in compilation ambiguities + * when resolving the symbols. Note that the Compatibility Profile hierarchy can be used with a Core Profile context (as long as no deprecated symbol is + * used) and the Core Profile hierarchy can be used with a Compatibility Profile context. The recommendation is to use the Compatibility Profile hierarchy + * only when deprecated functionality is required. In any other case, the Core Profile hierarchy should be preferred.
+ * + *For example, an OpenGL application that requires OpenGL 3.3, must use modern OpenGL features only and needs the best possible performance:
+ * + *LWJGL is a Java library that enables cross-platform access to popular native APIs useful in the development of graphics (OpenGL), audio (OpenAL) and + * parallel computing (OpenCL) applications. This access is direct and high-performance, yet also wrapped in a type-safe and user-friendly layer, appropriate + * for the Java ecosystem.
+ * + *LWJGL is an enabling technology and provides low-level access. It is not a framework and does not provide higher-level utilities than what the native + * libraries expose. As such, novice programmers are encouraged to try one of the frameworks or game engines that make use of LWJGL, before working directly + * with the library.
+ * + *LWJGL is open source software and freely available at no charge.
+ * + * @see www.lwjgl.org + */ +@org.lwjgl.system.NonnullDefault +package org.lwjgl; diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/LibSTB.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/LibSTB.java new file mode 100644 index 00000000..5d362bd7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/LibSTB.java @@ -0,0 +1,46 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; + +/** Initializes the stb shared library. */ +final class LibSTB { + + static { + String libName = Platform.mapLibraryNameBundled("lwjgl"); + Library.loadSystem(System::load, System::loadLibrary, LibSTB.class, "org.lwjgl.stb", libName); + + MemoryAllocator allocator = getAllocator(Configuration.DEBUG_MEMORY_ALLOCATOR_INTERNAL.get(true)); + setupMalloc( + allocator.getMalloc(), + allocator.getCalloc(), + allocator.getRealloc(), + allocator.getFree(), + allocator.getAlignedAlloc(), + allocator.getAlignedFree() + ); + } + + private LibSTB() { + } + + static void initialize() { + // intentionally empty to trigger static initializer + } + + private static native void setupMalloc( + long malloc, + long calloc, + long realloc, + long free, + long aligned_alloc, + long aligned_free + ); + +} diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBDXT.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBDXT.java new file mode 100644 index 00000000..136993be --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBDXT.java @@ -0,0 +1,96 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import java.nio.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to stb_dxt.h from the stb library. + * + *DXT1/DXT5 compressor.
+ */ +public class STBDXT { + + public static final int STB_DXT_NORMAL = 0x0; + + /** Use dithering. Dubious win, never use for normal maps and the like! */ + public static final int STB_DXT_DITHER = 0x1; + + /** High quality mode, does two refinement steps instead of 1. ~30-40% slower. */ + public static final int STB_DXT_HIGHQUAL = 0x2; + + static { LibSTB.initialize(); } + + protected STBDXT() { + throw new UnsupportedOperationException(); + } + + // --- [ stb_compress_dxt_block ] --- + + /** Unsafe version of: {@link #stb_compress_dxt_block compress_dxt_block} */ + public static native void nstb_compress_dxt_block(long dest, long src_rgba_four_bytes_per_pixel, int alpha, int mode); + + /** + * Call this function for every block (you must pad). The source should be a 4x4 block of RGBA data in row-major order; A is ignored if you specify + * {@code alpha=0}; you can turn on dithering and "high quality" using {@code mode}. + * + * @param dest a buffer in which to store the compressed block + * @param src_rgba_four_bytes_per_pixel the block to compress + * @param alpha 1 to compress the alpha channel, 0 to ignore it + * @param mode the compression mode. One of:| {@link #STB_DXT_NORMAL DXT_NORMAL} | {@link #STB_DXT_DITHER DXT_DITHER} | {@link #STB_DXT_HIGHQUAL DXT_HIGHQUAL} |
Bitmap font for use in 3D APIs:
+ * + *Intended for when you just want to get some text displaying in a 3D app as quickly as possible.
+ * + *Doesn't use any textures, instead builds characters out of quads.
+ * + *Here's sample code for old OpenGL; it's a lot more complicated to make work on modern APIs, and that's your problem.
+ * + *
+ * void print_string(float x, float y, char *text, float r, float g, float b)
+ * {
+ * static char buffer[99999]; // ~500 chars
+ * int num_quads;
+ *
+ * num_quads = stb_easy_font_print(x, y, text, NULL, buffer, sizeof(buffer));
+ *
+ * glColor3f(r,g,b);
+ * glEnableClientState(GL_VERTEX_ARRAY);
+ * glVertexPointer(2, GL_FLOAT, 16, buffer);
+ * glDrawArrays(GL_QUADS, 0, num_quads*4);
+ * glDisableClientState(GL_VERTEX_ARRAY);
+ * }The vertex data is divided into quads, i.e. there are four vertices in the vertex buffer for each quad.
+ * + *The vertices are stored in an interleaved format:
+ * + *
+ * x:float
+ * y:float
+ * z:float
+ * color:uint8[4]You can ignore z and color if you get them from elsewhere. This format was chosen in the hopes it would make it easier for you to reuse existing + * buffer-drawing code.
+ * + *If you pass in {@code NULL} for color, it becomes {@code 255,255,255,255}.
+ * + *If the buffer isn't large enough, it will truncate. Expect it to use an average of ~270 bytes per character.
+ * + *If your API doesn't draw quads, build a reusable index list that allows you to render quads as indexed triangles.
+ * + * @param x the x offset + * @param y the y offset + * @param text an ASCII string + * @param color the text color, in RGBA (4 bytes) + * @param vertex_buffer a pointer to memory in which to store the vertex data + * + * @return the number of quads + */ + public static int stb_easy_font_print(float x, float y, @NativeType("char *") ByteBuffer text, @Nullable @NativeType("unsigned char *") ByteBuffer color, @NativeType("void *") ByteBuffer vertex_buffer) { + if (CHECKS) { + checkNT1(text); + checkSafe(color, 4); + } + return nstb_easy_font_print(x, y, memAddress(text), memAddressSafe(color), memAddress(vertex_buffer), vertex_buffer.remaining()); + } + + /** + * Takes a string (which can contain '\n') and fills out a vertex buffer with renderable data to draw the string. Output data assumes increasing x is + * rightwards, increasing y is downwards. + * + *The vertex data is divided into quads, i.e. there are four vertices in the vertex buffer for each quad.
+ * + *The vertices are stored in an interleaved format:
+ * + *
+ * x:float
+ * y:float
+ * z:float
+ * color:uint8[4]You can ignore z and color if you get them from elsewhere. This format was chosen in the hopes it would make it easier for you to reuse existing + * buffer-drawing code.
+ * + *If you pass in {@code NULL} for color, it becomes {@code 255,255,255,255}.
+ * + *If the buffer isn't large enough, it will truncate. Expect it to use an average of ~270 bytes per character.
+ * + *If your API doesn't draw quads, build a reusable index list that allows you to render quads as indexed triangles.
+ * + * @param x the x offset + * @param y the y offset + * @param text an ASCII string + * @param color the text color, in RGBA (4 bytes) + * @param vertex_buffer a pointer to memory in which to store the vertex data + * + * @return the number of quads + */ + public static int stb_easy_font_print(float x, float y, @NativeType("char *") CharSequence text, @Nullable @NativeType("unsigned char *") ByteBuffer color, @NativeType("void *") ByteBuffer vertex_buffer) { + if (CHECKS) { + checkSafe(color, 4); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nASCII(text, true); + long textEncoded = stack.getPointerAddress(); + return nstb_easy_font_print(x, y, textEncoded, memAddressSafe(color), memAddress(vertex_buffer), vertex_buffer.remaining()); + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ stb_easy_font_spacing ] --- + + /** + * Use positive values to expand the space between characters, and small negative values (no smaller than {@code -1.5}) to contract the space between characters. + * + *E.g. {@code spacing = 1} adds one "pixel" of spacing between the characters. {@code spacing = -1} is reasonable but feels a bit too compact to me; + * {@code -0.5} is a reasonable compromise as long as you're scaling the font up.
+ * + * @param spacing the font spacing + */ + public static native void stb_easy_font_spacing(float spacing); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBIEOFCallback.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBIEOFCallback.java new file mode 100644 index 00000000..7158aa73 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBIEOFCallback.java @@ -0,0 +1,75 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Instances of this class may be set to the {@code eof} field of the {@link STBIIOCallbacks} struct. + * + *
+ * int (*) (
+ * void *user
+ * )
+ * int (*) (
+ * void *user
+ * )
+ * struct stbi_io_callbacks {
+ * int (*{@link STBIReadCallbackI read}) (void *user, char *data, int size);
+ * void (*{@link STBISkipCallbackI skip}) (void *user, int n);
+ * int (*{@link STBIEOFCallbackI eof}) (void *user);
+ * }The created instance holds a strong reference to the container object.
+ */ + public STBIIOCallbacks(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code read} field. */ + @NativeType("int (*) (void *, char *, int)") + public STBIReadCallback read() { return nread(address()); } + /** Returns the value of the {@code skip} field. */ + @NativeType("void (*) (void *, int)") + public STBISkipCallback skip() { return nskip(address()); } + /** Returns the value of the {@code eof} field. */ + @NativeType("int (*) (void *)") + public STBIEOFCallback eof() { return neof(address()); } + + /** Sets the specified value to the {@code read} field. */ + public STBIIOCallbacks read(@NativeType("int (*) (void *, char *, int)") STBIReadCallbackI value) { nread(address(), value); return this; } + /** Sets the specified value to the {@code skip} field. */ + public STBIIOCallbacks skip(@NativeType("void (*) (void *, int)") STBISkipCallbackI value) { nskip(address(), value); return this; } + /** Sets the specified value to the {@code eof} field. */ + public STBIIOCallbacks eof(@NativeType("int (*) (void *)") STBIEOFCallbackI value) { neof(address(), value); return this; } + + /** Initializes this struct with the specified values. */ + public STBIIOCallbacks set( + STBIReadCallbackI read, + STBISkipCallbackI skip, + STBIEOFCallbackI eof + ) { + read(read); + skip(skip); + eof(eof); + + return this; + } + + /** + * Copies the specified struct data to this struct. + * + * @param src the source struct + * + * @return this struct + */ + public STBIIOCallbacks set(STBIIOCallbacks src) { + memCopy(src.address(), address(), SIZEOF); + return this; + } + + // ----------------------------------- + + /** Returns a new {@code STBIIOCallbacks} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static STBIIOCallbacks malloc() { + return wrap(STBIIOCallbacks.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code STBIIOCallbacks} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static STBIIOCallbacks calloc() { + return wrap(STBIIOCallbacks.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code STBIIOCallbacks} instance allocated with {@link BufferUtils}. */ + public static STBIIOCallbacks create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(STBIIOCallbacks.class, memAddress(container), container); + } + + /** Returns a new {@code STBIIOCallbacks} instance for the specified memory address. */ + public static STBIIOCallbacks create(long address) { + return wrap(STBIIOCallbacks.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static STBIIOCallbacks createSafe(long address) { + return address == NULL ? null : wrap(STBIIOCallbacks.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code STBIIOCallbacks} instance allocated on the thread-local {@link MemoryStack}. */ + public static STBIIOCallbacks mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code STBIIOCallbacks} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static STBIIOCallbacks callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code STBIIOCallbacks} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static STBIIOCallbacks mallocStack(MemoryStack stack) { + return wrap(STBIIOCallbacks.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code STBIIOCallbacks} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static STBIIOCallbacks callocStack(MemoryStack stack) { + return wrap(STBIIOCallbacks.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #read}. */ + public static STBIReadCallback nread(long struct) { return STBIReadCallback.create(memGetAddress(struct + STBIIOCallbacks.READ)); } + /** Unsafe version of {@link #skip}. */ + public static STBISkipCallback nskip(long struct) { return STBISkipCallback.create(memGetAddress(struct + STBIIOCallbacks.SKIP)); } + /** Unsafe version of {@link #eof}. */ + public static STBIEOFCallback neof(long struct) { return STBIEOFCallback.create(memGetAddress(struct + STBIIOCallbacks.EOF)); } + + /** Unsafe version of {@link #read(STBIReadCallbackI) read}. */ + public static void nread(long struct, STBIReadCallbackI value) { memPutAddress(struct + STBIIOCallbacks.READ, value.address()); } + /** Unsafe version of {@link #skip(STBISkipCallbackI) skip}. */ + public static void nskip(long struct, STBISkipCallbackI value) { memPutAddress(struct + STBIIOCallbacks.SKIP, value.address()); } + /** Unsafe version of {@link #eof(STBIEOFCallbackI) eof}. */ + public static void neof(long struct, STBIEOFCallbackI value) { memPutAddress(struct + STBIIOCallbacks.EOF, value.address()); } + + /** + * Validates pointer members that should not be {@code NULL}. + * + * @param struct the struct to validate + */ + public static void validate(long struct) { + check(memGetAddress(struct + STBIIOCallbacks.READ)); + check(memGetAddress(struct + STBIIOCallbacks.SKIP)); + check(memGetAddress(struct + STBIIOCallbacks.EOF)); + } + + /** + * Calls {@link #validate(long)} for each struct contained in the specified struct array. + * + * @param array the struct array to validate + * @param count the number of structs in {@code array} + */ + public static void validate(long array, int count) { + for (int i = 0; i < count; i++) { + validate(array + Integer.toUnsignedLong(i) * SIZEOF); + } + } + + // ----------------------------------- + + /** An array of {@link STBIIOCallbacks} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected STBIIOCallbacks getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code read} field. */ + @NativeType("int (*) (void *, char *, int)") + public STBIReadCallback read() { return STBIIOCallbacks.nread(address()); } + /** Returns the value of the {@code skip} field. */ + @NativeType("void (*) (void *, int)") + public STBISkipCallback skip() { return STBIIOCallbacks.nskip(address()); } + /** Returns the value of the {@code eof} field. */ + @NativeType("int (*) (void *)") + public STBIEOFCallback eof() { return STBIIOCallbacks.neof(address()); } + + /** Sets the specified value to the {@code read} field. */ + public Buffer read(@NativeType("int (*) (void *, char *, int)") STBIReadCallbackI value) { STBIIOCallbacks.nread(address(), value); return this; } + /** Sets the specified value to the {@code skip} field. */ + public Buffer skip(@NativeType("void (*) (void *, int)") STBISkipCallbackI value) { STBIIOCallbacks.nskip(address(), value); return this; } + /** Sets the specified value to the {@code eof} field. */ + public Buffer eof(@NativeType("int (*) (void *)") STBIEOFCallbackI value) { STBIIOCallbacks.neof(address(), value); return this; } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBIReadCallback.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBIReadCallback.java new file mode 100644 index 00000000..a77cc7a6 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBIReadCallback.java @@ -0,0 +1,93 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; + +import java.nio.*; + +/** + * Instances of this class may be set to the {@code read} field of the {@link STBIIOCallbacks} struct. + * + *
+ * int (*) (
+ * void *user,
+ * char *data,
+ * int size
+ * )This method may only be used inside a STBIReadCallback invocation.
+ * + * @param data the STBIReadCallback {@code data} argument + * @param size the STBIReadCallback {@code size} argument + * + * @return the data as a ByteBuffer + */ + public static ByteBuffer getData(long data, int size) { + return memByteBuffer(data, size); + } + + private static final class Container extends STBIReadCallback { + + private final STBIReadCallbackI delegate; + + Container(long functionPointer, STBIReadCallbackI delegate) { + super(functionPointer); + this.delegate = delegate; + } + + @Override + public int invoke(long user, long data, int size) { + return delegate.invoke(user, data, size); + } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBIReadCallbackI.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBIReadCallbackI.java new file mode 100644 index 00000000..ff63a8df --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBIReadCallbackI.java @@ -0,0 +1,53 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.dyncall.DynCallback.*; + +/** + * Instances of this interface may be set to the {@code read} field of the {@link STBIIOCallbacks} struct. + * + *
+ * int (*) (
+ * void *user,
+ * char *data,
+ * int size
+ * )
+ * void (*) (
+ * void *user,
+ * int n
+ * )
+ * void (*) (
+ * void *user,
+ * int n
+ * )
+ * void (*) (
+ * void *context,
+ * void *data,
+ * int size
+ * )This method may only be used inside a STBIWriteCallback invocation.
+ * + * @param data the STBIWriteCallback {@code data} argument + * @param size the STBIWriteCallback {@code size} argument + * + * @return the data as a ByteBuffer + */ + public static ByteBuffer getData(long data, int size) { + return memByteBuffer(data, size); + } + + private static final class Container extends STBIWriteCallback { + + private final STBIWriteCallbackI delegate; + + Container(long functionPointer, STBIWriteCallbackI delegate) { + super(functionPointer); + this.delegate = delegate; + } + + @Override + public void invoke(long context, long data, int size) { + delegate.invoke(context, data, size); + } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBIWriteCallbackI.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBIWriteCallbackI.java new file mode 100644 index 00000000..6b5442ac --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBIWriteCallbackI.java @@ -0,0 +1,51 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.dyncall.DynCallback.*; + +/** + * Instances of this interface may be used with the {@link STBImageWrite} {@code write_type_to_func} functions. + * + *
+ * void (*) (
+ * void *context,
+ * void *data,
+ * int size
+ * )
+ * unsigned char * (*) (
+ * unsigned char *data,
+ * int data_len,
+ * int *out_len,
+ * int quality
+ * )
+ * unsigned char * (*) (
+ * unsigned char *data,
+ * int data_len,
+ * int *out_len,
+ * int quality
+ * )The returned data will be freed with {@link MemoryUtil#memFree} so it must be heap allocated with {@link MemoryUtil#memAlloc}.
+ * + * @param data the data to compress + * @param data_len the data length, in bytes + * @param out_len returns the compressed data length, in bytes + * @param quality the compression quality to use + * + * @return the compressed data + */ + @NativeType("unsigned char *") long invoke(@NativeType("unsigned char *") long data, int data_len, @NativeType("int *") long out_len, int quality); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBImage.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBImage.java new file mode 100644 index 00000000..82c302b1 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBImage.java @@ -0,0 +1,1322 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to stb_image.h from the stb library. + * + *Primarily of interest to game developers and other people who can avoid problematic images and only need the trivial interface. Supported formats:
+ * + *Animated GIF still needs a proper API, but here's one way to do it.
+ * + *Features:
+ * + *Limitations:
+ * + *Basic usage (see HDR discussion below for HDR usage):
+ * + *
+ * int x,y,n;
+ * unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
+ * // ... process data if not NULL ...
+ * // ... x = width, y = height, n = # 8-bit components per pixel ...
+ * // ... replace '0' with '1'..'4' to force that many components per pixel
+ * // ... but 'n' will always be the number that it would have been if you said 0
+ * stbi_image_free(data)stb_image supports loading HDR images in general, and currently the Radiance .HDR file format specifically. You can still load any file through the + * existing interface; if you attempt to load an HDR file, it will be automatically remapped to LDR, assuming gamma 2.2 and an arbitrary scale factor + * defaulting to 1; both of these constants can be reconfigured through this interface:
+ * + *
+ * stbi_hdr_to_ldr_gamma(2.2f);
+ * stbi_hdr_to_ldr_scale(1.0f);(note, do not use inverse constants; stbi_image will invert them appropriately).
+ * + *Additionally, there is a new, parallel interface for loading files as (linear) floats to preserve the full dynamic range:
+ * + *
+ * float *data = stbi_loadf(filename, &x, &y, &n, 0);If you load LDR images through this interface, those images will be promoted to floating point values, run through the inverse of constants + * corresponding to the above:
+ * + *
+ * stbi_ldr_to_hdr_scale(1.0f);
+ * stbi_ldr_to_hdr_gamma(2.2f);Finally, given a filename (or an open file or memory block) containing image data, you can query for the "most appropriate" interface to use (that is, + * whether the image is HDR or not), using:
+ * + *
+ * stbi_is_hdr(char *filename);By default we convert iphone-formatted PNGs back to RGB, even though they are internally encoded differently. You can disable this conversion by + * calling {@link #stbi_convert_iphone_png_to_rgb convert_iphone_png_to_rgb}(0), in which case you will always just get the native iphone "format" through (which is BGR stored in RGB).
+ * + *Call {@link #stbi_set_unpremultiply_on_load set_unpremultiply_on_load}(1) as well to force a divide per pixel to remove any premultiplied alpha *only* if the image file explicitly says + * there's premultiplied data (currently only happens in iPhone images, and only if iPhone convert-to-rgb processing is on).
+ */ +public class STBImage { + + /** + * Component count. + * + *The return value from an image loader is an {@code 'unsigned char *'} which points to the pixel data, or {@code NULL} on an allocation failure or if the image + * is corrupt or invalid. The pixel data consists of {@code *y} scanlines of {@code *x} pixels, with each pixel consisting of N interleaved 8-bit + * components; the first pixel pointed to is top-left-most in the image. There is no padding between image scanlines or between pixels, regardless of + * format. The number of components N is {@code 'desired_channels'} if {@code desired_channels} is non-zero, or {@code *channels_in_file} otherwise. If + * {@code desired_channels} is non-zero, {@code *channels_in_file} has the number of components that would have been output otherwise. E.g. if you + * set {@code desired_channels} to 4, you will always get RGBA output, but you can check {@code *channels_in_file} to see if it's trivially opaque because + * e.g. there were only 3 channels in the source image.
+ * + *An output image with N components has the following components interleaved in this order in each pixel:
+ * + *
+ * N=#channels_in_file components
+ * 1 grey
+ * 2 grey, alpha
+ * 3 red, green, blue
+ * 4 red, green, blue, alphaIf image loading fails for any reason, the return value will be {@code NULL}, and {@code *x}, {@code *y}, {@code *channels_in_file} will be unchanged. The + * function {@link #stbi_failure_reason failure_reason} can be queried for an extremely brief, end-user unfriendly explanation of why the load failed.
+ * + *Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
+ * + * @param filename the file name + * @param x outputs the image width in pixels + * @param y outputs the image height in pixels + * @param channels_in_file outputs number of components in image + * @param desired_channels 0 or 1..4 to force that many components per pixel. One of:| 0 | 1 | 2 | 3 | 4 |
The return value from an image loader is an {@code 'unsigned char *'} which points to the pixel data, or {@code NULL} on an allocation failure or if the image + * is corrupt or invalid. The pixel data consists of {@code *y} scanlines of {@code *x} pixels, with each pixel consisting of N interleaved 8-bit + * components; the first pixel pointed to is top-left-most in the image. There is no padding between image scanlines or between pixels, regardless of + * format. The number of components N is {@code 'desired_channels'} if {@code desired_channels} is non-zero, or {@code *channels_in_file} otherwise. If + * {@code desired_channels} is non-zero, {@code *channels_in_file} has the number of components that would have been output otherwise. E.g. if you + * set {@code desired_channels} to 4, you will always get RGBA output, but you can check {@code *channels_in_file} to see if it's trivially opaque because + * e.g. there were only 3 channels in the source image.
+ * + *An output image with N components has the following components interleaved in this order in each pixel:
+ * + *
+ * N=#channels_in_file components
+ * 1 grey
+ * 2 grey, alpha
+ * 3 red, green, blue
+ * 4 red, green, blue, alphaIf image loading fails for any reason, the return value will be {@code NULL}, and {@code *x}, {@code *y}, {@code *channels_in_file} will be unchanged. The + * function {@link #stbi_failure_reason failure_reason} can be queried for an extremely brief, end-user unfriendly explanation of why the load failed.
+ * + *Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
+ * + * @param filename the file name + * @param x outputs the image width in pixels + * @param y outputs the image height in pixels + * @param channels_in_file outputs number of components in image + * @param desired_channels 0 or 1..4 to force that many components per pixel. One of:| 0 | 1 | 2 | 3 | 4 |
| 0 | 1 | 2 | 3 | 4 |
I/O callbacks allow you to read from arbitrary sources, like packaged files or some other source. Data read from callbacks are processed through a + * small internal buffer (currently 128 bytes) to try to reduce overhead.
+ * + *The three functions you must define are "read" (reads some bytes of data), "skip" (skips some bytes of data), "eof" (reports if the stream is at the + * end).
+ * + * @param clbk an {@link STBIIOCallbacks} struct + * @param user a pointer to user data + * @param x outputs the image width in pixels + * @param y outputs the image height in pixels + * @param channels_in_file outputs number of components in image + * @param desired_channels 0 or 1..4 to force that many components per pixel. One of:| 0 | 1 | 2 | 3 | 4 |
| 0 | 1 | 2 | 3 | 4 |
| 0 | 1 | 2 | 3 | 4 |
| 0 | 1 | 2 | 3 | 4 |
| 0 | 1 | 2 | 3 | 4 |
| 0 | 1 | 2 | 3 | 4 |
| 0 | 1 | 2 | 3 | 4 |
| 0 | 1 | 2 | 3 | 4 |
| 0 | 1 | 2 | 3 | 4 |
| 0 | 1 | 2 | 3 | 4 |
Written with emphasis on usability, portability, and efficiency. (No SIMD or threads, so it be easily outperformed by libs that use those.) Only + * scaling and translation is supported, no rotations or shears. Easy API downsamples w/Mitchell filter, upsamples w/cubic interpolation.
+ * + *
+ * stbir_resize_uint8( input_pixels , in_w , in_h , 0,
+ * output_pixels, out_w, out_h, 0, num_channels)
+ * stbir_resize_float(...)
+ * stbir_resize_uint8_srgb( input_pixels , in_w , in_h , 0,
+ * output_pixels, out_w, out_h, 0,
+ * num_channels , alpha_chan , 0)
+ * stbir_resize_uint8_srgb_edgemode(
+ * input_pixels , in_w , in_h , 0,
+ * output_pixels, out_w, out_h, 0,
+ * num_channels , alpha_chan , 0, STBIR_EDGE_CLAMP)
+ * // WRAP/REFLECT/ZEROMost of the resizing functions provide the ability to control how the alpha channel of an image is processed. The important things to know about this:
+ * + *This function uses the default resampling filter defined at compile time. For a different filter, use the medium-complexity API.
+ * + * @param input_pixels the source image data + * @param input_w the source image width + * @param input_h the source image height + * @param input_stride_in_bytes the offset between successive rows of the source image data in memory, in bytes. You can specify 0 to mean packed continuously in memory + * @param output_pixels returns the scaled image data + * @param output_w the resized image width + * @param output_h the resized image height + * @param output_stride_in_bytes the offset between successive rows of the resized image data in memory, in bytes. You can specify 0 to mean packed continuously in memory + * @param num_channels the number of channels in the image (e.g. RGB=3, RGBA=4) + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbir_resize_uint8(@NativeType("unsigned char const *") ByteBuffer input_pixels, int input_w, int input_h, int input_stride_in_bytes, @NativeType("unsigned char *") ByteBuffer output_pixels, int output_w, int output_h, int output_stride_in_bytes, int num_channels) { + if (CHECKS) { + check(input_pixels, input_h * (input_stride_in_bytes == 0 ? input_w * num_channels : input_stride_in_bytes)); + check(output_pixels, output_h * (output_stride_in_bytes == 0 ? output_w * num_channels : output_stride_in_bytes)); + } + return nstbir_resize_uint8(memAddress(input_pixels), input_w, input_h, input_stride_in_bytes, memAddress(output_pixels), output_w, output_h, output_stride_in_bytes, num_channels) != 0; + } + + // --- [ stbir_resize_float ] --- + + /** Unsafe version of: {@link #stbir_resize_float resize_float} */ + public static native int nstbir_resize_float(long input_pixels, int input_w, int input_h, int input_stride_in_bytes, long output_pixels, int output_w, int output_h, int output_stride_in_bytes, int num_channels); + + /** + * Float version of {@link #stbir_resize_uint8 resize_uint8}. + * + * @param input_pixels the source image data + * @param input_w the source image width + * @param input_h the source image height + * @param input_stride_in_bytes the offset between successive rows of the source image data in memory, in bytes. You can specify 0 to mean packed continuously in memory + * @param output_pixels returns the scaled image data + * @param output_w the resized image width + * @param output_h the resized image height + * @param output_stride_in_bytes the offset between successive rows of the resized image data in memory, in bytes. You can specify 0 to mean packed continuously in memory + * @param num_channels the number of channels in the image (e.g. RGB=3, RGBA=4) + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbir_resize_float(@NativeType("float const *") FloatBuffer input_pixels, int input_w, int input_h, int input_stride_in_bytes, @NativeType("float *") FloatBuffer output_pixels, int output_w, int output_h, int output_stride_in_bytes, int num_channels) { + if (CHECKS) { + check(input_pixels, input_h * (input_stride_in_bytes == 0 ? input_w * num_channels : (input_stride_in_bytes >> 2))); + check(output_pixels, output_h * (output_stride_in_bytes == 0 ? output_w * num_channels : (output_stride_in_bytes >> 2))); + } + return nstbir_resize_float(memAddress(input_pixels), input_w, input_h, input_stride_in_bytes, memAddress(output_pixels), output_w, output_h, output_stride_in_bytes, num_channels) != 0; + } + + // --- [ stbir_resize_uint8_srgb ] --- + + /** Unsafe version of: {@link #stbir_resize_uint8_srgb resize_uint8_srgb} */ + public static native int nstbir_resize_uint8_srgb(long input_pixels, int input_w, int input_h, int input_stride_in_bytes, long output_pixels, int output_w, int output_h, int output_stride_in_bytes, int num_channels, int alpha_channel, int flags); + + /** + * Easy-to-use API for resizing images. + * + *This function uses the default resampling filter defined at compile time. For a different filter, use the medium-complexity API.
+ * + * @param input_pixels the source image data + * @param input_w the source image width + * @param input_h the source image height + * @param input_stride_in_bytes the offset between successive rows of the source image data in memory, in bytes. You can specify 0 to mean packed continuously in memory + * @param output_pixels returns the scaled image data + * @param output_w the resized image width + * @param output_h the resized image height + * @param output_stride_in_bytes the offset between successive rows of the resized image data in memory, in bytes. You can specify 0 to mean packed continuously in memory + * @param num_channels the number of channels in the image (e.g. RGB=3, RGBA=4) + * @param alpha_channel the alpha channel index, or {@link #STBIR_ALPHA_CHANNEL_NONE ALPHA_CHANNEL_NONE} if there is no alpha channel + * @param flags the alpha channel flags. 0 will propably do the right thing if you're not sure what the flags mean. One of:| {@link #STBIR_FLAG_ALPHA_PREMULTIPLIED FLAG_ALPHA_PREMULTIPLIED} | {@link #STBIR_FLAG_ALPHA_USES_COLORSPACE FLAG_ALPHA_USES_COLORSPACE} |
| {@link #STBIR_FLAG_ALPHA_PREMULTIPLIED FLAG_ALPHA_PREMULTIPLIED} | {@link #STBIR_FLAG_ALPHA_USES_COLORSPACE FLAG_ALPHA_USES_COLORSPACE} |
| {@link #STBIR_EDGE_CLAMP EDGE_CLAMP} | {@link #STBIR_EDGE_REFLECT EDGE_REFLECT} | {@link #STBIR_EDGE_WRAP EDGE_WRAP} | {@link #STBIR_EDGE_ZERO EDGE_ZERO} |
| {@link #STBIR_FLAG_ALPHA_PREMULTIPLIED FLAG_ALPHA_PREMULTIPLIED} | {@link #STBIR_FLAG_ALPHA_USES_COLORSPACE FLAG_ALPHA_USES_COLORSPACE} |
| {@link #STBIR_EDGE_CLAMP EDGE_CLAMP} | {@link #STBIR_EDGE_REFLECT EDGE_REFLECT} | {@link #STBIR_EDGE_WRAP EDGE_WRAP} | {@link #STBIR_EDGE_ZERO EDGE_ZERO} |
| {@link #STBIR_FILTER_DEFAULT FILTER_DEFAULT} | {@link #STBIR_FILTER_BOX FILTER_BOX} | {@link #STBIR_FILTER_TRIANGLE FILTER_TRIANGLE} | {@link #STBIR_FILTER_CUBICBSPLINE FILTER_CUBICBSPLINE} | {@link #STBIR_FILTER_CATMULLROM FILTER_CATMULLROM} |
| {@link #STBIR_FILTER_MITCHELL FILTER_MITCHELL} |
| {@link #STBIR_COLORSPACE_LINEAR COLORSPACE_LINEAR} | {@link #STBIR_COLORSPACE_SRGB COLORSPACE_SRGB} |
| {@link #STBIR_FLAG_ALPHA_PREMULTIPLIED FLAG_ALPHA_PREMULTIPLIED} | {@link #STBIR_FLAG_ALPHA_USES_COLORSPACE FLAG_ALPHA_USES_COLORSPACE} |
| {@link #STBIR_EDGE_CLAMP EDGE_CLAMP} | {@link #STBIR_EDGE_REFLECT EDGE_REFLECT} | {@link #STBIR_EDGE_WRAP EDGE_WRAP} | {@link #STBIR_EDGE_ZERO EDGE_ZERO} |
| {@link #STBIR_FILTER_DEFAULT FILTER_DEFAULT} | {@link #STBIR_FILTER_BOX FILTER_BOX} | {@link #STBIR_FILTER_TRIANGLE FILTER_TRIANGLE} | {@link #STBIR_FILTER_CUBICBSPLINE FILTER_CUBICBSPLINE} | {@link #STBIR_FILTER_CATMULLROM FILTER_CATMULLROM} |
| {@link #STBIR_FILTER_MITCHELL FILTER_MITCHELL} |
| {@link #STBIR_COLORSPACE_LINEAR COLORSPACE_LINEAR} | {@link #STBIR_COLORSPACE_SRGB COLORSPACE_SRGB} |
| {@link #STBIR_FLAG_ALPHA_PREMULTIPLIED FLAG_ALPHA_PREMULTIPLIED} | {@link #STBIR_FLAG_ALPHA_USES_COLORSPACE FLAG_ALPHA_USES_COLORSPACE} |
| {@link #STBIR_EDGE_CLAMP EDGE_CLAMP} | {@link #STBIR_EDGE_REFLECT EDGE_REFLECT} | {@link #STBIR_EDGE_WRAP EDGE_WRAP} | {@link #STBIR_EDGE_ZERO EDGE_ZERO} |
| {@link #STBIR_FILTER_DEFAULT FILTER_DEFAULT} | {@link #STBIR_FILTER_BOX FILTER_BOX} | {@link #STBIR_FILTER_TRIANGLE FILTER_TRIANGLE} | {@link #STBIR_FILTER_CUBICBSPLINE FILTER_CUBICBSPLINE} | {@link #STBIR_FILTER_CATMULLROM FILTER_CATMULLROM} |
| {@link #STBIR_FILTER_MITCHELL FILTER_MITCHELL} |
| {@link #STBIR_COLORSPACE_LINEAR COLORSPACE_LINEAR} | {@link #STBIR_COLORSPACE_SRGB COLORSPACE_SRGB} |
| {@link #STBIR_FLAG_ALPHA_PREMULTIPLIED FLAG_ALPHA_PREMULTIPLIED} | {@link #STBIR_FLAG_ALPHA_USES_COLORSPACE FLAG_ALPHA_USES_COLORSPACE} |
| {@link #STBIR_EDGE_CLAMP EDGE_CLAMP} | {@link #STBIR_EDGE_REFLECT EDGE_REFLECT} | {@link #STBIR_EDGE_WRAP EDGE_WRAP} | {@link #STBIR_EDGE_ZERO EDGE_ZERO} |
| {@link #STBIR_FILTER_DEFAULT FILTER_DEFAULT} | {@link #STBIR_FILTER_BOX FILTER_BOX} | {@link #STBIR_FILTER_TRIANGLE FILTER_TRIANGLE} | {@link #STBIR_FILTER_CUBICBSPLINE FILTER_CUBICBSPLINE} | {@link #STBIR_FILTER_CATMULLROM FILTER_CATMULLROM} |
| {@link #STBIR_FILTER_MITCHELL FILTER_MITCHELL} |
| {@link #STBIR_COLORSPACE_LINEAR COLORSPACE_LINEAR} | {@link #STBIR_COLORSPACE_SRGB COLORSPACE_SRGB} |
| {@link #STBIR_FLAG_ALPHA_PREMULTIPLIED FLAG_ALPHA_PREMULTIPLIED} | {@link #STBIR_FLAG_ALPHA_USES_COLORSPACE FLAG_ALPHA_USES_COLORSPACE} |
| {@link #STBIR_EDGE_CLAMP EDGE_CLAMP} | {@link #STBIR_EDGE_REFLECT EDGE_REFLECT} | {@link #STBIR_EDGE_WRAP EDGE_WRAP} | {@link #STBIR_EDGE_ZERO EDGE_ZERO} |
| {@link #STBIR_FILTER_DEFAULT FILTER_DEFAULT} | {@link #STBIR_FILTER_BOX FILTER_BOX} | {@link #STBIR_FILTER_TRIANGLE FILTER_TRIANGLE} | {@link #STBIR_FILTER_CUBICBSPLINE FILTER_CUBICBSPLINE} | {@link #STBIR_FILTER_CATMULLROM FILTER_CATMULLROM} |
| {@link #STBIR_FILTER_MITCHELL FILTER_MITCHELL} |
| {@link #STBIR_COLORSPACE_LINEAR COLORSPACE_LINEAR} | {@link #STBIR_COLORSPACE_SRGB COLORSPACE_SRGB} |
| {@link #STBIR_FLAG_ALPHA_PREMULTIPLIED FLAG_ALPHA_PREMULTIPLIED} | {@link #STBIR_FLAG_ALPHA_USES_COLORSPACE FLAG_ALPHA_USES_COLORSPACE} |
| {@link #STBIR_EDGE_CLAMP EDGE_CLAMP} | {@link #STBIR_EDGE_REFLECT EDGE_REFLECT} | {@link #STBIR_EDGE_WRAP EDGE_WRAP} | {@link #STBIR_EDGE_ZERO EDGE_ZERO} |
| {@link #STBIR_FILTER_DEFAULT FILTER_DEFAULT} | {@link #STBIR_FILTER_BOX FILTER_BOX} | {@link #STBIR_FILTER_TRIANGLE FILTER_TRIANGLE} | {@link #STBIR_FILTER_CUBICBSPLINE FILTER_CUBICBSPLINE} | {@link #STBIR_FILTER_CATMULLROM FILTER_CATMULLROM} |
| {@link #STBIR_FILTER_MITCHELL FILTER_MITCHELL} |
| {@link #STBIR_COLORSPACE_LINEAR COLORSPACE_LINEAR} | {@link #STBIR_COLORSPACE_SRGB COLORSPACE_SRGB} |
| {@link #STBIR_TYPE_UINT8 TYPE_UINT8} | {@link #STBIR_TYPE_UINT16 TYPE_UINT16} | {@link #STBIR_TYPE_UINT32 TYPE_UINT32} | {@link #STBIR_TYPE_FLOAT TYPE_FLOAT} |
| {@link #STBIR_FLAG_ALPHA_PREMULTIPLIED FLAG_ALPHA_PREMULTIPLIED} | {@link #STBIR_FLAG_ALPHA_USES_COLORSPACE FLAG_ALPHA_USES_COLORSPACE} |
| {@link #STBIR_COLORSPACE_LINEAR COLORSPACE_LINEAR} | {@link #STBIR_COLORSPACE_SRGB COLORSPACE_SRGB} |
| {@link #STBIR_TYPE_UINT8 TYPE_UINT8} | {@link #STBIR_TYPE_UINT16 TYPE_UINT16} | {@link #STBIR_TYPE_UINT32 TYPE_UINT32} | {@link #STBIR_TYPE_FLOAT TYPE_FLOAT} |
| {@link #STBIR_FLAG_ALPHA_PREMULTIPLIED FLAG_ALPHA_PREMULTIPLIED} | {@link #STBIR_FLAG_ALPHA_USES_COLORSPACE FLAG_ALPHA_USES_COLORSPACE} |
| {@link #STBIR_COLORSPACE_LINEAR COLORSPACE_LINEAR} | {@link #STBIR_COLORSPACE_SRGB COLORSPACE_SRGB} |
| {@link #STBIR_TYPE_UINT8 TYPE_UINT8} | {@link #STBIR_TYPE_UINT16 TYPE_UINT16} | {@link #STBIR_TYPE_UINT32 TYPE_UINT32} | {@link #STBIR_TYPE_FLOAT TYPE_FLOAT} |
| {@link #STBIR_FLAG_ALPHA_PREMULTIPLIED FLAG_ALPHA_PREMULTIPLIED} | {@link #STBIR_FLAG_ALPHA_USES_COLORSPACE FLAG_ALPHA_USES_COLORSPACE} |
| {@link #STBIR_COLORSPACE_LINEAR COLORSPACE_LINEAR} | {@link #STBIR_COLORSPACE_SRGB COLORSPACE_SRGB} |
| {@link #STBIR_TYPE_UINT8 TYPE_UINT8} | {@link #STBIR_TYPE_UINT16 TYPE_UINT16} | {@link #STBIR_TYPE_UINT32 TYPE_UINT32} | {@link #STBIR_TYPE_FLOAT TYPE_FLOAT} |
| {@link #STBIR_FLAG_ALPHA_PREMULTIPLIED FLAG_ALPHA_PREMULTIPLIED} | {@link #STBIR_FLAG_ALPHA_USES_COLORSPACE FLAG_ALPHA_USES_COLORSPACE} |
| {@link #STBIR_COLORSPACE_LINEAR COLORSPACE_LINEAR} | {@link #STBIR_COLORSPACE_SRGB COLORSPACE_SRGB} |
| {@link #STBIR_TYPE_UINT8 TYPE_UINT8} | {@link #STBIR_TYPE_UINT16 TYPE_UINT16} | {@link #STBIR_TYPE_UINT32 TYPE_UINT32} | {@link #STBIR_TYPE_FLOAT TYPE_FLOAT} |
| {@link #STBIR_FLAG_ALPHA_PREMULTIPLIED FLAG_ALPHA_PREMULTIPLIED} | {@link #STBIR_FLAG_ALPHA_USES_COLORSPACE FLAG_ALPHA_USES_COLORSPACE} |
| {@link #STBIR_COLORSPACE_LINEAR COLORSPACE_LINEAR} | {@link #STBIR_COLORSPACE_SRGB COLORSPACE_SRGB} |
| {@link #STBIR_TYPE_UINT8 TYPE_UINT8} | {@link #STBIR_TYPE_UINT16 TYPE_UINT16} | {@link #STBIR_TYPE_UINT32 TYPE_UINT32} | {@link #STBIR_TYPE_FLOAT TYPE_FLOAT} |
| {@link #STBIR_FLAG_ALPHA_PREMULTIPLIED FLAG_ALPHA_PREMULTIPLIED} | {@link #STBIR_FLAG_ALPHA_USES_COLORSPACE FLAG_ALPHA_USES_COLORSPACE} |
| {@link #STBIR_COLORSPACE_LINEAR COLORSPACE_LINEAR} | {@link #STBIR_COLORSPACE_SRGB COLORSPACE_SRGB} |
This header file is a library for writing images to C stdio.
+ * + *The PNG output is not optimal; it is 20-50% larger than the file written by a decent optimizing implementation; though providing a custom zlib compress + * function (see {@link #stbi_zlib_compress zlib_compress}) can mitigate that. This library is designed for source code compactness and simplicity, not optimal image + * file size or run-time performance.
+ * + *There are five functions, one for each image file format:
+ * + *
+ * int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
+ * int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
+ * int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
+ * int stbi_write_hdr(char const *filename, int w, int h, int comp, const void *data);
+ * int stbi_write_jpg(char const *filename, int w, int h, int comp, const float *data, int quality);
+ *
+ * void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data verticallyThere are also five equivalent functions that use an arbitrary write function. You are expected to open/close your file-equivalent before and after + * calling these:
+ * + *
+ * int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes);
+ * int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);
+ * int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);
+ * int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);
+ * int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality);where the callback is:
+ * + *
+ * void stbi_write_func(void *context, void *data, int size);You can configure it with these global variables:
+ * + *
+ * int stbi_write_tga_with_rle; // defaults to true; set to 0 to disable RLE
+ * int stbi_write_png_compression_level; // defaults to 8; set to higher for more compression
+ * int stbi_write_force_png_filter; // defaults to -1; set to 0..5 to force a filter modeThe functions create an image file defined by the parameters. The image is a rectangle of pixels stored from left-to-right, top-to-bottom. Each pixel + * contains {@code comp} channels of data stored interleaved with 8-bits per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is monochrome + * color.) The rectangle is {@code w} pixels wide and {@code h} pixels tall. The {@code *data} pointer points to the first byte of the top-left-most + * pixel.
+ */ +public class STBImageWrite { + + static { LibSTB.initialize(); } + + protected STBImageWrite() { + throw new UnsupportedOperationException(); + } + + // --- [ stbi_write_png ] --- + + /** Unsafe version of: {@link #stbi_write_png write_png} */ + public static native int nstbi_write_png(long filename, int w, int h, int comp, long data, int stride_in_bytes); + + /** + * Writes a PNR image file. + * + *PNG creates output files with the same number of components as the input.
+ * + *PNG supports writing rectangles of data even when the bytes storing rows of data are not consecutive in memory (e.g. sub-rectangles of a larger image), + * by supplying the stride between the beginning of adjacent rows. The other formats do not. (Thus you cannot write a native-format BMP through the BMP + * writer, both because it is in BGR order and because it may have padding at the end of the line.)
+ * + *PNG allows you to set the deflate compression level by setting the global variable {@link #stbi_write_png_compression_level write_png_compression_level} (it defaults to 8).
+ * + * @param filename the image file path + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * @param stride_in_bytes the distance in bytes from the first byte of a row of pixels to the first byte of the next row of pixels + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbi_write_png(@NativeType("char const *") ByteBuffer filename, int w, int h, int comp, @NativeType("void const *") ByteBuffer data, int stride_in_bytes) { + if (CHECKS) { + checkNT1(filename); + check(data, (stride_in_bytes != 0 ? stride_in_bytes : w * comp) * h); + } + return nstbi_write_png(memAddress(filename), w, h, comp, memAddress(data), stride_in_bytes) != 0; + } + + /** + * Writes a PNR image file. + * + *PNG creates output files with the same number of components as the input.
+ * + *PNG supports writing rectangles of data even when the bytes storing rows of data are not consecutive in memory (e.g. sub-rectangles of a larger image), + * by supplying the stride between the beginning of adjacent rows. The other formats do not. (Thus you cannot write a native-format BMP through the BMP + * writer, both because it is in BGR order and because it may have padding at the end of the line.)
+ * + *PNG allows you to set the deflate compression level by setting the global variable {@link #stbi_write_png_compression_level write_png_compression_level} (it defaults to 8).
+ * + * @param filename the image file path + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * @param stride_in_bytes the distance in bytes from the first byte of a row of pixels to the first byte of the next row of pixels + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbi_write_png(@NativeType("char const *") CharSequence filename, int w, int h, int comp, @NativeType("void const *") ByteBuffer data, int stride_in_bytes) { + if (CHECKS) { + check(data, (stride_in_bytes != 0 ? stride_in_bytes : w * comp) * h); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8(filename, true); + long filenameEncoded = stack.getPointerAddress(); + return nstbi_write_png(filenameEncoded, w, h, comp, memAddress(data), stride_in_bytes) != 0; + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ stbi_write_png_compression_level ] --- + + private static native long nstbi_write_png_compression_level(); + + @NativeType("int *") + private static IntBuffer stbi_write_png_compression_level() { + long __result = nstbi_write_png_compression_level(); + return memIntBuffer(__result, 1); + } + + /** Returns the address of the global variable {@code stbi_write_png_compression_level}. */ + public static final IntBuffer stbi_write_png_compression_level = stbi_write_png_compression_level(); + + // --- [ stbi_write_force_png_filter ] --- + + private static native long nstbi_write_force_png_filter(); + + @NativeType("int *") + private static IntBuffer stbi_write_force_png_filter() { + long __result = nstbi_write_force_png_filter(); + return memIntBuffer(__result, 1); + } + + /** Returns the address of the global variable {@code stbi_write_force_png_filter}. */ + public static final IntBuffer stbi_write_force_png_filter = stbi_write_force_png_filter(); + + // --- [ stbi_zlib_compress ] --- + + private static native long nstbi_zlib_compress(); + + @NativeType("unsigned char * (*) (unsigned char *, int, int *, int) *") + private static PointerBuffer stbi_zlib_compress() { + long __result = nstbi_zlib_compress(); + return memPointerBuffer(__result, 1); + } + + /** + * Returns the address of the global variable {@code stbi_zlib_compress}. + * + *The address of an {@link STBIZlibCompress} instance may be set to this variable, in order to override the Zlib compression implementation.
+ */ + public static final PointerBuffer stbi_zlib_compress = stbi_zlib_compress(); + + // --- [ stbi_write_bmp ] --- + + /** Unsafe version of: {@link #stbi_write_bmp write_bmp} */ + public static native int nstbi_write_bmp(long filename, int w, int h, int comp, long data); + + /** + * Writes a BMP image file. + * + *The BMP format expands Y to RGB in the file format and does not output alpha.
+ * + * @param filename the image file path + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbi_write_bmp(@NativeType("char const *") ByteBuffer filename, int w, int h, int comp, @NativeType("void const *") ByteBuffer data) { + if (CHECKS) { + checkNT1(filename); + check(data, w * h * comp); + } + return nstbi_write_bmp(memAddress(filename), w, h, comp, memAddress(data)) != 0; + } + + /** + * Writes a BMP image file. + * + *The BMP format expands Y to RGB in the file format and does not output alpha.
+ * + * @param filename the image file path + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbi_write_bmp(@NativeType("char const *") CharSequence filename, int w, int h, int comp, @NativeType("void const *") ByteBuffer data) { + if (CHECKS) { + check(data, w * h * comp); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8(filename, true); + long filenameEncoded = stack.getPointerAddress(); + return nstbi_write_bmp(filenameEncoded, w, h, comp, memAddress(data)) != 0; + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ stbi_write_tga ] --- + + /** Unsafe version of: {@link #stbi_write_tga write_tga} */ + public static native int nstbi_write_tga(long filename, int w, int h, int comp, long data); + + /** + * Writes a TGA image file. + * + *TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed data, set the global variable {@code stbi_write_tga_with_rle} to 0. The variable + * can be accessed with {@link #stbi_write_tga_with_rle write_tga_with_rle}.
+ * + * @param filename the image file path + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbi_write_tga(@NativeType("char const *") ByteBuffer filename, int w, int h, int comp, @NativeType("void const *") ByteBuffer data) { + if (CHECKS) { + checkNT1(filename); + check(data, w * h * comp); + } + return nstbi_write_tga(memAddress(filename), w, h, comp, memAddress(data)) != 0; + } + + /** + * Writes a TGA image file. + * + *TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed data, set the global variable {@code stbi_write_tga_with_rle} to 0. The variable + * can be accessed with {@link #stbi_write_tga_with_rle write_tga_with_rle}.
+ * + * @param filename the image file path + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbi_write_tga(@NativeType("char const *") CharSequence filename, int w, int h, int comp, @NativeType("void const *") ByteBuffer data) { + if (CHECKS) { + check(data, w * h * comp); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8(filename, true); + long filenameEncoded = stack.getPointerAddress(); + return nstbi_write_tga(filenameEncoded, w, h, comp, memAddress(data)) != 0; + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ stbi_write_tga_with_rle ] --- + + private static native long nstbi_write_tga_with_rle(); + + @NativeType("int *") + private static IntBuffer stbi_write_tga_with_rle() { + long __result = nstbi_write_tga_with_rle(); + return memIntBuffer(__result, 1); + } + + /** Returns the address of the global variable {@code stbi_write_tga_with_rle}. */ + public static final IntBuffer stbi_write_tga_with_rle = stbi_write_tga_with_rle(); + + // --- [ stbi_write_hdr ] --- + + /** Unsafe version of: {@link #stbi_write_hdr write_hdr} */ + public static native int nstbi_write_hdr(long filename, int w, int h, int comp, long data); + + /** + * Writes an HDR image file. + * + *HDR expects linear float data. Since the format is always 32-bit rgb(e) data, alpha (if provided) is discarded, and for monochrome data it is + * replicated across all three channels.
+ * + * @param filename the image file path + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbi_write_hdr(@NativeType("char const *") ByteBuffer filename, int w, int h, int comp, @NativeType("float const *") FloatBuffer data) { + if (CHECKS) { + checkNT1(filename); + check(data, w * h * comp); + } + return nstbi_write_hdr(memAddress(filename), w, h, comp, memAddress(data)) != 0; + } + + /** + * Writes an HDR image file. + * + *HDR expects linear float data. Since the format is always 32-bit rgb(e) data, alpha (if provided) is discarded, and for monochrome data it is + * replicated across all three channels.
+ * + * @param filename the image file path + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbi_write_hdr(@NativeType("char const *") CharSequence filename, int w, int h, int comp, @NativeType("float const *") FloatBuffer data) { + if (CHECKS) { + check(data, w * h * comp); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8(filename, true); + long filenameEncoded = stack.getPointerAddress(); + return nstbi_write_hdr(filenameEncoded, w, h, comp, memAddress(data)) != 0; + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ stbi_write_jpg ] --- + + /** Unsafe version of: {@link #stbi_write_jpg write_jpg} */ + public static native int nstbi_write_jpg(long filename, int w, int h, int comp, long data, int quality); + + /** + * Writes a JPEG image file. + * + *JPEG does ignore alpha channels in input data; quality is between 1 and 100. Higher quality looks better but results in a bigger image. JPEG baseline + * (no JPEG progressive).
+ * + * @param filename the image file path + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * @param quality the compression quality + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbi_write_jpg(@NativeType("char const *") ByteBuffer filename, int w, int h, int comp, @NativeType("void const *") ByteBuffer data, int quality) { + if (CHECKS) { + checkNT1(filename); + check(data, w * h * comp); + } + return nstbi_write_jpg(memAddress(filename), w, h, comp, memAddress(data), quality) != 0; + } + + /** + * Writes a JPEG image file. + * + *JPEG does ignore alpha channels in input data; quality is between 1 and 100. Higher quality looks better but results in a bigger image. JPEG baseline + * (no JPEG progressive).
+ * + * @param filename the image file path + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * @param quality the compression quality + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbi_write_jpg(@NativeType("char const *") CharSequence filename, int w, int h, int comp, @NativeType("void const *") ByteBuffer data, int quality) { + if (CHECKS) { + check(data, w * h * comp); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8(filename, true); + long filenameEncoded = stack.getPointerAddress(); + return nstbi_write_jpg(filenameEncoded, w, h, comp, memAddress(data), quality) != 0; + } finally { + stack.setPointer(stackPointer); + } + } + + // --- [ stbi_write_png_to_func ] --- + + /** Unsafe version of: {@link #stbi_write_png_to_func write_png_to_func} */ + public static native int nstbi_write_png_to_func(long func, long context, int w, int h, int comp, long data, int stride_in_bytes); + + /** + * Callback version of {@link #stbi_write_png write_png}. + * + * @param func the callback function + * @param context a context that will be passed to {@code func} + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * @param stride_in_bytes the distance in bytes from the first byte of a row of pixels to the first byte of the next row of pixels + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbi_write_png_to_func(@NativeType("stbi_write_func *") STBIWriteCallbackI func, @NativeType("void *") long context, int w, int h, int comp, @NativeType("void const *") ByteBuffer data, int stride_in_bytes) { + if (CHECKS) { + check(data, (stride_in_bytes != 0 ? stride_in_bytes : w * comp) * h); + } + return nstbi_write_png_to_func(func.address(), context, w, h, comp, memAddress(data), stride_in_bytes) != 0; + } + + // --- [ stbi_write_bmp_to_func ] --- + + /** Unsafe version of: {@link #stbi_write_bmp_to_func write_bmp_to_func} */ + public static native int nstbi_write_bmp_to_func(long func, long context, int w, int h, int comp, long data); + + /** + * Callback version of {@link #stbi_write_bmp write_bmp}. + * + * @param func the callback function + * @param context a context that will be passed to {@code func} + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbi_write_bmp_to_func(@NativeType("stbi_write_func *") STBIWriteCallbackI func, @NativeType("void *") long context, int w, int h, int comp, @NativeType("void const *") ByteBuffer data) { + if (CHECKS) { + check(data, w * h * comp); + } + return nstbi_write_bmp_to_func(func.address(), context, w, h, comp, memAddress(data)) != 0; + } + + // --- [ stbi_write_tga_to_func ] --- + + /** Unsafe version of: {@link #stbi_write_tga_to_func write_tga_to_func} */ + public static native int nstbi_write_tga_to_func(long func, long context, int w, int h, int comp, long data); + + /** + * Callback version of {@link #stbi_write_tga write_tga}. + * + * @param func the callback function + * @param context a context that will be passed to {@code func} + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbi_write_tga_to_func(@NativeType("stbi_write_func *") STBIWriteCallbackI func, @NativeType("void *") long context, int w, int h, int comp, @NativeType("void const *") ByteBuffer data) { + if (CHECKS) { + check(data, w * h * comp); + } + return nstbi_write_tga_to_func(func.address(), context, w, h, comp, memAddress(data)) != 0; + } + + // --- [ stbi_write_hdr_to_func ] --- + + /** Unsafe version of: {@link #stbi_write_hdr_to_func write_hdr_to_func} */ + public static native int nstbi_write_hdr_to_func(long func, long context, int w, int h, int comp, long data); + + /** + * Callback version of {@link #stbi_write_hdr write_hdr}. + * + * @param func the callback function + * @param context a context that will be passed to {@code func} + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * + * @return 1 on success, 0 on failure + */ + @NativeType("int") + public static boolean stbi_write_hdr_to_func(@NativeType("stbi_write_func *") STBIWriteCallbackI func, @NativeType("void *") long context, int w, int h, int comp, @NativeType("float const *") FloatBuffer data) { + if (CHECKS) { + check(data, w * h * comp); + } + return nstbi_write_hdr_to_func(func.address(), context, w, h, comp, memAddress(data)) != 0; + } + + // --- [ stbi_write_jpg_to_func ] --- + + /** Unsafe version of: {@link #stbi_write_jpg_to_func write_jpg_to_func} */ + public static native int nstbi_write_jpg_to_func(long func, long context, int w, int h, int comp, long data, int quality); + + /** + * Callback version of {@link #stbi_write_jpg write_jpg}. + * + * @param func the callback function + * @param context a context that will be passed to {@code func} + * @param w the image width, in pixels + * @param h the image height, in pixels + * @param comp the number of channels in each pixel + * @param data the image data + * @param quality the compression quality + * + * @return 1 on success, 0 on failure + */ + public static int stbi_write_jpg_to_func(@NativeType("stbi_write_func *") STBIWriteCallbackI func, @NativeType("void *") long context, int w, int h, int comp, @NativeType("void const *") ByteBuffer data, int quality) { + if (CHECKS) { + check(data, w * h * comp); + } + return nstbi_write_jpg_to_func(func.address(), context, w, h, comp, memAddress(data), quality); + } + + // --- [ stbi_flip_vertically_on_write ] --- + + /** Unsafe version of: {@link #stbi_flip_vertically_on_write flip_vertically_on_write} */ + public static native void nstbi_flip_vertically_on_write(int flip_boolean); + + /** + * Configures if the written image should flipped vertically. + * + * @param flip_boolean true to flip data vertically + */ + public static void stbi_flip_vertically_on_write(@NativeType("int") boolean flip_boolean) { + nstbi_flip_vertically_on_write(flip_boolean ? 1 : 0); + } + + /** Array version of: {@link #nstbi_write_hdr} */ + public static native int nstbi_write_hdr(long filename, int w, int h, int comp, float[] data); + + /** Array version of: {@link #stbi_write_hdr write_hdr} */ + @NativeType("int") + public static boolean stbi_write_hdr(@NativeType("char const *") ByteBuffer filename, int w, int h, int comp, @NativeType("float const *") float[] data) { + if (CHECKS) { + checkNT1(filename); + check(data, w * h * comp); + } + return nstbi_write_hdr(memAddress(filename), w, h, comp, data) != 0; + } + + /** Array version of: {@link #stbi_write_hdr write_hdr} */ + @NativeType("int") + public static boolean stbi_write_hdr(@NativeType("char const *") CharSequence filename, int w, int h, int comp, @NativeType("float const *") float[] data) { + if (CHECKS) { + check(data, w * h * comp); + } + MemoryStack stack = stackGet(); int stackPointer = stack.getPointer(); + try { + stack.nUTF8(filename, true); + long filenameEncoded = stack.getPointerAddress(); + return nstbi_write_hdr(filenameEncoded, w, h, comp, data) != 0; + } finally { + stack.setPointer(stackPointer); + } + } + + /** Array version of: {@link #nstbi_write_hdr_to_func} */ + public static native int nstbi_write_hdr_to_func(long func, long context, int w, int h, int comp, float[] data); + + /** Array version of: {@link #stbi_write_hdr_to_func write_hdr_to_func} */ + @NativeType("int") + public static boolean stbi_write_hdr_to_func(@NativeType("stbi_write_func *") STBIWriteCallbackI func, @NativeType("void *") long context, int w, int h, int comp, @NativeType("float const *") float[] data) { + if (CHECKS) { + check(data, w * h * comp); + } + return nstbi_write_hdr_to_func(func.address(), context, w, h, comp, data) != 0; + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBPerlin.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBPerlin.java new file mode 100644 index 00000000..399d0fae --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBPerlin.java @@ -0,0 +1,108 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import org.lwjgl.system.*; + + +/** + * Native bindings to stb_perlin.h from the stb library. + * + *Revised Perlin noise (3D input, 1D output).
+ */ +public class STBPerlin { + + static { LibSTB.initialize(); } + + protected STBPerlin() { + throw new UnsupportedOperationException(); + } + + // --- [ stb_perlin_noise3 ] --- + + /** + * Computes a random value at the coordinate (x,y,z). + * + *Adjacent random values are continuous but the noise fluctuates its randomness with period 1, i.e. takes on wholly unrelated values at integer points. + * Specifically, this implements Ken Perlin's revised noise function from 2002.
+ * + *The "wrap" parameters can be used to create wraparound noise that wraps at powers of two. The numbers MUST be powers of two. Specify 0 to mean "don't + * care". (The noise always wraps every 256 due details of the implementation, even if you ask for larger or no wrapping.)
+ * + * @param x the x coordinate + * @param y the y coordinate + * @param z the z coordinate + * @param x_wrap 0, or a power of two value that specifies the x wraparound coordinate + * @param y_wrap 0, or a power of two value that specifies the y wraparound coordinate + * @param z_wrap 0, or a power of two value that specifies the z wraparound coordinate + */ + public static native float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap); + + // --- [ stb_perlin_noise3_seed ] --- + + /** + * As {@link #stb_perlin_noise3 perlin_noise3}, but {@code seed} selects from multiple different variations of the noise function. + * + *The current implementation only uses the bottom 8 bits of {@code seed}, but possibly in the future more bits will be used.
+ * + * @param x the x coordinate + * @param y the y coordinate + * @param z the z coordinate + * @param x_wrap 0, or a power of two value that specifies the x wraparound coordinate + * @param y_wrap 0, or a power of two value that specifies the y wraparound coordinate + * @param z_wrap 0, or a power of two value that specifies the z wraparound coordinate + * @param seed selects from multiple different variations of the noise function + */ + public static native float stb_perlin_noise3_seed(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, int seed); + + // --- [ stb_perlin_ridge_noise3 ] --- + + /** + * Computes ridged noise. Calls {@link #stb_perlin_noise3 perlin_noise3} {@code octaves} times, so this parameter will affect runtime. + * + * @param x the x coordinate + * @param y the y coordinate + * @param z the z coordinate + * @param lacunarity spacing between successive octaves (use exactly 2.0 for wrapping output) + * @param gain relative weighting applied to each successive octave + * @param offset used to invert the ridges, may need to be larger, not sure + * @param octaves number of "octaves" of {@code noise3()} to sum + */ + public static native float stb_perlin_ridge_noise3(float x, float y, float z, float lacunarity, float gain, float offset, int octaves); + + // --- [ stb_perlin_fbm_noise3 ] --- + + /** + * Computes Fractal Brownian Motion noise. Calls {@link #stb_perlin_noise3 perlin_noise3} {@code octaves} times, so this parameter will affect runtime. + * + * @param x the x coordinate + * @param y the y coordinate + * @param z the z coordinate + * @param lacunarity spacing between successive octaves (use exactly 2.0 for wrapping output) + * @param gain relative weighting applied to each successive octave + * @param octaves number of "octaves" of {@code noise3()} to sum + */ + public static native float stb_perlin_fbm_noise3(float x, float y, float z, float lacunarity, float gain, int octaves); + + // --- [ stb_perlin_turbulence_noise3 ] --- + + /** + * Computes turbulence noise. Calls {@link #stb_perlin_noise3 perlin_noise3} {@code octaves} times, so this parameter will affect runtime. + * + * @param x the x coordinate + * @param y the y coordinate + * @param z the z coordinate + * @param lacunarity spacing between successive octaves (use exactly 2.0 for wrapping output) + * @param gain relative weighting applied to each successive octave + * @param octaves number of "octaves" of {@code noise3()} to sum + */ + public static native float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves); + + // --- [ stb_perlin_noise3_wrap_nonpow2 ] --- + + public static native float stb_perlin_noise3_wrap_nonpow2(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, @NativeType("unsigned char") byte seed); + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBRPContext.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBRPContext.java new file mode 100644 index 00000000..37e2ff76 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBRPContext.java @@ -0,0 +1,364 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.MemoryStack.*; + +/** + * The opaque {@code stbrp_context} struct. + * + *
+ * struct stbrp_context {
+ * int width;
+ * int height;
+ * int align;
+ * int init_mode;
+ * int heuristic;
+ * int num_nodes;
+ * {@link STBRPNode stbrp_node} * active_head;
+ * {@link STBRPNode stbrp_node} * free_head;
+ * {@link STBRPNode stbrp_node} extra[2];
+ * }The created instance holds a strong reference to the container object.
+ */ + public STBRPContext(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code width} field. */ + public int width() { return nwidth(address()); } + /** Returns the value of the {@code height} field. */ + public int height() { return nheight(address()); } + /** Returns the value of the {@code align} field. */ + public int align() { return nalign(address()); } + /** Returns the value of the {@code init_mode} field. */ + public int init_mode() { return ninit_mode(address()); } + /** Returns the value of the {@code heuristic} field. */ + public int heuristic() { return nheuristic(address()); } + /** Returns the value of the {@code num_nodes} field. */ + public int num_nodes() { return nnum_nodes(address()); } + /** Returns a {@link STBRPNode} view of the struct pointed to by the {@code active_head} field. */ + @Nullable + @NativeType("stbrp_node *") + public STBRPNode active_head() { return nactive_head(address()); } + /** Returns a {@link STBRPNode} view of the struct pointed to by the {@code free_head} field. */ + @Nullable + @NativeType("stbrp_node *") + public STBRPNode free_head() { return nfree_head(address()); } + /** Returns a {@link STBRPNode}.Buffer view of the {@code extra} field. */ + @NativeType("stbrp_node[2]") + public STBRPNode.Buffer extra() { return nextra(address()); } + /** Returns a {@link STBRPNode} view of the struct at the specified index of the {@code extra} field. */ + @NativeType("stbrp_node") + public STBRPNode extra(int index) { return nextra(address(), index); } + + // ----------------------------------- + + /** Returns a new {@code STBRPContext} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static STBRPContext malloc() { + return wrap(STBRPContext.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code STBRPContext} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static STBRPContext calloc() { + return wrap(STBRPContext.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code STBRPContext} instance allocated with {@link BufferUtils}. */ + public static STBRPContext create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(STBRPContext.class, memAddress(container), container); + } + + /** Returns a new {@code STBRPContext} instance for the specified memory address. */ + public static STBRPContext create(long address) { + return wrap(STBRPContext.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static STBRPContext createSafe(long address) { + return address == NULL ? null : wrap(STBRPContext.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code STBRPContext} instance allocated on the thread-local {@link MemoryStack}. */ + public static STBRPContext mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code STBRPContext} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static STBRPContext callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code STBRPContext} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static STBRPContext mallocStack(MemoryStack stack) { + return wrap(STBRPContext.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code STBRPContext} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static STBRPContext callocStack(MemoryStack stack) { + return wrap(STBRPContext.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #width}. */ + public static int nwidth(long struct) { return UNSAFE.getInt(null, struct + STBRPContext.WIDTH); } + /** Unsafe version of {@link #height}. */ + public static int nheight(long struct) { return UNSAFE.getInt(null, struct + STBRPContext.HEIGHT); } + /** Unsafe version of {@link #align}. */ + public static int nalign(long struct) { return UNSAFE.getInt(null, struct + STBRPContext.ALIGN); } + /** Unsafe version of {@link #init_mode}. */ + public static int ninit_mode(long struct) { return UNSAFE.getInt(null, struct + STBRPContext.INIT_MODE); } + /** Unsafe version of {@link #heuristic}. */ + public static int nheuristic(long struct) { return UNSAFE.getInt(null, struct + STBRPContext.HEURISTIC); } + /** Unsafe version of {@link #num_nodes}. */ + public static int nnum_nodes(long struct) { return UNSAFE.getInt(null, struct + STBRPContext.NUM_NODES); } + /** Unsafe version of {@link #active_head}. */ + @Nullable public static STBRPNode nactive_head(long struct) { return STBRPNode.createSafe(memGetAddress(struct + STBRPContext.ACTIVE_HEAD)); } + /** Unsafe version of {@link #free_head}. */ + @Nullable public static STBRPNode nfree_head(long struct) { return STBRPNode.createSafe(memGetAddress(struct + STBRPContext.FREE_HEAD)); } + /** Unsafe version of {@link #extra}. */ + public static STBRPNode.Buffer nextra(long struct) { return STBRPNode.create(struct + STBRPContext.EXTRA, 2); } + /** Unsafe version of {@link #extra(int) extra}. */ + public static STBRPNode nextra(long struct, int index) { + return STBRPNode.create(struct + STBRPContext.EXTRA + check(index, 2) * STBRPNode.SIZEOF); + } + + // ----------------------------------- + + /** An array of {@link STBRPContext} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected STBRPContext getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code width} field. */ + public int width() { return STBRPContext.nwidth(address()); } + /** Returns the value of the {@code height} field. */ + public int height() { return STBRPContext.nheight(address()); } + /** Returns the value of the {@code align} field. */ + public int align() { return STBRPContext.nalign(address()); } + /** Returns the value of the {@code init_mode} field. */ + public int init_mode() { return STBRPContext.ninit_mode(address()); } + /** Returns the value of the {@code heuristic} field. */ + public int heuristic() { return STBRPContext.nheuristic(address()); } + /** Returns the value of the {@code num_nodes} field. */ + public int num_nodes() { return STBRPContext.nnum_nodes(address()); } + /** Returns a {@link STBRPNode} view of the struct pointed to by the {@code active_head} field. */ + @Nullable + @NativeType("stbrp_node *") + public STBRPNode active_head() { return STBRPContext.nactive_head(address()); } + /** Returns a {@link STBRPNode} view of the struct pointed to by the {@code free_head} field. */ + @Nullable + @NativeType("stbrp_node *") + public STBRPNode free_head() { return STBRPContext.nfree_head(address()); } + /** Returns a {@link STBRPNode}.Buffer view of the {@code extra} field. */ + @NativeType("stbrp_node[2]") + public STBRPNode.Buffer extra() { return STBRPContext.nextra(address()); } + /** Returns a {@link STBRPNode} view of the struct at the specified index of the {@code extra} field. */ + @NativeType("stbrp_node") + public STBRPNode extra(int index) { return STBRPContext.nextra(address(), index); } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBRPNode.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBRPNode.java new file mode 100644 index 00000000..96475f4c --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBRPNode.java @@ -0,0 +1,285 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.MemoryStack.*; + +/** + * The opaque {@code stbrp_node} struct. + * + *
+ * struct stbrp_node {
+ * stbrp_coord x;
+ * stbrp_coord y;
+ * {@link STBRPNode stbrp_node} * next;
+ * }The created instance holds a strong reference to the container object.
+ */ + public STBRPNode(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code x} field. */ + @NativeType("stbrp_coord") + public short x() { return nx(address()); } + /** Returns the value of the {@code y} field. */ + @NativeType("stbrp_coord") + public short y() { return ny(address()); } + /** Returns a {@link STBRPNode} view of the struct pointed to by the {@code next} field. */ + @Nullable + @NativeType("stbrp_node *") + public STBRPNode next() { return nnext(address()); } + + // ----------------------------------- + + /** Returns a new {@code STBRPNode} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static STBRPNode malloc() { + return wrap(STBRPNode.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code STBRPNode} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static STBRPNode calloc() { + return wrap(STBRPNode.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code STBRPNode} instance allocated with {@link BufferUtils}. */ + public static STBRPNode create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(STBRPNode.class, memAddress(container), container); + } + + /** Returns a new {@code STBRPNode} instance for the specified memory address. */ + public static STBRPNode create(long address) { + return wrap(STBRPNode.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static STBRPNode createSafe(long address) { + return address == NULL ? null : wrap(STBRPNode.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code STBRPNode} instance allocated on the thread-local {@link MemoryStack}. */ + public static STBRPNode mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code STBRPNode} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static STBRPNode callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code STBRPNode} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static STBRPNode mallocStack(MemoryStack stack) { + return wrap(STBRPNode.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code STBRPNode} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static STBRPNode callocStack(MemoryStack stack) { + return wrap(STBRPNode.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #x}. */ + public static short nx(long struct) { return UNSAFE.getShort(null, struct + STBRPNode.X); } + /** Unsafe version of {@link #y}. */ + public static short ny(long struct) { return UNSAFE.getShort(null, struct + STBRPNode.Y); } + /** Unsafe version of {@link #next}. */ + @Nullable public static STBRPNode nnext(long struct) { return STBRPNode.createSafe(memGetAddress(struct + STBRPNode.NEXT)); } + + // ----------------------------------- + + /** An array of {@link STBRPNode} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected STBRPNode getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code x} field. */ + @NativeType("stbrp_coord") + public short x() { return STBRPNode.nx(address()); } + /** Returns the value of the {@code y} field. */ + @NativeType("stbrp_coord") + public short y() { return STBRPNode.ny(address()); } + /** Returns a {@link STBRPNode} view of the struct pointed to by the {@code next} field. */ + @Nullable + @NativeType("stbrp_node *") + public STBRPNode next() { return STBRPNode.nnext(address()); } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBRPRect.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBRPRect.java new file mode 100644 index 00000000..acbe04ab --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBRPRect.java @@ -0,0 +1,398 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.MemoryStack.*; + +/** + * A packed rectangle. + * + *
+ * struct stbrp_rect {
+ * int id;
+ * stbrp_coord w;
+ * stbrp_coord h;
+ * stbrp_coord x;
+ * stbrp_coord y;
+ * int was_packed;
+ * }The created instance holds a strong reference to the container object.
+ */ + public STBRPRect(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code id} field. */ + public int id() { return nid(address()); } + /** Returns the value of the {@code w} field. */ + @NativeType("stbrp_coord") + public short w() { return nw(address()); } + /** Returns the value of the {@code h} field. */ + @NativeType("stbrp_coord") + public short h() { return nh(address()); } + /** Returns the value of the {@code x} field. */ + @NativeType("stbrp_coord") + public short x() { return nx(address()); } + /** Returns the value of the {@code y} field. */ + @NativeType("stbrp_coord") + public short y() { return ny(address()); } + /** Returns the value of the {@code was_packed} field. */ + @NativeType("int") + public boolean was_packed() { return nwas_packed(address()) != 0; } + + /** Sets the specified value to the {@code id} field. */ + public STBRPRect id(int value) { nid(address(), value); return this; } + /** Sets the specified value to the {@code w} field. */ + public STBRPRect w(@NativeType("stbrp_coord") short value) { nw(address(), value); return this; } + /** Sets the specified value to the {@code h} field. */ + public STBRPRect h(@NativeType("stbrp_coord") short value) { nh(address(), value); return this; } + /** Sets the specified value to the {@code x} field. */ + public STBRPRect x(@NativeType("stbrp_coord") short value) { nx(address(), value); return this; } + /** Sets the specified value to the {@code y} field. */ + public STBRPRect y(@NativeType("stbrp_coord") short value) { ny(address(), value); return this; } + /** Sets the specified value to the {@code was_packed} field. */ + public STBRPRect was_packed(@NativeType("int") boolean value) { nwas_packed(address(), value ? 1 : 0); return this; } + + /** Initializes this struct with the specified values. */ + public STBRPRect set( + int id, + short w, + short h, + short x, + short y, + boolean was_packed + ) { + id(id); + w(w); + h(h); + x(x); + y(y); + was_packed(was_packed); + + return this; + } + + /** + * Copies the specified struct data to this struct. + * + * @param src the source struct + * + * @return this struct + */ + public STBRPRect set(STBRPRect src) { + memCopy(src.address(), address(), SIZEOF); + return this; + } + + // ----------------------------------- + + /** Returns a new {@code STBRPRect} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static STBRPRect malloc() { + return wrap(STBRPRect.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code STBRPRect} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static STBRPRect calloc() { + return wrap(STBRPRect.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code STBRPRect} instance allocated with {@link BufferUtils}. */ + public static STBRPRect create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(STBRPRect.class, memAddress(container), container); + } + + /** Returns a new {@code STBRPRect} instance for the specified memory address. */ + public static STBRPRect create(long address) { + return wrap(STBRPRect.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static STBRPRect createSafe(long address) { + return address == NULL ? null : wrap(STBRPRect.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code STBRPRect} instance allocated on the thread-local {@link MemoryStack}. */ + public static STBRPRect mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code STBRPRect} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static STBRPRect callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code STBRPRect} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static STBRPRect mallocStack(MemoryStack stack) { + return wrap(STBRPRect.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code STBRPRect} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static STBRPRect callocStack(MemoryStack stack) { + return wrap(STBRPRect.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #id}. */ + public static int nid(long struct) { return UNSAFE.getInt(null, struct + STBRPRect.ID); } + /** Unsafe version of {@link #w}. */ + public static short nw(long struct) { return UNSAFE.getShort(null, struct + STBRPRect.W); } + /** Unsafe version of {@link #h}. */ + public static short nh(long struct) { return UNSAFE.getShort(null, struct + STBRPRect.H); } + /** Unsafe version of {@link #x}. */ + public static short nx(long struct) { return UNSAFE.getShort(null, struct + STBRPRect.X); } + /** Unsafe version of {@link #y}. */ + public static short ny(long struct) { return UNSAFE.getShort(null, struct + STBRPRect.Y); } + /** Unsafe version of {@link #was_packed}. */ + public static int nwas_packed(long struct) { return UNSAFE.getInt(null, struct + STBRPRect.WAS_PACKED); } + + /** Unsafe version of {@link #id(int) id}. */ + public static void nid(long struct, int value) { UNSAFE.putInt(null, struct + STBRPRect.ID, value); } + /** Unsafe version of {@link #w(short) w}. */ + public static void nw(long struct, short value) { UNSAFE.putShort(null, struct + STBRPRect.W, value); } + /** Unsafe version of {@link #h(short) h}. */ + public static void nh(long struct, short value) { UNSAFE.putShort(null, struct + STBRPRect.H, value); } + /** Unsafe version of {@link #x(short) x}. */ + public static void nx(long struct, short value) { UNSAFE.putShort(null, struct + STBRPRect.X, value); } + /** Unsafe version of {@link #y(short) y}. */ + public static void ny(long struct, short value) { UNSAFE.putShort(null, struct + STBRPRect.Y, value); } + /** Unsafe version of {@link #was_packed(boolean) was_packed}. */ + public static void nwas_packed(long struct, int value) { UNSAFE.putInt(null, struct + STBRPRect.WAS_PACKED, value); } + + // ----------------------------------- + + /** An array of {@link STBRPRect} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected STBRPRect getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code id} field. */ + public int id() { return STBRPRect.nid(address()); } + /** Returns the value of the {@code w} field. */ + @NativeType("stbrp_coord") + public short w() { return STBRPRect.nw(address()); } + /** Returns the value of the {@code h} field. */ + @NativeType("stbrp_coord") + public short h() { return STBRPRect.nh(address()); } + /** Returns the value of the {@code x} field. */ + @NativeType("stbrp_coord") + public short x() { return STBRPRect.nx(address()); } + /** Returns the value of the {@code y} field. */ + @NativeType("stbrp_coord") + public short y() { return STBRPRect.ny(address()); } + /** Returns the value of the {@code was_packed} field. */ + @NativeType("int") + public boolean was_packed() { return STBRPRect.nwas_packed(address()) != 0; } + + /** Sets the specified value to the {@code id} field. */ + public Buffer id(int value) { STBRPRect.nid(address(), value); return this; } + /** Sets the specified value to the {@code w} field. */ + public Buffer w(@NativeType("stbrp_coord") short value) { STBRPRect.nw(address(), value); return this; } + /** Sets the specified value to the {@code h} field. */ + public Buffer h(@NativeType("stbrp_coord") short value) { STBRPRect.nh(address(), value); return this; } + /** Sets the specified value to the {@code x} field. */ + public Buffer x(@NativeType("stbrp_coord") short value) { STBRPRect.nx(address(), value); return this; } + /** Sets the specified value to the {@code y} field. */ + public Buffer y(@NativeType("stbrp_coord") short value) { STBRPRect.ny(address(), value); return this; } + /** Sets the specified value to the {@code was_packed} field. */ + public Buffer was_packed(@NativeType("int") boolean value) { STBRPRect.nwas_packed(address(), value ? 1 : 0); return this; } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBRectPack.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBRectPack.java new file mode 100644 index 00000000..b90470d4 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBRectPack.java @@ -0,0 +1,147 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import org.lwjgl.system.*; + + +/** + * Native bindings to stb_rect_pack.h from the stb library. + * + *Useful for e.g. packing rectangular textures into an atlas. Does not do rotation.
+ * + *This library currently uses the Skyline Bottom-Left algorithm. Not necessarily the awesomest packing method, but better than the totally naive one in + * stb_truetype (which is primarily what this is meant to replace).
+ */ +public class STBRectPack { + + /** + * Packing heuristics + * + *Rectangles which are successfully packed have the {@code was_packed} flag set to a non-zero value and {@code x} and {@code y} store the minimum + * location on each axis (i.e. bottom-left in cartesian coordinates, top-left if you imagine y increasing downwards). Rectangles which do not fit have the + * {@code was_packed} flag set to 0.
+ * + *You should not try to access the {@code rects} array from another thread while this function is running, as the function temporarily reorders the array + * while it executes.
+ * + *To pack into another rectangle, you need to call {@link #stbrp_init_target init_target} again. To continue packing into the same rectangle, you can call this function again. + * Calling this multiple times with multiple rect arrays will probably produce worse packing results than calling it a single time with the full rectangle + * array, but the option is available.
+ * + * @param context an {@link STBRPContext} struct + * @param rects an array of {@link STBRPRect} structs + * + * @return 1 if all of the rectangles were successfully packed and 0 otherwise + */ + public static int stbrp_pack_rects(@NativeType("stbrp_context *") STBRPContext context, @NativeType("stbrp_rect *") STBRPRect.Buffer rects) { + return nstbrp_pack_rects(context.address(), rects.address(), rects.remaining()); + } + + // --- [ stbrp_init_target ] --- + + /** + * Unsafe version of: {@link #stbrp_init_target init_target} + * + * @param num_nodes the number of structs in {@code nodes} + */ + public static native void nstbrp_init_target(long context, int width, int height, long nodes, int num_nodes); + + /** + * Initialize a rectangle packer to: pack a rectangle that is {@code width} by {@code height} in dimensions using temporary storage provided by the array + * {@code nodes}, which is {@code num_nodes} long. + * + *You must call this function every time you start packing into a new target.
+ * + *There is no "shutdown" function. The {@code nodes} memory must stay valid for the following {@link #stbrp_pack_rects pack_rects} call (or calls), but can be freed after the + * call (or calls) finish.
+ * + *Note: to guarantee best results, either:
+ * + *If you don't do either of the above things, widths will be quantized to multiples of small integers to guarantee the algorithm doesn't run out of + * temporary storage.
+ * + *If you do #2, then the non-quantized algorithm will be used, but the algorithm may run out of temporary storage and be unable to pack some rectangles.
+ * + * @param context an {@link STBRPContext} struct + * @param width the rectangle width + * @param height the rectangle height + * @param nodes an array of {@link STBRPNode} structs + */ + public static void stbrp_init_target(@NativeType("stbrp_context *") STBRPContext context, int width, int height, @NativeType("stbrp_node *") STBRPNode.Buffer nodes) { + nstbrp_init_target(context.address(), width, height, nodes.address(), nodes.remaining()); + } + + // --- [ stbrp_setup_allow_out_of_mem ] --- + + /** Unsafe version of: {@link #stbrp_setup_allow_out_of_mem setup_allow_out_of_mem} */ + public static native void nstbrp_setup_allow_out_of_mem(long context, int allow_out_of_mem); + + /** + * Optionally call this function after init but before doing any packing to change the handling of the out-of-temp-memory scenario, described in + * {@link #stbrp_init_target init_target}. If you call init again, this will be reset to the default (false). + * + * @param context an {@link STBRPContext} struct + * @param allow_out_of_mem 1 to allow running out of temporary storage + */ + public static void stbrp_setup_allow_out_of_mem(@NativeType("stbrp_context *") STBRPContext context, @NativeType("int") boolean allow_out_of_mem) { + nstbrp_setup_allow_out_of_mem(context.address(), allow_out_of_mem ? 1 : 0); + } + + // --- [ stbrp_setup_heuristic ] --- + + /** Unsafe version of: {@link #stbrp_setup_heuristic setup_heuristic} */ + public static native void nstbrp_setup_heuristic(long context, int heuristic); + + /** + * Optionally select which packing heuristic the library should use. Different heuristics will produce better/worse results for different data sets. If + * you call init again, this will be reset to the default. + * + * @param context an {@link STBRPContext} struct + * @param heuristic the packing heuristic + */ + public static void stbrp_setup_heuristic(@NativeType("stbrp_context *") STBRPContext context, int heuristic) { + nstbrp_setup_heuristic(context.address(), heuristic); + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTAlignedQuad.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTAlignedQuad.java new file mode 100644 index 00000000..bd5c36d4 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTAlignedQuad.java @@ -0,0 +1,327 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.MemoryStack.*; + +/** + * Quad used for drawing a baked character, returned by {@link STBTruetype#stbtt_GetBakedQuad GetBakedQuad}. + * + *
+ * struct stbtt_aligned_quad {
+ * float x0;
+ * float y0;
+ * float s0;
+ * float t0;
+ * float x1;
+ * float y1;
+ * float s1;
+ * float t1;
+ * }The created instance holds a strong reference to the container object.
+ */ + public STBTTAlignedQuad(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code x0} field. */ + public float x0() { return nx0(address()); } + /** Returns the value of the {@code y0} field. */ + public float y0() { return ny0(address()); } + /** Returns the value of the {@code s0} field. */ + public float s0() { return ns0(address()); } + /** Returns the value of the {@code t0} field. */ + public float t0() { return nt0(address()); } + /** Returns the value of the {@code x1} field. */ + public float x1() { return nx1(address()); } + /** Returns the value of the {@code y1} field. */ + public float y1() { return ny1(address()); } + /** Returns the value of the {@code s1} field. */ + public float s1() { return ns1(address()); } + /** Returns the value of the {@code t1} field. */ + public float t1() { return nt1(address()); } + + // ----------------------------------- + + /** Returns a new {@code STBTTAlignedQuad} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static STBTTAlignedQuad malloc() { + return wrap(STBTTAlignedQuad.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code STBTTAlignedQuad} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static STBTTAlignedQuad calloc() { + return wrap(STBTTAlignedQuad.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code STBTTAlignedQuad} instance allocated with {@link BufferUtils}. */ + public static STBTTAlignedQuad create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(STBTTAlignedQuad.class, memAddress(container), container); + } + + /** Returns a new {@code STBTTAlignedQuad} instance for the specified memory address. */ + public static STBTTAlignedQuad create(long address) { + return wrap(STBTTAlignedQuad.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static STBTTAlignedQuad createSafe(long address) { + return address == NULL ? null : wrap(STBTTAlignedQuad.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code STBTTAlignedQuad} instance allocated on the thread-local {@link MemoryStack}. */ + public static STBTTAlignedQuad mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code STBTTAlignedQuad} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static STBTTAlignedQuad callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code STBTTAlignedQuad} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static STBTTAlignedQuad mallocStack(MemoryStack stack) { + return wrap(STBTTAlignedQuad.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code STBTTAlignedQuad} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static STBTTAlignedQuad callocStack(MemoryStack stack) { + return wrap(STBTTAlignedQuad.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #x0}. */ + public static float nx0(long struct) { return UNSAFE.getFloat(null, struct + STBTTAlignedQuad.X0); } + /** Unsafe version of {@link #y0}. */ + public static float ny0(long struct) { return UNSAFE.getFloat(null, struct + STBTTAlignedQuad.Y0); } + /** Unsafe version of {@link #s0}. */ + public static float ns0(long struct) { return UNSAFE.getFloat(null, struct + STBTTAlignedQuad.S0); } + /** Unsafe version of {@link #t0}. */ + public static float nt0(long struct) { return UNSAFE.getFloat(null, struct + STBTTAlignedQuad.T0); } + /** Unsafe version of {@link #x1}. */ + public static float nx1(long struct) { return UNSAFE.getFloat(null, struct + STBTTAlignedQuad.X1); } + /** Unsafe version of {@link #y1}. */ + public static float ny1(long struct) { return UNSAFE.getFloat(null, struct + STBTTAlignedQuad.Y1); } + /** Unsafe version of {@link #s1}. */ + public static float ns1(long struct) { return UNSAFE.getFloat(null, struct + STBTTAlignedQuad.S1); } + /** Unsafe version of {@link #t1}. */ + public static float nt1(long struct) { return UNSAFE.getFloat(null, struct + STBTTAlignedQuad.T1); } + + // ----------------------------------- + + /** An array of {@link STBTTAlignedQuad} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected STBTTAlignedQuad getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code x0} field. */ + public float x0() { return STBTTAlignedQuad.nx0(address()); } + /** Returns the value of the {@code y0} field. */ + public float y0() { return STBTTAlignedQuad.ny0(address()); } + /** Returns the value of the {@code s0} field. */ + public float s0() { return STBTTAlignedQuad.ns0(address()); } + /** Returns the value of the {@code t0} field. */ + public float t0() { return STBTTAlignedQuad.nt0(address()); } + /** Returns the value of the {@code x1} field. */ + public float x1() { return STBTTAlignedQuad.nx1(address()); } + /** Returns the value of the {@code y1} field. */ + public float y1() { return STBTTAlignedQuad.ny1(address()); } + /** Returns the value of the {@code s1} field. */ + public float s1() { return STBTTAlignedQuad.ns1(address()); } + /** Returns the value of the {@code t1} field. */ + public float t1() { return STBTTAlignedQuad.nt1(address()); } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTBakedChar.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTBakedChar.java new file mode 100644 index 00000000..9b3ada22 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTBakedChar.java @@ -0,0 +1,325 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.MemoryStack.*; + +/** + * Baked character data, returned by {@link STBTruetype#stbtt_BakeFontBitmap BakeFontBitmap}. + * + *
+ * struct stbtt_bakedchar {
+ * unsigned short x0;
+ * unsigned short y0;
+ * unsigned short x1;
+ * unsigned short y1;
+ * float xoff;
+ * float yoff;
+ * float xadvance;
+ * }The created instance holds a strong reference to the container object.
+ */ + public STBTTBakedChar(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code x0} field. */ + @NativeType("unsigned short") + public short x0() { return nx0(address()); } + /** Returns the value of the {@code y0} field. */ + @NativeType("unsigned short") + public short y0() { return ny0(address()); } + /** Returns the value of the {@code x1} field. */ + @NativeType("unsigned short") + public short x1() { return nx1(address()); } + /** Returns the value of the {@code y1} field. */ + @NativeType("unsigned short") + public short y1() { return ny1(address()); } + /** Returns the value of the {@code xoff} field. */ + public float xoff() { return nxoff(address()); } + /** Returns the value of the {@code yoff} field. */ + public float yoff() { return nyoff(address()); } + /** Returns the value of the {@code xadvance} field. */ + public float xadvance() { return nxadvance(address()); } + + // ----------------------------------- + + /** Returns a new {@code STBTTBakedChar} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static STBTTBakedChar malloc() { + return wrap(STBTTBakedChar.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code STBTTBakedChar} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static STBTTBakedChar calloc() { + return wrap(STBTTBakedChar.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code STBTTBakedChar} instance allocated with {@link BufferUtils}. */ + public static STBTTBakedChar create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(STBTTBakedChar.class, memAddress(container), container); + } + + /** Returns a new {@code STBTTBakedChar} instance for the specified memory address. */ + public static STBTTBakedChar create(long address) { + return wrap(STBTTBakedChar.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static STBTTBakedChar createSafe(long address) { + return address == NULL ? null : wrap(STBTTBakedChar.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code STBTTBakedChar} instance allocated on the thread-local {@link MemoryStack}. */ + public static STBTTBakedChar mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code STBTTBakedChar} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static STBTTBakedChar callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code STBTTBakedChar} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static STBTTBakedChar mallocStack(MemoryStack stack) { + return wrap(STBTTBakedChar.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code STBTTBakedChar} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static STBTTBakedChar callocStack(MemoryStack stack) { + return wrap(STBTTBakedChar.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #x0}. */ + public static short nx0(long struct) { return UNSAFE.getShort(null, struct + STBTTBakedChar.X0); } + /** Unsafe version of {@link #y0}. */ + public static short ny0(long struct) { return UNSAFE.getShort(null, struct + STBTTBakedChar.Y0); } + /** Unsafe version of {@link #x1}. */ + public static short nx1(long struct) { return UNSAFE.getShort(null, struct + STBTTBakedChar.X1); } + /** Unsafe version of {@link #y1}. */ + public static short ny1(long struct) { return UNSAFE.getShort(null, struct + STBTTBakedChar.Y1); } + /** Unsafe version of {@link #xoff}. */ + public static float nxoff(long struct) { return UNSAFE.getFloat(null, struct + STBTTBakedChar.XOFF); } + /** Unsafe version of {@link #yoff}. */ + public static float nyoff(long struct) { return UNSAFE.getFloat(null, struct + STBTTBakedChar.YOFF); } + /** Unsafe version of {@link #xadvance}. */ + public static float nxadvance(long struct) { return UNSAFE.getFloat(null, struct + STBTTBakedChar.XADVANCE); } + + // ----------------------------------- + + /** An array of {@link STBTTBakedChar} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected STBTTBakedChar getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code x0} field. */ + @NativeType("unsigned short") + public short x0() { return STBTTBakedChar.nx0(address()); } + /** Returns the value of the {@code y0} field. */ + @NativeType("unsigned short") + public short y0() { return STBTTBakedChar.ny0(address()); } + /** Returns the value of the {@code x1} field. */ + @NativeType("unsigned short") + public short x1() { return STBTTBakedChar.nx1(address()); } + /** Returns the value of the {@code y1} field. */ + @NativeType("unsigned short") + public short y1() { return STBTTBakedChar.ny1(address()); } + /** Returns the value of the {@code xoff} field. */ + public float xoff() { return STBTTBakedChar.nxoff(address()); } + /** Returns the value of the {@code yoff} field. */ + public float yoff() { return STBTTBakedChar.nyoff(address()); } + /** Returns the value of the {@code xadvance} field. */ + public float xadvance() { return STBTTBakedChar.nxadvance(address()); } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTBitmap.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTBitmap.java new file mode 100644 index 00000000..c5d70216 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTBitmap.java @@ -0,0 +1,382 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.MemoryStack.*; + +/** + * Bitmap data. + * + *
+ * struct stbtt__bitmap {
+ * int w;
+ * int h;
+ * int stride;
+ * unsigned char * pixels;
+ * }The created instance holds a strong reference to the container object.
+ */ + public STBTTBitmap(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code w} field. */ + public int w() { return nw(address()); } + /** Returns the value of the {@code h} field. */ + public int h() { return nh(address()); } + /** Returns the value of the {@code stride} field. */ + public int stride() { return nstride(address()); } + /** + * Returns a {@link ByteBuffer} view of the data pointed to by the {@code pixels} field. + * + * @param capacity the number of elements in the returned buffer + */ + @NativeType("unsigned char *") + public ByteBuffer pixels(int capacity) { return npixels(address(), capacity); } + + /** Sets the specified value to the {@code w} field. */ + public STBTTBitmap w(int value) { nw(address(), value); return this; } + /** Sets the specified value to the {@code h} field. */ + public STBTTBitmap h(int value) { nh(address(), value); return this; } + /** Sets the specified value to the {@code stride} field. */ + public STBTTBitmap stride(int value) { nstride(address(), value); return this; } + /** Sets the address of the specified {@link ByteBuffer} to the {@code pixels} field. */ + public STBTTBitmap pixels(@NativeType("unsigned char *") ByteBuffer value) { npixels(address(), value); return this; } + + /** Initializes this struct with the specified values. */ + public STBTTBitmap set( + int w, + int h, + int stride, + ByteBuffer pixels + ) { + w(w); + h(h); + stride(stride); + pixels(pixels); + + return this; + } + + /** + * Copies the specified struct data to this struct. + * + * @param src the source struct + * + * @return this struct + */ + public STBTTBitmap set(STBTTBitmap src) { + memCopy(src.address(), address(), SIZEOF); + return this; + } + + // ----------------------------------- + + /** Returns a new {@code STBTTBitmap} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static STBTTBitmap malloc() { + return wrap(STBTTBitmap.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code STBTTBitmap} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static STBTTBitmap calloc() { + return wrap(STBTTBitmap.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code STBTTBitmap} instance allocated with {@link BufferUtils}. */ + public static STBTTBitmap create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(STBTTBitmap.class, memAddress(container), container); + } + + /** Returns a new {@code STBTTBitmap} instance for the specified memory address. */ + public static STBTTBitmap create(long address) { + return wrap(STBTTBitmap.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static STBTTBitmap createSafe(long address) { + return address == NULL ? null : wrap(STBTTBitmap.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code STBTTBitmap} instance allocated on the thread-local {@link MemoryStack}. */ + public static STBTTBitmap mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code STBTTBitmap} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static STBTTBitmap callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code STBTTBitmap} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static STBTTBitmap mallocStack(MemoryStack stack) { + return wrap(STBTTBitmap.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code STBTTBitmap} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static STBTTBitmap callocStack(MemoryStack stack) { + return wrap(STBTTBitmap.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #w}. */ + public static int nw(long struct) { return UNSAFE.getInt(null, struct + STBTTBitmap.W); } + /** Unsafe version of {@link #h}. */ + public static int nh(long struct) { return UNSAFE.getInt(null, struct + STBTTBitmap.H); } + /** Unsafe version of {@link #stride}. */ + public static int nstride(long struct) { return UNSAFE.getInt(null, struct + STBTTBitmap.STRIDE); } + /** Unsafe version of {@link #pixels(int) pixels}. */ + public static ByteBuffer npixels(long struct, int capacity) { return memByteBuffer(memGetAddress(struct + STBTTBitmap.PIXELS), capacity); } + + /** Unsafe version of {@link #w(int) w}. */ + public static void nw(long struct, int value) { UNSAFE.putInt(null, struct + STBTTBitmap.W, value); } + /** Unsafe version of {@link #h(int) h}. */ + public static void nh(long struct, int value) { UNSAFE.putInt(null, struct + STBTTBitmap.H, value); } + /** Unsafe version of {@link #stride(int) stride}. */ + public static void nstride(long struct, int value) { UNSAFE.putInt(null, struct + STBTTBitmap.STRIDE, value); } + /** Unsafe version of {@link #pixels(ByteBuffer) pixels}. */ + public static void npixels(long struct, ByteBuffer value) { memPutAddress(struct + STBTTBitmap.PIXELS, memAddress(value)); } + + /** + * Validates pointer members that should not be {@code NULL}. + * + * @param struct the struct to validate + */ + public static void validate(long struct) { + check(memGetAddress(struct + STBTTBitmap.PIXELS)); + } + + /** + * Calls {@link #validate(long)} for each struct contained in the specified struct array. + * + * @param array the struct array to validate + * @param count the number of structs in {@code array} + */ + public static void validate(long array, int count) { + for (int i = 0; i < count; i++) { + validate(array + Integer.toUnsignedLong(i) * SIZEOF); + } + } + + // ----------------------------------- + + /** An array of {@link STBTTBitmap} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected STBTTBitmap getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code w} field. */ + public int w() { return STBTTBitmap.nw(address()); } + /** Returns the value of the {@code h} field. */ + public int h() { return STBTTBitmap.nh(address()); } + /** Returns the value of the {@code stride} field. */ + public int stride() { return STBTTBitmap.nstride(address()); } + /** + * Returns a {@link ByteBuffer} view of the data pointed to by the {@code pixels} field. + * + * @param capacity the number of elements in the returned buffer + */ + @NativeType("unsigned char *") + public ByteBuffer pixels(int capacity) { return STBTTBitmap.npixels(address(), capacity); } + + /** Sets the specified value to the {@code w} field. */ + public Buffer w(int value) { STBTTBitmap.nw(address(), value); return this; } + /** Sets the specified value to the {@code h} field. */ + public Buffer h(int value) { STBTTBitmap.nh(address(), value); return this; } + /** Sets the specified value to the {@code stride} field. */ + public Buffer stride(int value) { STBTTBitmap.nstride(address(), value); return this; } + /** Sets the address of the specified {@link ByteBuffer} to the {@code pixels} field. */ + public Buffer pixels(@NativeType("unsigned char *") ByteBuffer value) { STBTTBitmap.npixels(address(), value); return this; } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTFontinfo.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTFontinfo.java new file mode 100644 index 00000000..2a170218 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTFontinfo.java @@ -0,0 +1,236 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.MemoryStack.*; + +/** An opaque structure that contains font information. */ +@NativeType("struct stbtt_fontinfo") +public class STBTTFontinfo extends Struct implements NativeResource { + + /** The struct size in bytes. */ + public static final int SIZEOF; + + /** The struct alignment in bytes. */ + public static final int ALIGNOF; + + static { + LibSTB.initialize(); + + try (MemoryStack stack = stackPush()) { + IntBuffer offsets = stack.mallocInt(1); + SIZEOF = offsets(memAddress(offsets)); + ALIGNOF = offsets.get(0); + } + } + + private static native int offsets(long buffer); + + /** + * Creates a {@code STBTTFontinfo} instance at the current position of the specified {@link ByteBuffer} container. Changes to the buffer's content will be + * visible to the struct instance and vice versa. + * + *The created instance holds a strong reference to the container object.
+ */ + public STBTTFontinfo(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + // ----------------------------------- + + /** Returns a new {@code STBTTFontinfo} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static STBTTFontinfo malloc() { + return wrap(STBTTFontinfo.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code STBTTFontinfo} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static STBTTFontinfo calloc() { + return wrap(STBTTFontinfo.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code STBTTFontinfo} instance allocated with {@link BufferUtils}. */ + public static STBTTFontinfo create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(STBTTFontinfo.class, memAddress(container), container); + } + + /** Returns a new {@code STBTTFontinfo} instance for the specified memory address. */ + public static STBTTFontinfo create(long address) { + return wrap(STBTTFontinfo.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static STBTTFontinfo createSafe(long address) { + return address == NULL ? null : wrap(STBTTFontinfo.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code STBTTFontinfo} instance allocated on the thread-local {@link MemoryStack}. */ + public static STBTTFontinfo mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code STBTTFontinfo} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static STBTTFontinfo callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code STBTTFontinfo} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static STBTTFontinfo mallocStack(MemoryStack stack) { + return wrap(STBTTFontinfo.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code STBTTFontinfo} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static STBTTFontinfo callocStack(MemoryStack stack) { + return wrap(STBTTFontinfo.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + // ----------------------------------- + + /** An array of {@link STBTTFontinfo} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected STBTTFontinfo getElementFactory() { + return ELEMENT_FACTORY; + } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTPackContext.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTPackContext.java new file mode 100644 index 00000000..7d0467d7 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTPackContext.java @@ -0,0 +1,387 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.MemoryStack.*; + +/** + * An opaque structure which holds all the context needed from {@link STBTruetype#stbtt_PackBegin PackBegin} to {@link STBTruetype#stbtt_PackEnd PackEnd}. + * + *
+ * struct stbtt_pack_context {
+ * void * user_allocator_context;
+ * {@link STBRPContext stbrp_context} * pack_info;
+ * int width;
+ * int height;
+ * int stride_in_bytes;
+ * int padding;
+ * int skip_missing;
+ * unsigned int h_oversample;
+ * unsigned int v_oversample;
+ * unsigned char * pixels;
+ * {@link STBRPNode stbrp_node} * nodes;
+ * }The created instance holds a strong reference to the container object.
+ */ + public STBTTPackContext(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code user_allocator_context} field. */ + @NativeType("void *") + public long user_allocator_context() { return nuser_allocator_context(address()); } + /** Returns a {@link STBRPContext} view of the struct pointed to by the {@code pack_info} field. */ + @NativeType("stbrp_context *") + public STBRPContext pack_info() { return npack_info(address()); } + /** Returns the value of the {@code width} field. */ + public int width() { return nwidth(address()); } + /** Returns the value of the {@code height} field. */ + public int height() { return nheight(address()); } + /** Returns the value of the {@code stride_in_bytes} field. */ + public int stride_in_bytes() { return nstride_in_bytes(address()); } + /** Returns the value of the {@code padding} field. */ + public int padding() { return npadding(address()); } + /** Returns the value of the {@code skip_missing} field. */ + @NativeType("int") + public boolean skip_missing() { return nskip_missing(address()) != 0; } + /** Returns the value of the {@code h_oversample} field. */ + @NativeType("unsigned int") + public int h_oversample() { return nh_oversample(address()); } + /** Returns the value of the {@code v_oversample} field. */ + @NativeType("unsigned int") + public int v_oversample() { return nv_oversample(address()); } + /** + * Returns a {@link ByteBuffer} view of the data pointed to by the {@code pixels} field. + * + * @param capacity the number of elements in the returned buffer + */ + @NativeType("unsigned char *") + public ByteBuffer pixels(int capacity) { return npixels(address(), capacity); } + /** + * Returns a {@link STBRPNode.Buffer} view of the struct array pointed to by the {@code nodes} field. + * + * @param capacity the number of elements in the returned buffer + */ + @NativeType("stbrp_node *") + public STBRPNode.Buffer nodes(int capacity) { return nnodes(address(), capacity); } + + // ----------------------------------- + + /** Returns a new {@code STBTTPackContext} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static STBTTPackContext malloc() { + return wrap(STBTTPackContext.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code STBTTPackContext} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static STBTTPackContext calloc() { + return wrap(STBTTPackContext.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code STBTTPackContext} instance allocated with {@link BufferUtils}. */ + public static STBTTPackContext create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(STBTTPackContext.class, memAddress(container), container); + } + + /** Returns a new {@code STBTTPackContext} instance for the specified memory address. */ + public static STBTTPackContext create(long address) { + return wrap(STBTTPackContext.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static STBTTPackContext createSafe(long address) { + return address == NULL ? null : wrap(STBTTPackContext.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code STBTTPackContext} instance allocated on the thread-local {@link MemoryStack}. */ + public static STBTTPackContext mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code STBTTPackContext} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static STBTTPackContext callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code STBTTPackContext} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static STBTTPackContext mallocStack(MemoryStack stack) { + return wrap(STBTTPackContext.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code STBTTPackContext} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static STBTTPackContext callocStack(MemoryStack stack) { + return wrap(STBTTPackContext.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #user_allocator_context}. */ + public static long nuser_allocator_context(long struct) { return memGetAddress(struct + STBTTPackContext.USER_ALLOCATOR_CONTEXT); } + /** Unsafe version of {@link #pack_info}. */ + public static STBRPContext npack_info(long struct) { return STBRPContext.create(memGetAddress(struct + STBTTPackContext.PACK_INFO)); } + /** Unsafe version of {@link #width}. */ + public static int nwidth(long struct) { return UNSAFE.getInt(null, struct + STBTTPackContext.WIDTH); } + /** Unsafe version of {@link #height}. */ + public static int nheight(long struct) { return UNSAFE.getInt(null, struct + STBTTPackContext.HEIGHT); } + /** Unsafe version of {@link #stride_in_bytes}. */ + public static int nstride_in_bytes(long struct) { return UNSAFE.getInt(null, struct + STBTTPackContext.STRIDE_IN_BYTES); } + /** Unsafe version of {@link #padding}. */ + public static int npadding(long struct) { return UNSAFE.getInt(null, struct + STBTTPackContext.PADDING); } + /** Unsafe version of {@link #skip_missing}. */ + public static int nskip_missing(long struct) { return UNSAFE.getInt(null, struct + STBTTPackContext.SKIP_MISSING); } + /** Unsafe version of {@link #h_oversample}. */ + public static int nh_oversample(long struct) { return UNSAFE.getInt(null, struct + STBTTPackContext.H_OVERSAMPLE); } + /** Unsafe version of {@link #v_oversample}. */ + public static int nv_oversample(long struct) { return UNSAFE.getInt(null, struct + STBTTPackContext.V_OVERSAMPLE); } + /** Unsafe version of {@link #pixels(int) pixels}. */ + public static ByteBuffer npixels(long struct, int capacity) { return memByteBuffer(memGetAddress(struct + STBTTPackContext.PIXELS), capacity); } + /** Unsafe version of {@link #nodes}. */ + public static STBRPNode.Buffer nnodes(long struct, int capacity) { return STBRPNode.create(memGetAddress(struct + STBTTPackContext.NODES), capacity); } + + // ----------------------------------- + + /** An array of {@link STBTTPackContext} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected STBTTPackContext getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code user_allocator_context} field. */ + @NativeType("void *") + public long user_allocator_context() { return STBTTPackContext.nuser_allocator_context(address()); } + /** Returns a {@link STBRPContext} view of the struct pointed to by the {@code pack_info} field. */ + @NativeType("stbrp_context *") + public STBRPContext pack_info() { return STBTTPackContext.npack_info(address()); } + /** Returns the value of the {@code width} field. */ + public int width() { return STBTTPackContext.nwidth(address()); } + /** Returns the value of the {@code height} field. */ + public int height() { return STBTTPackContext.nheight(address()); } + /** Returns the value of the {@code stride_in_bytes} field. */ + public int stride_in_bytes() { return STBTTPackContext.nstride_in_bytes(address()); } + /** Returns the value of the {@code padding} field. */ + public int padding() { return STBTTPackContext.npadding(address()); } + /** Returns the value of the {@code skip_missing} field. */ + @NativeType("int") + public boolean skip_missing() { return STBTTPackContext.nskip_missing(address()) != 0; } + /** Returns the value of the {@code h_oversample} field. */ + @NativeType("unsigned int") + public int h_oversample() { return STBTTPackContext.nh_oversample(address()); } + /** Returns the value of the {@code v_oversample} field. */ + @NativeType("unsigned int") + public int v_oversample() { return STBTTPackContext.nv_oversample(address()); } + /** + * Returns a {@link ByteBuffer} view of the data pointed to by the {@code pixels} field. + * + * @param capacity the number of elements in the returned buffer + */ + @NativeType("unsigned char *") + public ByteBuffer pixels(int capacity) { return STBTTPackContext.npixels(address(), capacity); } + /** + * Returns a {@link STBRPNode.Buffer} view of the struct array pointed to by the {@code nodes} field. + * + * @param capacity the number of elements in the returned buffer + */ + @NativeType("stbrp_node *") + public STBRPNode.Buffer nodes(int capacity) { return STBTTPackContext.nnodes(address(), capacity); } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTPackRange.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTPackRange.java new file mode 100644 index 00000000..3e8e434b --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTPackRange.java @@ -0,0 +1,439 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.MemoryStack.*; + +/** + * A range of packed character data, used by {@link STBTruetype#stbtt_PackFontRanges PackFontRanges} + * + *
+ * struct stbtt_pack_range {
+ * float font_size;
+ * int first_unicode_codepoint_in_range;
+ * int * array_of_unicode_codepoints;
+ * int num_chars;
+ * {@link STBTTPackedchar stbtt_packedchar} * chardata_for_range;
+ * unsigned char h_oversample;
+ * unsigned char v_oversample;
+ * }The created instance holds a strong reference to the container object.
+ */ + public STBTTPackRange(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code font_size} field. */ + public float font_size() { return nfont_size(address()); } + /** Returns the value of the {@code first_unicode_codepoint_in_range} field. */ + public int first_unicode_codepoint_in_range() { return nfirst_unicode_codepoint_in_range(address()); } + /** Returns a {@link IntBuffer} view of the data pointed to by the {@code array_of_unicode_codepoints} field. */ + @Nullable + @NativeType("int *") + public IntBuffer array_of_unicode_codepoints() { return narray_of_unicode_codepoints(address()); } + /** Returns the value of the {@code num_chars} field. */ + public int num_chars() { return nnum_chars(address()); } + /** Returns a {@link STBTTPackedchar.Buffer} view of the struct array pointed to by the {@code chardata_for_range} field. */ + @NativeType("stbtt_packedchar *") + public STBTTPackedchar.Buffer chardata_for_range() { return nchardata_for_range(address()); } + /** Returns the value of the {@code h_oversample} field. */ + @NativeType("unsigned char") + public byte h_oversample() { return nh_oversample(address()); } + /** Returns the value of the {@code v_oversample} field. */ + @NativeType("unsigned char") + public byte v_oversample() { return nv_oversample(address()); } + + /** Sets the specified value to the {@code font_size} field. */ + public STBTTPackRange font_size(float value) { nfont_size(address(), value); return this; } + /** Sets the specified value to the {@code first_unicode_codepoint_in_range} field. */ + public STBTTPackRange first_unicode_codepoint_in_range(int value) { nfirst_unicode_codepoint_in_range(address(), value); return this; } + /** Sets the address of the specified {@link IntBuffer} to the {@code array_of_unicode_codepoints} field. */ + public STBTTPackRange array_of_unicode_codepoints(@Nullable @NativeType("int *") IntBuffer value) { narray_of_unicode_codepoints(address(), value); return this; } + /** Sets the specified value to the {@code num_chars} field. */ + public STBTTPackRange num_chars(int value) { nnum_chars(address(), value); return this; } + /** Sets the address of the specified {@link STBTTPackedchar.Buffer} to the {@code chardata_for_range} field. */ + public STBTTPackRange chardata_for_range(@NativeType("stbtt_packedchar *") STBTTPackedchar.Buffer value) { nchardata_for_range(address(), value); return this; } + /** Sets the specified value to the {@code h_oversample} field. */ + public STBTTPackRange h_oversample(@NativeType("unsigned char") byte value) { nh_oversample(address(), value); return this; } + /** Sets the specified value to the {@code v_oversample} field. */ + public STBTTPackRange v_oversample(@NativeType("unsigned char") byte value) { nv_oversample(address(), value); return this; } + + /** Initializes this struct with the specified values. */ + public STBTTPackRange set( + float font_size, + int first_unicode_codepoint_in_range, + @Nullable IntBuffer array_of_unicode_codepoints, + int num_chars, + STBTTPackedchar.Buffer chardata_for_range, + byte h_oversample, + byte v_oversample + ) { + font_size(font_size); + first_unicode_codepoint_in_range(first_unicode_codepoint_in_range); + array_of_unicode_codepoints(array_of_unicode_codepoints); + num_chars(num_chars); + chardata_for_range(chardata_for_range); + h_oversample(h_oversample); + v_oversample(v_oversample); + + return this; + } + + /** + * Copies the specified struct data to this struct. + * + * @param src the source struct + * + * @return this struct + */ + public STBTTPackRange set(STBTTPackRange src) { + memCopy(src.address(), address(), SIZEOF); + return this; + } + + // ----------------------------------- + + /** Returns a new {@code STBTTPackRange} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static STBTTPackRange malloc() { + return wrap(STBTTPackRange.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code STBTTPackRange} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static STBTTPackRange calloc() { + return wrap(STBTTPackRange.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code STBTTPackRange} instance allocated with {@link BufferUtils}. */ + public static STBTTPackRange create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(STBTTPackRange.class, memAddress(container), container); + } + + /** Returns a new {@code STBTTPackRange} instance for the specified memory address. */ + public static STBTTPackRange create(long address) { + return wrap(STBTTPackRange.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static STBTTPackRange createSafe(long address) { + return address == NULL ? null : wrap(STBTTPackRange.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code STBTTPackRange} instance allocated on the thread-local {@link MemoryStack}. */ + public static STBTTPackRange mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code STBTTPackRange} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static STBTTPackRange callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code STBTTPackRange} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static STBTTPackRange mallocStack(MemoryStack stack) { + return wrap(STBTTPackRange.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code STBTTPackRange} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static STBTTPackRange callocStack(MemoryStack stack) { + return wrap(STBTTPackRange.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #font_size}. */ + public static float nfont_size(long struct) { return UNSAFE.getFloat(null, struct + STBTTPackRange.FONT_SIZE); } + /** Unsafe version of {@link #first_unicode_codepoint_in_range}. */ + public static int nfirst_unicode_codepoint_in_range(long struct) { return UNSAFE.getInt(null, struct + STBTTPackRange.FIRST_UNICODE_CODEPOINT_IN_RANGE); } + /** Unsafe version of {@link #array_of_unicode_codepoints() array_of_unicode_codepoints}. */ + @Nullable public static IntBuffer narray_of_unicode_codepoints(long struct) { return memIntBufferSafe(memGetAddress(struct + STBTTPackRange.ARRAY_OF_UNICODE_CODEPOINTS), nnum_chars(struct)); } + /** Unsafe version of {@link #num_chars}. */ + public static int nnum_chars(long struct) { return UNSAFE.getInt(null, struct + STBTTPackRange.NUM_CHARS); } + /** Unsafe version of {@link #chardata_for_range}. */ + public static STBTTPackedchar.Buffer nchardata_for_range(long struct) { return STBTTPackedchar.create(memGetAddress(struct + STBTTPackRange.CHARDATA_FOR_RANGE), nnum_chars(struct)); } + /** Unsafe version of {@link #h_oversample}. */ + public static byte nh_oversample(long struct) { return UNSAFE.getByte(null, struct + STBTTPackRange.H_OVERSAMPLE); } + /** Unsafe version of {@link #v_oversample}. */ + public static byte nv_oversample(long struct) { return UNSAFE.getByte(null, struct + STBTTPackRange.V_OVERSAMPLE); } + + /** Unsafe version of {@link #font_size(float) font_size}. */ + public static void nfont_size(long struct, float value) { UNSAFE.putFloat(null, struct + STBTTPackRange.FONT_SIZE, value); } + /** Unsafe version of {@link #first_unicode_codepoint_in_range(int) first_unicode_codepoint_in_range}. */ + public static void nfirst_unicode_codepoint_in_range(long struct, int value) { UNSAFE.putInt(null, struct + STBTTPackRange.FIRST_UNICODE_CODEPOINT_IN_RANGE, value); } + /** Unsafe version of {@link #array_of_unicode_codepoints(IntBuffer) array_of_unicode_codepoints}. */ + public static void narray_of_unicode_codepoints(long struct, @Nullable IntBuffer value) { memPutAddress(struct + STBTTPackRange.ARRAY_OF_UNICODE_CODEPOINTS, memAddressSafe(value)); } + /** Sets the specified value to the {@code num_chars} field of the specified {@code struct}. */ + public static void nnum_chars(long struct, int value) { UNSAFE.putInt(null, struct + STBTTPackRange.NUM_CHARS, value); } + /** Unsafe version of {@link #chardata_for_range(STBTTPackedchar.Buffer) chardata_for_range}. */ + public static void nchardata_for_range(long struct, STBTTPackedchar.Buffer value) { memPutAddress(struct + STBTTPackRange.CHARDATA_FOR_RANGE, value.address()); } + /** Unsafe version of {@link #h_oversample(byte) h_oversample}. */ + public static void nh_oversample(long struct, byte value) { UNSAFE.putByte(null, struct + STBTTPackRange.H_OVERSAMPLE, value); } + /** Unsafe version of {@link #v_oversample(byte) v_oversample}. */ + public static void nv_oversample(long struct, byte value) { UNSAFE.putByte(null, struct + STBTTPackRange.V_OVERSAMPLE, value); } + + /** + * Validates pointer members that should not be {@code NULL}. + * + * @param struct the struct to validate + */ + public static void validate(long struct) { + check(memGetAddress(struct + STBTTPackRange.CHARDATA_FOR_RANGE)); + } + + /** + * Calls {@link #validate(long)} for each struct contained in the specified struct array. + * + * @param array the struct array to validate + * @param count the number of structs in {@code array} + */ + public static void validate(long array, int count) { + for (int i = 0; i < count; i++) { + validate(array + Integer.toUnsignedLong(i) * SIZEOF); + } + } + + // ----------------------------------- + + /** An array of {@link STBTTPackRange} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected STBTTPackRange getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code font_size} field. */ + public float font_size() { return STBTTPackRange.nfont_size(address()); } + /** Returns the value of the {@code first_unicode_codepoint_in_range} field. */ + public int first_unicode_codepoint_in_range() { return STBTTPackRange.nfirst_unicode_codepoint_in_range(address()); } + /** Returns a {@link IntBuffer} view of the data pointed to by the {@code array_of_unicode_codepoints} field. */ + @Nullable + @NativeType("int *") + public IntBuffer array_of_unicode_codepoints() { return STBTTPackRange.narray_of_unicode_codepoints(address()); } + /** Returns the value of the {@code num_chars} field. */ + public int num_chars() { return STBTTPackRange.nnum_chars(address()); } + /** Returns a {@link STBTTPackedchar.Buffer} view of the struct array pointed to by the {@code chardata_for_range} field. */ + @NativeType("stbtt_packedchar *") + public STBTTPackedchar.Buffer chardata_for_range() { return STBTTPackRange.nchardata_for_range(address()); } + /** Returns the value of the {@code h_oversample} field. */ + @NativeType("unsigned char") + public byte h_oversample() { return STBTTPackRange.nh_oversample(address()); } + /** Returns the value of the {@code v_oversample} field. */ + @NativeType("unsigned char") + public byte v_oversample() { return STBTTPackRange.nv_oversample(address()); } + + /** Sets the specified value to the {@code font_size} field. */ + public Buffer font_size(float value) { STBTTPackRange.nfont_size(address(), value); return this; } + /** Sets the specified value to the {@code first_unicode_codepoint_in_range} field. */ + public Buffer first_unicode_codepoint_in_range(int value) { STBTTPackRange.nfirst_unicode_codepoint_in_range(address(), value); return this; } + /** Sets the address of the specified {@link IntBuffer} to the {@code array_of_unicode_codepoints} field. */ + public Buffer array_of_unicode_codepoints(@Nullable @NativeType("int *") IntBuffer value) { STBTTPackRange.narray_of_unicode_codepoints(address(), value); return this; } + /** Sets the specified value to the {@code num_chars} field. */ + public Buffer num_chars(int value) { STBTTPackRange.nnum_chars(address(), value); return this; } + /** Sets the address of the specified {@link STBTTPackedchar.Buffer} to the {@code chardata_for_range} field. */ + public Buffer chardata_for_range(@NativeType("stbtt_packedchar *") STBTTPackedchar.Buffer value) { STBTTPackRange.nchardata_for_range(address(), value); return this; } + /** Sets the specified value to the {@code h_oversample} field. */ + public Buffer h_oversample(@NativeType("unsigned char") byte value) { STBTTPackRange.nh_oversample(address(), value); return this; } + /** Sets the specified value to the {@code v_oversample} field. */ + public Buffer v_oversample(@NativeType("unsigned char") byte value) { STBTTPackRange.nv_oversample(address(), value); return this; } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTPackedchar.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTPackedchar.java new file mode 100644 index 00000000..2fb03507 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTPackedchar.java @@ -0,0 +1,439 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.MemoryStack.*; + +/** + * Packed character data, returned by {@link STBTruetype#stbtt_PackFontRange PackFontRange} + * + *
+ * struct stbtt_packedchar {
+ * unsigned short x0;
+ * unsigned short y0;
+ * unsigned short x1;
+ * unsigned short y1;
+ * float xoff;
+ * float yoff;
+ * float xadvance;
+ * float xoff2;
+ * float yoff2;
+ * }The created instance holds a strong reference to the container object.
+ */ + public STBTTPackedchar(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code x0} field. */ + @NativeType("unsigned short") + public short x0() { return nx0(address()); } + /** Returns the value of the {@code y0} field. */ + @NativeType("unsigned short") + public short y0() { return ny0(address()); } + /** Returns the value of the {@code x1} field. */ + @NativeType("unsigned short") + public short x1() { return nx1(address()); } + /** Returns the value of the {@code y1} field. */ + @NativeType("unsigned short") + public short y1() { return ny1(address()); } + /** Returns the value of the {@code xoff} field. */ + public float xoff() { return nxoff(address()); } + /** Returns the value of the {@code yoff} field. */ + public float yoff() { return nyoff(address()); } + /** Returns the value of the {@code xadvance} field. */ + public float xadvance() { return nxadvance(address()); } + /** Returns the value of the {@code xoff2} field. */ + public float xoff2() { return nxoff2(address()); } + /** Returns the value of the {@code yoff2} field. */ + public float yoff2() { return nyoff2(address()); } + + /** Sets the specified value to the {@code x0} field. */ + public STBTTPackedchar x0(@NativeType("unsigned short") short value) { nx0(address(), value); return this; } + /** Sets the specified value to the {@code y0} field. */ + public STBTTPackedchar y0(@NativeType("unsigned short") short value) { ny0(address(), value); return this; } + /** Sets the specified value to the {@code x1} field. */ + public STBTTPackedchar x1(@NativeType("unsigned short") short value) { nx1(address(), value); return this; } + /** Sets the specified value to the {@code y1} field. */ + public STBTTPackedchar y1(@NativeType("unsigned short") short value) { ny1(address(), value); return this; } + /** Sets the specified value to the {@code xoff} field. */ + public STBTTPackedchar xoff(float value) { nxoff(address(), value); return this; } + /** Sets the specified value to the {@code yoff} field. */ + public STBTTPackedchar yoff(float value) { nyoff(address(), value); return this; } + /** Sets the specified value to the {@code xadvance} field. */ + public STBTTPackedchar xadvance(float value) { nxadvance(address(), value); return this; } + /** Sets the specified value to the {@code xoff2} field. */ + public STBTTPackedchar xoff2(float value) { nxoff2(address(), value); return this; } + /** Sets the specified value to the {@code yoff2} field. */ + public STBTTPackedchar yoff2(float value) { nyoff2(address(), value); return this; } + + /** Initializes this struct with the specified values. */ + public STBTTPackedchar set( + short x0, + short y0, + short x1, + short y1, + float xoff, + float yoff, + float xadvance, + float xoff2, + float yoff2 + ) { + x0(x0); + y0(y0); + x1(x1); + y1(y1); + xoff(xoff); + yoff(yoff); + xadvance(xadvance); + xoff2(xoff2); + yoff2(yoff2); + + return this; + } + + /** + * Copies the specified struct data to this struct. + * + * @param src the source struct + * + * @return this struct + */ + public STBTTPackedchar set(STBTTPackedchar src) { + memCopy(src.address(), address(), SIZEOF); + return this; + } + + // ----------------------------------- + + /** Returns a new {@code STBTTPackedchar} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static STBTTPackedchar malloc() { + return wrap(STBTTPackedchar.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code STBTTPackedchar} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static STBTTPackedchar calloc() { + return wrap(STBTTPackedchar.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code STBTTPackedchar} instance allocated with {@link BufferUtils}. */ + public static STBTTPackedchar create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(STBTTPackedchar.class, memAddress(container), container); + } + + /** Returns a new {@code STBTTPackedchar} instance for the specified memory address. */ + public static STBTTPackedchar create(long address) { + return wrap(STBTTPackedchar.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static STBTTPackedchar createSafe(long address) { + return address == NULL ? null : wrap(STBTTPackedchar.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code STBTTPackedchar} instance allocated on the thread-local {@link MemoryStack}. */ + public static STBTTPackedchar mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code STBTTPackedchar} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static STBTTPackedchar callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code STBTTPackedchar} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static STBTTPackedchar mallocStack(MemoryStack stack) { + return wrap(STBTTPackedchar.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code STBTTPackedchar} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static STBTTPackedchar callocStack(MemoryStack stack) { + return wrap(STBTTPackedchar.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #x0}. */ + public static short nx0(long struct) { return UNSAFE.getShort(null, struct + STBTTPackedchar.X0); } + /** Unsafe version of {@link #y0}. */ + public static short ny0(long struct) { return UNSAFE.getShort(null, struct + STBTTPackedchar.Y0); } + /** Unsafe version of {@link #x1}. */ + public static short nx1(long struct) { return UNSAFE.getShort(null, struct + STBTTPackedchar.X1); } + /** Unsafe version of {@link #y1}. */ + public static short ny1(long struct) { return UNSAFE.getShort(null, struct + STBTTPackedchar.Y1); } + /** Unsafe version of {@link #xoff}. */ + public static float nxoff(long struct) { return UNSAFE.getFloat(null, struct + STBTTPackedchar.XOFF); } + /** Unsafe version of {@link #yoff}. */ + public static float nyoff(long struct) { return UNSAFE.getFloat(null, struct + STBTTPackedchar.YOFF); } + /** Unsafe version of {@link #xadvance}. */ + public static float nxadvance(long struct) { return UNSAFE.getFloat(null, struct + STBTTPackedchar.XADVANCE); } + /** Unsafe version of {@link #xoff2}. */ + public static float nxoff2(long struct) { return UNSAFE.getFloat(null, struct + STBTTPackedchar.XOFF2); } + /** Unsafe version of {@link #yoff2}. */ + public static float nyoff2(long struct) { return UNSAFE.getFloat(null, struct + STBTTPackedchar.YOFF2); } + + /** Unsafe version of {@link #x0(short) x0}. */ + public static void nx0(long struct, short value) { UNSAFE.putShort(null, struct + STBTTPackedchar.X0, value); } + /** Unsafe version of {@link #y0(short) y0}. */ + public static void ny0(long struct, short value) { UNSAFE.putShort(null, struct + STBTTPackedchar.Y0, value); } + /** Unsafe version of {@link #x1(short) x1}. */ + public static void nx1(long struct, short value) { UNSAFE.putShort(null, struct + STBTTPackedchar.X1, value); } + /** Unsafe version of {@link #y1(short) y1}. */ + public static void ny1(long struct, short value) { UNSAFE.putShort(null, struct + STBTTPackedchar.Y1, value); } + /** Unsafe version of {@link #xoff(float) xoff}. */ + public static void nxoff(long struct, float value) { UNSAFE.putFloat(null, struct + STBTTPackedchar.XOFF, value); } + /** Unsafe version of {@link #yoff(float) yoff}. */ + public static void nyoff(long struct, float value) { UNSAFE.putFloat(null, struct + STBTTPackedchar.YOFF, value); } + /** Unsafe version of {@link #xadvance(float) xadvance}. */ + public static void nxadvance(long struct, float value) { UNSAFE.putFloat(null, struct + STBTTPackedchar.XADVANCE, value); } + /** Unsafe version of {@link #xoff2(float) xoff2}. */ + public static void nxoff2(long struct, float value) { UNSAFE.putFloat(null, struct + STBTTPackedchar.XOFF2, value); } + /** Unsafe version of {@link #yoff2(float) yoff2}. */ + public static void nyoff2(long struct, float value) { UNSAFE.putFloat(null, struct + STBTTPackedchar.YOFF2, value); } + + // ----------------------------------- + + /** An array of {@link STBTTPackedchar} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected STBTTPackedchar getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code x0} field. */ + @NativeType("unsigned short") + public short x0() { return STBTTPackedchar.nx0(address()); } + /** Returns the value of the {@code y0} field. */ + @NativeType("unsigned short") + public short y0() { return STBTTPackedchar.ny0(address()); } + /** Returns the value of the {@code x1} field. */ + @NativeType("unsigned short") + public short x1() { return STBTTPackedchar.nx1(address()); } + /** Returns the value of the {@code y1} field. */ + @NativeType("unsigned short") + public short y1() { return STBTTPackedchar.ny1(address()); } + /** Returns the value of the {@code xoff} field. */ + public float xoff() { return STBTTPackedchar.nxoff(address()); } + /** Returns the value of the {@code yoff} field. */ + public float yoff() { return STBTTPackedchar.nyoff(address()); } + /** Returns the value of the {@code xadvance} field. */ + public float xadvance() { return STBTTPackedchar.nxadvance(address()); } + /** Returns the value of the {@code xoff2} field. */ + public float xoff2() { return STBTTPackedchar.nxoff2(address()); } + /** Returns the value of the {@code yoff2} field. */ + public float yoff2() { return STBTTPackedchar.nyoff2(address()); } + + /** Sets the specified value to the {@code x0} field. */ + public Buffer x0(@NativeType("unsigned short") short value) { STBTTPackedchar.nx0(address(), value); return this; } + /** Sets the specified value to the {@code y0} field. */ + public Buffer y0(@NativeType("unsigned short") short value) { STBTTPackedchar.ny0(address(), value); return this; } + /** Sets the specified value to the {@code x1} field. */ + public Buffer x1(@NativeType("unsigned short") short value) { STBTTPackedchar.nx1(address(), value); return this; } + /** Sets the specified value to the {@code y1} field. */ + public Buffer y1(@NativeType("unsigned short") short value) { STBTTPackedchar.ny1(address(), value); return this; } + /** Sets the specified value to the {@code xoff} field. */ + public Buffer xoff(float value) { STBTTPackedchar.nxoff(address(), value); return this; } + /** Sets the specified value to the {@code yoff} field. */ + public Buffer yoff(float value) { STBTTPackedchar.nyoff(address(), value); return this; } + /** Sets the specified value to the {@code xadvance} field. */ + public Buffer xadvance(float value) { STBTTPackedchar.nxadvance(address(), value); return this; } + /** Sets the specified value to the {@code xoff2} field. */ + public Buffer xoff2(float value) { STBTTPackedchar.nxoff2(address(), value); return this; } + /** Sets the specified value to the {@code yoff2} field. */ + public Buffer yoff2(float value) { STBTTPackedchar.nyoff2(address(), value); return this; } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTVertex.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTVertex.java new file mode 100644 index 00000000..5c5d7651 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTTVertex.java @@ -0,0 +1,331 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; +import org.lwjgl.system.*; + +import static org.lwjgl.system.MemoryUtil.*; +import static org.lwjgl.system.MemoryStack.*; + +/** + * Vertex data. + * + *
+ * struct stbtt_vertex {
+ * stbtt_vertex_type x;
+ * stbtt_vertex_type y;
+ * stbtt_vertex_type cx;
+ * stbtt_vertex_type cy;
+ * stbtt_vertex_type cx1;
+ * stbtt_vertex_type cy1;
+ * unsigned char type;
+ * }The created instance holds a strong reference to the container object.
+ */ + public STBTTVertex(ByteBuffer container) { + super(memAddress(container), __checkContainer(container, SIZEOF)); + } + + @Override + public int sizeof() { return SIZEOF; } + + /** Returns the value of the {@code x} field. */ + @NativeType("stbtt_vertex_type") + public short x() { return nx(address()); } + /** Returns the value of the {@code y} field. */ + @NativeType("stbtt_vertex_type") + public short y() { return ny(address()); } + /** Returns the value of the {@code cx} field. */ + @NativeType("stbtt_vertex_type") + public short cx() { return ncx(address()); } + /** Returns the value of the {@code cy} field. */ + @NativeType("stbtt_vertex_type") + public short cy() { return ncy(address()); } + /** Returns the value of the {@code cx1} field. */ + @NativeType("stbtt_vertex_type") + public short cx1() { return ncx1(address()); } + /** Returns the value of the {@code cy1} field. */ + @NativeType("stbtt_vertex_type") + public short cy1() { return ncy1(address()); } + /** Returns the value of the {@code type} field. */ + @NativeType("unsigned char") + public byte type() { return ntype(address()); } + + // ----------------------------------- + + /** Returns a new {@code STBTTVertex} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */ + public static STBTTVertex malloc() { + return wrap(STBTTVertex.class, nmemAllocChecked(SIZEOF)); + } + + /** Returns a new {@code STBTTVertex} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */ + public static STBTTVertex calloc() { + return wrap(STBTTVertex.class, nmemCallocChecked(1, SIZEOF)); + } + + /** Returns a new {@code STBTTVertex} instance allocated with {@link BufferUtils}. */ + public static STBTTVertex create() { + ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF); + return wrap(STBTTVertex.class, memAddress(container), container); + } + + /** Returns a new {@code STBTTVertex} instance for the specified memory address. */ + public static STBTTVertex create(long address) { + return wrap(STBTTVertex.class, address); + } + + /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static STBTTVertex createSafe(long address) { + return address == NULL ? null : wrap(STBTTVertex.class, address); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer malloc(int capacity) { + return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. + * + * @param capacity the buffer capacity + */ + public static Buffer calloc(int capacity) { + return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated with {@link BufferUtils}. + * + * @param capacity the buffer capacity + */ + public static Buffer create(int capacity) { + ByteBuffer container = __create(capacity, SIZEOF); + return wrap(Buffer.class, memAddress(container), capacity, container); + } + + /** + * Create a {@link Buffer} instance at the specified memory. + * + * @param address the memory address + * @param capacity the buffer capacity + */ + public static Buffer create(long address, int capacity) { + return wrap(Buffer.class, address, capacity); + } + + /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */ + @Nullable + public static Buffer createSafe(long address, int capacity) { + return address == NULL ? null : wrap(Buffer.class, address, capacity); + } + + // ----------------------------------- + + /** Returns a new {@code STBTTVertex} instance allocated on the thread-local {@link MemoryStack}. */ + public static STBTTVertex mallocStack() { + return mallocStack(stackGet()); + } + + /** Returns a new {@code STBTTVertex} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */ + public static STBTTVertex callocStack() { + return callocStack(stackGet()); + } + + /** + * Returns a new {@code STBTTVertex} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + */ + public static STBTTVertex mallocStack(MemoryStack stack) { + return wrap(STBTTVertex.class, stack.nmalloc(ALIGNOF, SIZEOF)); + } + + /** + * Returns a new {@code STBTTVertex} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + */ + public static STBTTVertex callocStack(MemoryStack stack) { + return wrap(STBTTVertex.class, stack.ncalloc(ALIGNOF, 1, SIZEOF)); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack}. + * + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity) { + return mallocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. + * + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity) { + return callocStack(capacity, stackGet()); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack}. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer mallocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity); + } + + /** + * Returns a new {@link Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero. + * + * @param stack the stack from which to allocate + * @param capacity the buffer capacity + */ + public static Buffer callocStack(int capacity, MemoryStack stack) { + return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity); + } + + // ----------------------------------- + + /** Unsafe version of {@link #x}. */ + public static short nx(long struct) { return UNSAFE.getShort(null, struct + STBTTVertex.X); } + /** Unsafe version of {@link #y}. */ + public static short ny(long struct) { return UNSAFE.getShort(null, struct + STBTTVertex.Y); } + /** Unsafe version of {@link #cx}. */ + public static short ncx(long struct) { return UNSAFE.getShort(null, struct + STBTTVertex.CX); } + /** Unsafe version of {@link #cy}. */ + public static short ncy(long struct) { return UNSAFE.getShort(null, struct + STBTTVertex.CY); } + /** Unsafe version of {@link #cx1}. */ + public static short ncx1(long struct) { return UNSAFE.getShort(null, struct + STBTTVertex.CX1); } + /** Unsafe version of {@link #cy1}. */ + public static short ncy1(long struct) { return UNSAFE.getShort(null, struct + STBTTVertex.CY1); } + /** Unsafe version of {@link #type}. */ + public static byte ntype(long struct) { return UNSAFE.getByte(null, struct + STBTTVertex.TYPE); } + + // ----------------------------------- + + /** An array of {@link STBTTVertex} structs. */ + public static class Buffer extends StructBufferThe created buffer instance holds a strong reference to the container object.
+ */ + public Buffer(ByteBuffer container) { + super(container, container.remaining() / SIZEOF); + } + + public Buffer(long address, int cap) { + super(address, null, -1, 0, cap, cap); + } + + Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) { + super(address, container, mark, pos, lim, cap); + } + + @Override + protected Buffer self() { + return this; + } + + @Override + protected STBTTVertex getElementFactory() { + return ELEMENT_FACTORY; + } + + /** Returns the value of the {@code x} field. */ + @NativeType("stbtt_vertex_type") + public short x() { return STBTTVertex.nx(address()); } + /** Returns the value of the {@code y} field. */ + @NativeType("stbtt_vertex_type") + public short y() { return STBTTVertex.ny(address()); } + /** Returns the value of the {@code cx} field. */ + @NativeType("stbtt_vertex_type") + public short cx() { return STBTTVertex.ncx(address()); } + /** Returns the value of the {@code cy} field. */ + @NativeType("stbtt_vertex_type") + public short cy() { return STBTTVertex.ncy(address()); } + /** Returns the value of the {@code cx1} field. */ + @NativeType("stbtt_vertex_type") + public short cx1() { return STBTTVertex.ncx1(address()); } + /** Returns the value of the {@code cy1} field. */ + @NativeType("stbtt_vertex_type") + public short cy1() { return STBTTVertex.ncy1(address()); } + /** Returns the value of the {@code type} field. */ + @NativeType("unsigned char") + public byte type() { return STBTTVertex.ntype(address()); } + + } + +} \ No newline at end of file diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTruetype.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTruetype.java new file mode 100644 index 00000000..ce3ffc00 --- /dev/null +++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBTruetype.java @@ -0,0 +1,2157 @@ +/* + * Copyright LWJGL. All rights reserved. + * License terms: https://www.lwjgl.org/license + * MACHINE GENERATED FILE, DO NOT EDIT + */ +package org.lwjgl.stb; + +import javax.annotation.*; + +import java.nio.*; + +import org.lwjgl.*; + +import org.lwjgl.system.*; + +import static org.lwjgl.system.Checks.*; +import static org.lwjgl.system.MemoryStack.*; +import static org.lwjgl.system.MemoryUtil.*; + +/** + * Native bindings to stb_truetype.h from the stb library. + * + *This library processes TrueType files:
+ * + *Some important concepts to understand to use this library:
+ * + *Characters are defined by unicode codepoints, e.g. 65 is uppercase A, 231 is lowercase c with a cedilla, 0x7e30 is the hiragana for "ma".
+ * + *A visual character shape (every codepoint is rendered as some glyph)
+ * + *A font-specific integer ID representing a glyph
+ * + *Glyph shapes are defined relative to a baseline, which is the bottom of uppercase characters. Characters extend both above and below the baseline.
+ * + *As you draw text to the screen, you keep track of a "current point" which is the origin of each character. The current point's vertical position is the + * baseline. Even "baked fonts" use this model.
+ * + *The vertical qualities of the font, used to vertically position and space the characters. See docs for {@link #stbtt_GetFontVMetrics GetFontVMetrics}.
+ * + *The preferred interface for specifying font sizes in stb_truetype is to specify how tall the font's vertical extent should be in pixels. If that sounds + * good enough, skip the next paragraph.
+ * + *Most font APIs instead use "points", which are a common typographic measurement for describing font size, defined as 72 points per inch. stb_truetype + * provides a point API for compatibility. However, true "per inch" conventions don't make much sense on computer displays since different monitors have + * different number of pixels per inch. For example, Windows traditionally uses a convention that there are 96 pixels per inch, thus making 'inch' + * measurements have nothing to do with inches, and thus effectively defining a point to be 1.333 pixels. Additionally, the TrueType font data provides an + * explicit scale factor to scale a given font's glyphs to points, but the author has observed that this scale factor is often wrong for non-commercial + * fonts, thus making fonts scaled in points according to the TrueType spec incoherently sized in practice.
+ * + *Select how high you want the font to be, in points or pixels. Call #()ScaleForPixelHeight or {@link #stbtt_ScaleForMappingEmToPixels ScaleForMappingEmToPixels} to compute a scale factor + * {@code SF} that will be used by all other functions.
+ * + *You need to select a y-coordinate that is the baseline of where your text will appear. Call {@link #stbtt_GetFontBoundingBox GetFontBoundingBox} to get the baseline-relative bounding + * box for all characters. {@code SF*-y0} will be the distance in pixels that the worst-case character could extend above the baseline, so if you want the + * top edge of characters to appear at the top of the screen where {@code y=0}, then you would set the baseline to {@code SF*-y0}.
+ * + *Set the current point where the first character will appear. The first character could extend left of the current point; this is font dependent. You + * can either choose a current point that is the leftmost point and hope, or add some padding, or check the bounding box or left-side-bearing of the first + * character to be displayed and set the current point based on that.
+ * + *Compute the bounding box of the character. It will contain signed values relative to {@code Call {@link #stbtt_GetGlyphHMetrics GetGlyphHMetrics}, and compute {@code current_point += SF * advance}. Quality: Performance: The system uses the raw data found in the .ttf file without changing it and without building auxiliary data structures. This is a bit inefficient on
+ * little-endian systems (the data is big-endian), but assuming you're caching the bitmaps or glyph shapes this shouldn't be a big deal. It appears to be very hard to programmatically determine what font a given file is in a general way. I provide an API for this, but I don't recommend
+ * it. Incomplete text-in-3d-api example, which draws quads properly aligned to be lossless: Complete program (this compiles): get a single bitmap, print as ASCII art: Complete program: print "Hello World!" banner, with bugs: You should really just solve this offline, keep your own tables of what font is what, and don't try to get it out of the .ttf file. That's because
+ * getting it out of the .ttf file is really hard, because the names in the file can appear in many possible encodings, in many possible languages, and
+ * e.g. if you need a case-insensitive comparison, the details of that depend on the encoding & language in a complex way (actually underspecified in
+ * truetype, but also gigantic). But you can use the provided functions in two possible ways: This uses a very simply packing, use with {@link #stbtt_GetBakedQuad GetBakedQuad}. The coordinate system used assumes y increases downwards. Characters will extend both above and below the current position; see discussion of
+ * "BASELINE" above. This function sets the amount of oversampling for all following calls to {@link #stbtt_PackFontRange PackFontRange} or {@link #stbtt_PackFontRangesGatherRects PackFontRangesGatherRects} for a given pack context. The
+ * default (no oversampling) is achieved by {@code h_oversample=1, v_oversample=1}. The total number of pixels required is
+ * {@code h_oversample*v_oversample} larger than the default; for example, 2x2 oversampling requires 4x the storage of 1x1. For best results, render
+ * oversampled textures with bilinear filtering. Look at the readme in
+ * stb/tests/oversample for information about oversampled fonts. To use with PackFontRangesGather etc., you must set it before calls to {@link #stbtt_PackFontRangesGatherRects PackFontRangesGatherRects}. The coordinate system used assumes y increases downwards. Characters will extend both above and below the current position; see discussion of
+ * "BASELINE" above. TrueType collection (.ttc) files may contain multiple fonts, while TrueType font (.ttf) files only contain one font. The number of fonts can be used
+ * for indexing with {@link #stbtt_GetFontOffsetForIndex GetFontOffsetForIndex} where the index is between zero and one less than the total fonts. If an error occurs, -1 is returned. so if you prefer to measure height by the ascent only, use a similar calculation. The returned values are expressed in unscaled coordinates, so you must multiply by the scale factor for a given size. The returned values are expressed in unscaled coordinates. The shape is a series of contours. Each one starts with a {@link #STBTT_vmove vmove}, then consists of a series of mixed {@link #STBTT_vline vline} and {@link #STBTT_vcurve vcurve} segments. A {@link #STBTT_vline vline} draws a
+ * line from previous endpoint to its {@code x,y}; a {@link #STBTT_vcurve vcurve} draws a quadratic bezier from previous endpoint to its {@code x,y}, using {@code cx,cy} as
+ * the bezier control point. The {@link STBTTVertex} values are expressed in "unscaled" coordinates. The shape is a series of contours. Each one starts with a {@link #STBTT_vmove vmove}, then consists of a series of mixed {@link #STBTT_vline vline} and {@link #STBTT_vcurve vcurve} segments. A {@link #STBTT_vline vline} draws a
+ * line from previous endpoint to its {@code x,y}; a {@link #STBTT_vcurve vcurve} draws a quadratic bezier from previous endpoint to its {@code x,y}, using {@code cx,cy} as
+ * the bezier control point. The {@link STBTTVertex} values are expressed in "unscaled" coordinates. Note that the bitmap uses y-increases-down, but the shape uses y-increases-up, so {@code CodepointBitmapBox} and {@code CodepointBox} are inverted. Note that the bitmap uses y-increases-down, but the shape uses y-increases-up, so {@code GlyphBitmapBox} and {@code GlyphBox} are inverted. {@code pixel_dist_scale} & {@code onedge_value} are a scale & bias that allows you to make optimal use of the limited {@code 0..255} for your
+ * application, trading off precision and special effects. SDF values outside the range {@code 0..255} are clamped to {@code 0..255}. Example: This will create an SDF bitmap in which the character is about 22 pixels high but the whole bitmap is about {@code 22+5+5=32} pixels high. To produce a
+ * filled shape, sample the SDF at each pixel and fill the pixel if the SDF value is greater than or equal to {@code 180/255}. (You'll actually want to
+ * antialias, which is beyond the scope of this example.) Additionally, you can compute offset outlines (e.g. to stroke the character border inside &
+ * outside, or only outside). For example, to fill outside the character up to 3 SDF pixels, you would compare against {@code (180-36.0*3)/255 = 72/255}.
+ * The above choice of variables maps a range from 5 pixels outside the shape to 2 pixels inside the shape to {@code 0..255}; this is intended primarily
+ * for apply outside effects only (the interior range is needed to allow proper antialiasing of the font at smaller sizes). The function computes the SDF analytically at each SDF pixel, not by e.g. building a higher-res bitmap and approximating it. In theory the quality
+ * should be as high as possible for an SDF of this size & representation, but unclear if this is true in practice (perhaps building a higher-res
+ * bitmap and computing from that can allow drop-out prevention). The algorithm has not been optimized at all, so expect it to be slow if computing lots of characters or very large sizes. If you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold". If you use any other flag, use a font name like "Arial"; this checks the
+ * {@code macStyle} header field; I don't know if fonts set this consistently. If you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold". If you use any other flag, use a font name like "Arial"; this checks the
+ * {@code macStyle} header field; I don't know if fonts set this consistently. See the truetype spec: Ogg Vorbis audio decoder. Individual stb_vorbis* handles are not thread-safe; you cannot decode from them from multiple threads at the same time. However, you can have multiple
+ * {@code stb_vorbis*} handles and decode from them independently in multiple threads. This API allows you to get blocks of data from any source and hand them to stb_vorbis. you have to buffer them; stb_vorbis will tell you how much it
+ * used, and you have to give it the rest next time; and stb_vorbis may not have enough data to work with and you will need to give it the same data
+ * again PLUS more. Note that the Vorbis specification does not bound the size of an individual frame. This API assumes stb_vorbis is allowed to pull data from a source -- either a block of memory containing the _entire_ vorbis stream, or a FILE * that
+ * you or it create, or possibly some other reading mechanism if you go modify the source to replace the FILE * case with some kind of callback to your
+ * code. (But if you don't support seeking, you may just want to go ahead and use pushdata.) NOT WORKING YET after a seek with PULLDATA API. Note that on resynch, stb_vorbis will rarely consume all of the buffer, instead only {@code datablock_length_in_bytes-3} or less. This is because it
+ * wants to avoid missing parts of a page header if they cross a datablock boundary, without writing state-machiney code to record a partial detection. The number of channels returned are stored in *channels (which can be {@code NULL} -- it is always the same as the number of channels reported by {@link #stb_vorbis_get_info get_info}).
+ * {@code *output} will contain an array of {@code float*} buffers, one per channel. In other words, {@code (*output)[0][0]} contains the first sample
+ * from the first channel, and {@code (*output)[1][0]} contains the first sample from the second channel. Note that after opening a file, you will ALWAYS get one N-bytes,0-sample frame, because Vorbis always "discards" the first frame. If you want to seek using pushdata, you need to seek in your file, then call stb_vorbis_flush_pushdata(), then start calling decoding, then once
+ * decoding is returning you data, call {@link #stb_vorbis_get_sample_offset get_sample_offset}, and if you don't like the result, seek your file again and repeat. You generally should not intermix calls to {@code stb_vorbis_get_frame_*()} and {@code stb_vorbis_get_samples_*()}, since the latter calls the former. The data is coerced to the number of channels you request according to the channel coercion rules (see below). You must pass in the size of your
+ * buffer(s) so that stb_vorbis will not overwrite the end of the buffer. The maximum buffer size needed can be gotten from {@link #stb_vorbis_get_info get_info}; however, the
+ * Vorbis I specification implies an absolute maximum of 4096 samples per channel. Let M be the number of channels requested, and N the number of channels present, and Cn be the nth channel; let stereo L be the sum of all L and center
+ * channels, and stereo R be the sum of all R and center channels (channel assignment from the vorbis spec). Note that this is not good surround etc. mixing at all! It's just so you get something useful. Note that for interleaved data, you pass in the number of shorts (the size of your array), but the return value is the number of samples per channel,
+ * not the total number of samples. The created instance holds a strong reference to the container object. The created buffer instance holds a strong reference to the container object. The created instance holds a strong reference to the container object. The created buffer instance holds a strong reference to the container object. The functionality provided by stb includes: Method names in this class are prefixed with {@code api} to avoid ambiguities when used with static imports. This method is useful when debugging to quickly identify values returned from an API. The encoded buffers must be freed with {@link #apiArrayFree}. The encoded buffers must be freed with {@link #apiArrayFree}. Callback instances use native resources and must be explicitly freed when no longer used by calling the {@link #free} method. The native function uses the default calling convention. Base interface for dynamically created native functions that call into Java code. Pointers to such functions can be passed to native APIs as callbacks. This interface does not define a callback method, therefore it should not be implemented directly. The following inner interfaces should be used instead: On Java 9 these checks are replaced with the corresponding {@link java.util.Objects} methods, which perform better. Internal class, don't use. When enabled, LWJGL will perform basic checks during its operation, mainly to avoid crashes in native code. Examples of such checks are:
+ * context-specific function address validation, buffer capacity checks, null-termination checks, etc. These checks are generally low-overhead and should
+ * not have a measurable effect on performance, so its recommended to have them enabled both during development and in production releases. If maximum performance is required, they can be disabled by setting {@link Configuration#DISABLE_CHECKS} to true. When enabled, LWJGL will perform additional checks during its operation. These checks are more expensive than the ones enabled with {@link #CHECKS}
+ * and will have a noticeable effect on performance, so they are disabled by default. Examples of such checks are: buffer object binding state check (GL),
+ * buffer capacity checks for texture images (GL & CL), etc. LWJGL will also print additional information, mainly during start-up. Can be enabled by setting {@link Configuration#DEBUG} to true. When enabled, capabilities classes will print an error message when they fail to retrieve a function pointer. Can be enabled by setting {@link Configuration#DEBUG_FUNCTIONS} to true. Care must be taken when setting static options. Such options are only read once or cached in {@code static final} fields. They must be
+ * configured through this class before touching any other LWJGL class.
+ * Property: org.lwjgl.librarypath When set programmatically, it can also be a {@link Function Function<String, String>} instance.
+ * Property: org.lwjgl.system.bundledLibrary.nameMapperAdvancing for the next character:
+ *
+ * ADVANCED USAGE
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ * NOTES
+ *
+ * SAMPLE PROGRAMS
+ *
+ *
+ *
+ *
+ * unsigned char ttf_buffer[1<<20];
+ * unsigned char temp_bitmap[512*512];
+ *
+ * stbtt_bakedchar cdata[96]; // ASCII 32..126 is 95 glyphs
+ * GLuint ftex;
+ *
+ * void my_stbtt_initfont(void)
+ * {
+ * fread(ttf_buffer, 1, 1<<20, fopen("c:/windows/fonts/times.ttf", "rb"));
+ * stbtt_BakeFontBitmap(ttf_buffer,0, 32.0, temp_bitmap,512,512, 32,96, cdata); // no guarantee this fits!
+ * // can free ttf_buffer at this point
+ * glGenTextures(1, &ftex);
+ * glBindTexture(GL_TEXTURE_2D, ftex);
+ * glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 512,512, 0, GL_ALPHA, GL_UNSIGNED_BYTE, temp_bitmap);
+ * // can free temp_bitmap at this point
+ * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ * }
+ *
+ * void my_stbtt_print(float x, float y, char *text)
+ * {
+ * // assume orthographic projection with units = screen pixels, origin at top left
+ * glEnable(GL_TEXTURE_2D);
+ * glBindTexture(GL_TEXTURE_2D, ftex);
+ * glBegin(GL_QUADS);
+ * while (*text) {
+ * if (*text >= 32 && *text < 128) {
+ * stbtt_aligned_quad q;
+ * stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);//1=opengl & d3d10+,0=d3d9
+ * glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y0);
+ * glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y0);
+ * glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y1);
+ * glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y1);
+ * }
+ * ++text;
+ * }
+ * glEnd();
+ * }
+ *
+ *
+ * char ttf_buffer[1<<25];
+ *
+ * int main(int argc, char **argv)
+ * {
+ * stbtt_fontinfo font;
+ * unsigned char *bitmap;
+ * int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) : 'a'), s = (argc > 2 ? atoi(argv[2]) : 20);
+ *
+ * fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] : "c:/windows/fonts/arialbd.ttf", "rb"));
+ *
+ * stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0));
+ * bitmap = stbtt_GetCodepointBitmap(&font, 0,stbtt_ScaleForPixelHeight(&font, s), c, &w, &h, 0,0);
+ *
+ * for (j=0; j < h; ++j) {
+ * for (i=0; i < w; ++i)
+ * putchar(" .:ioVM@"[bitmap[j*w+i]>>5]);
+ * putchar('\n');
+ * }
+ * return 0;
+ * }
+ *
+ *
+ * char buffer[24<<20];
+ * unsigned char screen[20][79];
+ *
+ * int main(int arg, char **argv)
+ * {
+ * stbtt_fontinfo font;
+ * int i,j,ascent,baseline,ch=0;
+ * float scale, xpos=2; // leave a little padding in case the character extends left
+ * char *text = "Heljo World!";
+ *
+ * fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb"));
+ * stbtt_InitFont(&font, buffer, 0);
+ *
+ * scale = stbtt_ScaleForPixelHeight(&font, 15);
+ * stbtt_GetFontVMetrics(&font, &ascent,0,0);
+ * baseline = (int) (ascent*scale);
+ *
+ * while (text[ch]) {
+ * int advance,lsb,x0,y0,x1,y1;
+ * float x_shift = xpos - (float) floor(xpos);
+ * stbtt_GetCodepointHMetrics(&font, text[ch], &advance, &lsb);
+ * stbtt_GetCodepointBitmapBoxSubpixel(&font, text[ch], scale,scale,x_shift,0, &x0,&y0,&x1,&y1);
+ * stbtt_MakeCodepointBitmapSubpixel(&font, &screen[baseline + y0][(int) xpos + x0], x1-x0,y1-y0, 79, scale,scale,x_shift,0, text[ch]);
+ * // note that this stomps the old data, so where character boxes overlap (e.g. 'lj') it's wrong
+ * // because this API is really for baking character bitmaps into textures. if you want to render
+ * // a sequence of characters, you really need to render each bitmap to a temp buffer, then
+ * // "alpha blend" that into the working buffer
+ * xpos += (advance * scale);
+ * if (text[ch+1])
+ * xpos += scale*stbtt_GetCodepointKernAdvance(&font, text[ch],text[ch+1]);
+ * ++ch;
+ * }
+ *
+ * for (j=0; j < 20; ++j) {
+ * for (i=0; i < 78; ++i)
+ * putchar(" .:ioVM@"[screen[j][i]>>5]);
+ * putchar('\n');
+ * }
+ *
+ * return 0;
+ * }Finding the right font...
+ *
+ *
+ *
+ */
+public class STBTruetype {
+
+ /** Vertex type. */
+ public static final byte
+ STBTT_vmove = 1,
+ STBTT_vline = 2,
+ STBTT_vcurve = 3,
+ STBTT_vcubic = 4;
+
+ /** Style flags, use in {@link #stbtt_FindMatchingFont FindMatchingFont}. */
+ public static final int
+ STBTT_MACSTYLE_DONTCARE = 0,
+ STBTT_MACSTYLE_BOLD = 1,
+ STBTT_MACSTYLE_ITALIC = 2,
+ STBTT_MACSTYLE_UNDERSCORE = 4,
+ STBTT_MACSTYLE_NONE = 8;
+
+ /** Platform IDs. */
+ public static final int
+ STBTT_PLATFORM_ID_UNICODE = 0,
+ STBTT_PLATFORM_ID_MAC = 1,
+ STBTT_PLATFORM_ID_ISO = 2,
+ STBTT_PLATFORM_ID_MICROSOFT = 3;
+
+ /** Encoding IDs for {@link #STBTT_PLATFORM_ID_UNICODE PLATFORM_ID_UNICODE}. */
+ public static final int
+ STBTT_UNICODE_EID_UNICODE_1_0 = 0,
+ STBTT_UNICODE_EID_UNICODE_1_1 = 1,
+ STBTT_UNICODE_EID_ISO_10646 = 2,
+ STBTT_UNICODE_EID_UNICODE_2_0_BMP = 3,
+ STBTT_UNICODE_EID_UNICODE_2_0_FULL = 4;
+
+ /** Encoding IDs for {@link #STBTT_PLATFORM_ID_MICROSOFT PLATFORM_ID_MICROSOFT}. */
+ public static final int
+ STBTT_MS_EID_SYMBOL = 0,
+ STBTT_MS_EID_UNICODE_BMP = 1,
+ STBTT_MS_EID_SHIFTJIS = 2,
+ STBTT_MS_EID_UNICODE_FULL = 10;
+
+ /** Encoding IDs for {@link #STBTT_PLATFORM_ID_MAC PLATFORM_ID_MAC}. */
+ public static final int
+ STBTT_MAC_EID_ROMAN = 0,
+ STBTT_MAC_EID_JAPANESE = 1,
+ STBTT_MAC_EID_CHINESE_TRAD = 2,
+ STBTT_MAC_EID_KOREAN = 3,
+ STBTT_MAC_EID_ARABIC = 4,
+ STBTT_MAC_EID_HEBREW = 5,
+ STBTT_MAC_EID_GREEK = 6,
+ STBTT_MAC_EID_RUSSIAN = 7;
+
+ /** Language ID for {@link #STBTT_PLATFORM_ID_MICROSOFT PLATFORM_ID_MICROSOFT}. */
+ public static final int
+ STBTT_MS_LANG_ENGLISH = 0x409,
+ STBTT_MS_LANG_CHINESE = 0x804,
+ STBTT_MS_LANG_DUTCH = 0x413,
+ STBTT_MS_LANG_FRENCH = 0x40C,
+ STBTT_MS_LANG_GERMAN = 0x407,
+ STBTT_MS_LANG_HEBREW = 0x40D,
+ STBTT_MS_LANG_ITALIAN = 0x410,
+ STBTT_MS_LANG_JAPANESE = 0x411,
+ STBTT_MS_LANG_KOREAN = 0x412,
+ STBTT_MS_LANG_RUSSIAN = 0x419,
+ STBTT_MS_LANG_SPANISH = 0x409,
+ STBTT_MS_LANG_SWEDISH = 0x41D;
+
+ /** Language ID for {@link #STBTT_PLATFORM_ID_MAC PLATFORM_ID_MAC}. */
+ public static final int
+ STBTT_MAC_LANG_ENGLISH = 0,
+ STBTT_MAC_LANG_ARABIC = 12,
+ STBTT_MAC_LANG_DUTCH = 4,
+ STBTT_MAC_LANG_FRENCH = 1,
+ STBTT_MAC_LANG_GERMAN = 2,
+ STBTT_MAC_LANG_HEBREW = 10,
+ STBTT_MAC_LANG_ITALIAN = 3,
+ STBTT_MAC_LANG_JAPANESE = 11,
+ STBTT_MAC_LANG_KOREAN = 23,
+ STBTT_MAC_LANG_RUSSIAN = 32,
+ STBTT_MAC_LANG_SPANISH = 6,
+ STBTT_MAC_LANG_SWEDISH = 5,
+ STBTT_MAC_LANG_CHINESE_SIMPLIFIED = 33,
+ STBTT_MAC_LANG_CHINESE_TRAD = 19;
+
+ static { LibSTB.initialize(); }
+
+ protected STBTruetype() {
+ throw new UnsupportedOperationException();
+ }
+
+ // --- [ stbtt_BakeFontBitmap ] ---
+
+ /**
+ * Unsafe version of: {@link #stbtt_BakeFontBitmap BakeFontBitmap}
+ *
+ * @param num_chars the number of characters to bake, starting at {@code first_char}
+ */
+ public static native int nstbtt_BakeFontBitmap(long data, int offset, float pixel_height, long pixels, int pw, int ph, int first_char, int num_chars, long chardata);
+
+ /**
+ * Bakes a font to a bitmap for use as texture.
+ *
+ *
+ * @param first_unicode_char_in_range the first unicode code point in the range
+ * @param chardata_for_range an array of {@link STBTTPackedchar} structs
+ *
+ * @return 1 on success, 0 on failure
+ */
+ @NativeType("int")
+ public static boolean stbtt_PackFontRange(@NativeType("stbtt_pack_context *") STBTTPackContext spc, @NativeType("unsigned char const *") ByteBuffer fontdata, int font_index, float font_size, int first_unicode_char_in_range, @NativeType("stbtt_packedchar *") STBTTPackedchar.Buffer chardata_for_range) {
+ return nstbtt_PackFontRange(spc.address(), memAddress(fontdata), font_index, font_size, first_unicode_char_in_range, chardata_for_range.remaining(), chardata_for_range.address()) != 0;
+ }
+
+ // --- [ stbtt_PackFontRanges ] ---
+
+ /**
+ * Unsafe version of: {@link #stbtt_PackFontRanges PackFontRanges}
+ *
+ * @param num_ranges the number of {@link STBTTPackRange} structs in {@code ranges}
+ */
+ public static native int nstbtt_PackFontRanges(long spc, long fontdata, int font_index, long ranges, int num_ranges);
+
+ /**
+ * Creates character bitmaps from multiple ranges of characters stored in ranges. This will usually create a better-packed bitmap than multiple calls to
+ * {@link #stbtt_PackFontRange PackFontRange}. Note that you can call this multiple times within a single {@link #stbtt_PackBegin PackBegin}/{@link #stbtt_PackEnd PackEnd}.
+ *
+ * @param spc an {@link STBTTPackContext} struct
+ * @param fontdata the font data
+ * @param font_index the font index (use 0 if you don't know what that is)
+ * @param ranges an array of {@link STBTTPackRange} structs
+ *
+ * @return 1 on success, 0 on failure
+ */
+ @NativeType("int")
+ public static boolean stbtt_PackFontRanges(@NativeType("stbtt_pack_context *") STBTTPackContext spc, @NativeType("unsigned char const *") ByteBuffer fontdata, int font_index, @NativeType("stbtt_pack_range *") STBTTPackRange.Buffer ranges) {
+ if (CHECKS) {
+ STBTTPackRange.validate(ranges.address(), ranges.remaining());
+ }
+ return nstbtt_PackFontRanges(spc.address(), memAddress(fontdata), font_index, ranges.address(), ranges.remaining()) != 0;
+ }
+
+ // --- [ stbtt_PackSetOversampling ] ---
+
+ /** Unsafe version of: {@link #stbtt_PackSetOversampling PackSetOversampling} */
+ public static native void nstbtt_PackSetOversampling(long spc, int h_oversample, int v_oversample);
+
+ /**
+ * Oversampling a font increases the quality by allowing higher-quality subpixel positioning, and is especially valuable at smaller text sizes.
+ *
+ *
+ * ..., 20 , ... // font max minus min y is 20 pixels tall
+ * ..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall
+ *
+ *
+ * scale = pixels / (ascent - descent)
+ *
+ *
+ * scale = stbtt_ScaleForPixelHeight(22)
+ * padding = 5
+ * onedge_value = 180
+ * pixel_dist_scale = 180/5.0 = 36.0
+ */
+ public static int stbtt_FindMatchingFont(@NativeType("unsigned char const *") ByteBuffer fontdata, @NativeType("char const *") ByteBuffer name, int flags) {
+ if (CHECKS) {
+ checkNT1(name);
+ }
+ return nstbtt_FindMatchingFont(memAddress(fontdata), memAddress(name), flags);
+ }
+
+ /**
+ * Returns the offset (not index) of the font that matches, or -1 if none.
+ *
+ * {@link #STBTT_MACSTYLE_DONTCARE MACSTYLE_DONTCARE} {@link #STBTT_MACSTYLE_BOLD MACSTYLE_BOLD} {@link #STBTT_MACSTYLE_ITALIC MACSTYLE_ITALIC} {@link #STBTT_MACSTYLE_UNDERSCORE MACSTYLE_UNDERSCORE} {@link #STBTT_MACSTYLE_NONE MACSTYLE_NONE}
+ */
+ public static int stbtt_FindMatchingFont(@NativeType("unsigned char const *") ByteBuffer fontdata, @NativeType("char const *") CharSequence name, int flags) {
+ MemoryStack stack = stackGet(); int stackPointer = stack.getPointer();
+ try {
+ stack.nUTF8(name, true);
+ long nameEncoded = stack.getPointerAddress();
+ return nstbtt_FindMatchingFont(memAddress(fontdata), nameEncoded, flags);
+ } finally {
+ stack.setPointer(stackPointer);
+ }
+ }
+
+ // --- [ stbtt_CompareUTF8toUTF16_bigendian ] ---
+
+ /**
+ * Unsafe version of: {@link #stbtt_CompareUTF8toUTF16_bigendian CompareUTF8toUTF16_bigendian}
+ *
+ * @param len1 the length of the first string, in bytes
+ * @param len2 the length of the second string, in bytes
+ */
+ public static native int nstbtt_CompareUTF8toUTF16_bigendian(long s1, int len1, long s2, int len2);
+
+ /**
+ * Returns 1/0 whether the first string interpreted as utf8 is identical to the second string interpreted as big-endian utf16... useful for strings
+ * returned from {@link #stbtt_GetFontNameString GetFontNameString}.
+ *
+ * @param s1 the first string
+ * @param s2 the second string
+ */
+ @NativeType("int")
+ public static boolean stbtt_CompareUTF8toUTF16_bigendian(@NativeType("char const *") ByteBuffer s1, @NativeType("char const *") ByteBuffer s2) {
+ return nstbtt_CompareUTF8toUTF16_bigendian(memAddress(s1), s1.remaining(), memAddress(s2), s2.remaining()) != 0;
+ }
+
+ // --- [ stbtt_GetFontNameString ] ---
+
+ /**
+ * Unsafe version of: {@link #stbtt_GetFontNameString GetFontNameString}
+ *
+ * @param length returns the string length, in bytes
+ */
+ public static native long nstbtt_GetFontNameString(long font, long length, int platformID, int encodingID, int languageID, int nameID);
+
+ /**
+ * Returns the string (which may be big-endian double byte, e.g. for unicode) and puts the length in bytes in {@code *length}.
+ *
+ * {@link #STBTT_MACSTYLE_DONTCARE MACSTYLE_DONTCARE} {@link #STBTT_MACSTYLE_BOLD MACSTYLE_BOLD} {@link #STBTT_MACSTYLE_ITALIC MACSTYLE_ITALIC} {@link #STBTT_MACSTYLE_UNDERSCORE MACSTYLE_UNDERSCORE} {@link #STBTT_MACSTYLE_NONE MACSTYLE_NONE}
+ * @param encodingID the encoding ID. One of:{@link #STBTT_PLATFORM_ID_UNICODE PLATFORM_ID_UNICODE} {@link #STBTT_PLATFORM_ID_MAC PLATFORM_ID_MAC} {@link #STBTT_PLATFORM_ID_ISO PLATFORM_ID_ISO} {@link #STBTT_PLATFORM_ID_MICROSOFT PLATFORM_ID_MICROSOFT}
+ * @param languageID the language ID. One of:{@link #STBTT_UNICODE_EID_UNICODE_1_0 UNICODE_EID_UNICODE_1_0} {@link #STBTT_UNICODE_EID_UNICODE_1_1 UNICODE_EID_UNICODE_1_1} {@link #STBTT_UNICODE_EID_ISO_10646 UNICODE_EID_ISO_10646} {@link #STBTT_UNICODE_EID_UNICODE_2_0_BMP UNICODE_EID_UNICODE_2_0_BMP} {@link #STBTT_UNICODE_EID_UNICODE_2_0_FULL UNICODE_EID_UNICODE_2_0_FULL} {@link #STBTT_MS_EID_SYMBOL MS_EID_SYMBOL} {@link #STBTT_MS_EID_UNICODE_BMP MS_EID_UNICODE_BMP} {@link #STBTT_MS_EID_SHIFTJIS MS_EID_SHIFTJIS} {@link #STBTT_MS_EID_UNICODE_FULL MS_EID_UNICODE_FULL} {@link #STBTT_MAC_EID_ROMAN MAC_EID_ROMAN} {@link #STBTT_MAC_EID_JAPANESE MAC_EID_JAPANESE} {@link #STBTT_MAC_EID_CHINESE_TRAD MAC_EID_CHINESE_TRAD} {@link #STBTT_MAC_EID_KOREAN MAC_EID_KOREAN} {@link #STBTT_MAC_EID_ARABIC MAC_EID_ARABIC} {@link #STBTT_MAC_EID_HEBREW MAC_EID_HEBREW} {@link #STBTT_MAC_EID_GREEK MAC_EID_GREEK} {@link #STBTT_MAC_EID_RUSSIAN MAC_EID_RUSSIAN}
+ * @param nameID the name ID
+ */
+ @Nullable
+ @NativeType("char const *")
+ public static ByteBuffer stbtt_GetFontNameString(@NativeType("stbtt_fontinfo const *") STBTTFontinfo font, int platformID, int encodingID, int languageID, int nameID) {
+ MemoryStack stack = stackGet(); int stackPointer = stack.getPointer();
+ IntBuffer length = stack.callocInt(1);
+ try {
+ long __result = nstbtt_GetFontNameString(font.address(), memAddress(length), platformID, encodingID, languageID, nameID);
+ return memByteBufferSafe(__result, length.get(0));
+ } finally {
+ stack.setPointer(stackPointer);
+ }
+ }
+
+ /** Array version of: {@link #nstbtt_GetBakedQuad} */
+ public static native void nstbtt_GetBakedQuad(long chardata, int pw, int ph, int char_index, float[] xpos, float[] ypos, long q, int opengl_fillrule);
+
+ /** Array version of: {@link #stbtt_GetBakedQuad GetBakedQuad} */
+ public static void stbtt_GetBakedQuad(@NativeType("stbtt_bakedchar const *") STBTTBakedChar.Buffer chardata, int pw, int ph, int char_index, @NativeType("float *") float[] xpos, @NativeType("float *") float[] ypos, @NativeType("stbtt_aligned_quad *") STBTTAlignedQuad q, @NativeType("int") boolean opengl_fillrule) {
+ if (CHECKS) {
+ check(chardata, char_index + 1);
+ check(xpos, 1);
+ check(ypos, 1);
+ }
+ nstbtt_GetBakedQuad(chardata.address(), pw, ph, char_index, xpos, ypos, q.address(), opengl_fillrule ? 1 : 0);
+ }
+
+ /** Array version of: {@link #nstbtt_GetScaledFontVMetrics} */
+ public static native void nstbtt_GetScaledFontVMetrics(long fontdata, int index, float size, float[] ascent, float[] descent, float[] lineGap);
+
+ /** Array version of: {@link #stbtt_GetScaledFontVMetrics GetScaledFontVMetrics} */
+ public static void stbtt_GetScaledFontVMetrics(@NativeType("unsigned char const *") ByteBuffer fontdata, int index, float size, @NativeType("float *") float[] ascent, @NativeType("float *") float[] descent, @NativeType("float *") float[] lineGap) {
+ if (CHECKS) {
+ check(ascent, 1);
+ check(descent, 1);
+ check(lineGap, 1);
+ }
+ nstbtt_GetScaledFontVMetrics(memAddress(fontdata), index, size, ascent, descent, lineGap);
+ }
+
+ /** Array version of: {@link #nstbtt_GetPackedQuad} */
+ public static native void nstbtt_GetPackedQuad(long chardata, int pw, int ph, int char_index, float[] xpos, float[] ypos, long q, int align_to_integer);
+
+ /** Array version of: {@link #stbtt_GetPackedQuad GetPackedQuad} */
+ public static void stbtt_GetPackedQuad(@NativeType("stbtt_packedchar const *") STBTTPackedchar.Buffer chardata, int pw, int ph, int char_index, @NativeType("float *") float[] xpos, @NativeType("float *") float[] ypos, @NativeType("stbtt_aligned_quad *") STBTTAlignedQuad q, @NativeType("int") boolean align_to_integer) {
+ if (CHECKS) {
+ check(chardata, char_index + 1);
+ check(xpos, 1);
+ check(ypos, 1);
+ }
+ nstbtt_GetPackedQuad(chardata.address(), pw, ph, char_index, xpos, ypos, q.address(), align_to_integer ? 1 : 0);
+ }
+
+ /** Array version of: {@link #nstbtt_GetFontVMetrics} */
+ public static native void nstbtt_GetFontVMetrics(long info, int[] ascent, int[] descent, int[] lineGap);
+
+ /** Array version of: {@link #stbtt_GetFontVMetrics GetFontVMetrics} */
+ public static void stbtt_GetFontVMetrics(@NativeType("stbtt_fontinfo const *") STBTTFontinfo info, @Nullable @NativeType("int *") int[] ascent, @Nullable @NativeType("int *") int[] descent, @Nullable @NativeType("int *") int[] lineGap) {
+ if (CHECKS) {
+ checkSafe(ascent, 1);
+ checkSafe(descent, 1);
+ checkSafe(lineGap, 1);
+ }
+ nstbtt_GetFontVMetrics(info.address(), ascent, descent, lineGap);
+ }
+
+ /** Array version of: {@link #nstbtt_GetFontVMetricsOS2} */
+ public static native int nstbtt_GetFontVMetricsOS2(long info, int[] typoAscent, int[] typoDescent, int[] typoLineGap);
+
+ /** Array version of: {@link #stbtt_GetFontVMetricsOS2 GetFontVMetricsOS2} */
+ @NativeType("int")
+ public static boolean stbtt_GetFontVMetricsOS2(@NativeType("stbtt_fontinfo const *") STBTTFontinfo info, @Nullable @NativeType("int *") int[] typoAscent, @Nullable @NativeType("int *") int[] typoDescent, @Nullable @NativeType("int *") int[] typoLineGap) {
+ if (CHECKS) {
+ checkSafe(typoAscent, 1);
+ checkSafe(typoDescent, 1);
+ checkSafe(typoLineGap, 1);
+ }
+ return nstbtt_GetFontVMetricsOS2(info.address(), typoAscent, typoDescent, typoLineGap) != 0;
+ }
+
+ /** Array version of: {@link #nstbtt_GetFontBoundingBox} */
+ public static native void nstbtt_GetFontBoundingBox(long info, int[] x0, int[] y0, int[] x1, int[] y1);
+
+ /** Array version of: {@link #stbtt_GetFontBoundingBox GetFontBoundingBox} */
+ public static void stbtt_GetFontBoundingBox(@NativeType("stbtt_fontinfo const *") STBTTFontinfo info, @NativeType("int *") int[] x0, @NativeType("int *") int[] y0, @NativeType("int *") int[] x1, @NativeType("int *") int[] y1) {
+ if (CHECKS) {
+ check(x0, 1);
+ check(y0, 1);
+ check(x1, 1);
+ check(y1, 1);
+ }
+ nstbtt_GetFontBoundingBox(info.address(), x0, y0, x1, y1);
+ }
+
+ /** Array version of: {@link #nstbtt_GetCodepointHMetrics} */
+ public static native void nstbtt_GetCodepointHMetrics(long info, int codepoint, int[] advanceWidth, int[] leftSideBearing);
+
+ /** Array version of: {@link #stbtt_GetCodepointHMetrics GetCodepointHMetrics} */
+ public static void stbtt_GetCodepointHMetrics(@NativeType("stbtt_fontinfo const *") STBTTFontinfo info, int codepoint, @Nullable @NativeType("int *") int[] advanceWidth, @Nullable @NativeType("int *") int[] leftSideBearing) {
+ if (CHECKS) {
+ checkSafe(advanceWidth, 1);
+ checkSafe(leftSideBearing, 1);
+ }
+ nstbtt_GetCodepointHMetrics(info.address(), codepoint, advanceWidth, leftSideBearing);
+ }
+
+ /** Array version of: {@link #nstbtt_GetCodepointBox} */
+ public static native int nstbtt_GetCodepointBox(long info, int codepoint, int[] x0, int[] y0, int[] x1, int[] y1);
+
+ /** Array version of: {@link #stbtt_GetCodepointBox GetCodepointBox} */
+ @NativeType("int")
+ public static boolean stbtt_GetCodepointBox(@NativeType("stbtt_fontinfo const *") STBTTFontinfo info, int codepoint, @Nullable @NativeType("int *") int[] x0, @Nullable @NativeType("int *") int[] y0, @Nullable @NativeType("int *") int[] x1, @Nullable @NativeType("int *") int[] y1) {
+ if (CHECKS) {
+ checkSafe(x0, 1);
+ checkSafe(y0, 1);
+ checkSafe(x1, 1);
+ checkSafe(y1, 1);
+ }
+ return nstbtt_GetCodepointBox(info.address(), codepoint, x0, y0, x1, y1) != 0;
+ }
+
+ /** Array version of: {@link #nstbtt_GetGlyphHMetrics} */
+ public static native void nstbtt_GetGlyphHMetrics(long info, int glyph_index, int[] advanceWidth, int[] leftSideBearing);
+
+ /** Array version of: {@link #stbtt_GetGlyphHMetrics GetGlyphHMetrics} */
+ public static void stbtt_GetGlyphHMetrics(@NativeType("stbtt_fontinfo const *") STBTTFontinfo info, int glyph_index, @Nullable @NativeType("int *") int[] advanceWidth, @Nullable @NativeType("int *") int[] leftSideBearing) {
+ if (CHECKS) {
+ checkSafe(advanceWidth, 1);
+ checkSafe(leftSideBearing, 1);
+ }
+ nstbtt_GetGlyphHMetrics(info.address(), glyph_index, advanceWidth, leftSideBearing);
+ }
+
+ /** Array version of: {@link #nstbtt_GetGlyphBox} */
+ public static native int nstbtt_GetGlyphBox(long info, int glyph_index, int[] x0, int[] y0, int[] x1, int[] y1);
+
+ /** Array version of: {@link #stbtt_GetGlyphBox GetGlyphBox} */
+ @NativeType("int")
+ public static boolean stbtt_GetGlyphBox(@NativeType("stbtt_fontinfo const *") STBTTFontinfo info, int glyph_index, @Nullable @NativeType("int *") int[] x0, @Nullable @NativeType("int *") int[] y0, @Nullable @NativeType("int *") int[] x1, @Nullable @NativeType("int *") int[] y1) {
+ if (CHECKS) {
+ checkSafe(x0, 1);
+ checkSafe(y0, 1);
+ checkSafe(x1, 1);
+ checkSafe(y1, 1);
+ }
+ return nstbtt_GetGlyphBox(info.address(), glyph_index, x0, y0, x1, y1) != 0;
+ }
+
+ /** Array version of: {@link #nstbtt_GetCodepointBitmap} */
+ public static native long nstbtt_GetCodepointBitmap(long info, float scale_x, float scale_y, int codepoint, int[] width, int[] height, int[] xoff, int[] yoff);
+
+ /** Array version of: {@link #stbtt_GetCodepointBitmap GetCodepointBitmap} */
+ @Nullable
+ @NativeType("unsigned char *")
+ public static ByteBuffer stbtt_GetCodepointBitmap(@NativeType("stbtt_fontinfo const *") STBTTFontinfo info, float scale_x, float scale_y, int codepoint, @NativeType("int *") int[] width, @NativeType("int *") int[] height, @Nullable @NativeType("int *") int[] xoff, @Nullable @NativeType("int *") int[] yoff) {
+ if (CHECKS) {
+ check(width, 1);
+ check(height, 1);
+ checkSafe(xoff, 1);
+ checkSafe(yoff, 1);
+ }
+ long __result = nstbtt_GetCodepointBitmap(info.address(), scale_x, scale_y, codepoint, width, height, xoff, yoff);
+ return memByteBufferSafe(__result, width[0] * height[0]);
+ }
+
+ /** Array version of: {@link #nstbtt_GetCodepointBitmapSubpixel} */
+ public static native long nstbtt_GetCodepointBitmapSubpixel(long info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int[] width, int[] height, int[] xoff, int[] yoff);
+
+ /** Array version of: {@link #stbtt_GetCodepointBitmapSubpixel GetCodepointBitmapSubpixel} */
+ @Nullable
+ @NativeType("unsigned char *")
+ public static ByteBuffer stbtt_GetCodepointBitmapSubpixel(@NativeType("stbtt_fontinfo const *") STBTTFontinfo info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, @NativeType("int *") int[] width, @NativeType("int *") int[] height, @Nullable @NativeType("int *") int[] xoff, @Nullable @NativeType("int *") int[] yoff) {
+ if (CHECKS) {
+ check(width, 1);
+ check(height, 1);
+ checkSafe(xoff, 1);
+ checkSafe(yoff, 1);
+ }
+ long __result = nstbtt_GetCodepointBitmapSubpixel(info.address(), scale_x, scale_y, shift_x, shift_y, codepoint, width, height, xoff, yoff);
+ return memByteBufferSafe(__result, width[0] * height[0]);
+ }
+
+ /** Array version of: {@link #nstbtt_MakeCodepointBitmapSubpixelPrefilter} */
+ public static native void nstbtt_MakeCodepointBitmapSubpixelPrefilter(long info, long output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float[] sub_x, float[] sub_y, int codepoint);
+
+ /** Array version of: {@link #stbtt_MakeCodepointBitmapSubpixelPrefilter MakeCodepointBitmapSubpixelPrefilter} */
+ public static void stbtt_MakeCodepointBitmapSubpixelPrefilter(@NativeType("stbtt_fontinfo const *") STBTTFontinfo info, @NativeType("unsigned char *") ByteBuffer output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, @NativeType("float *") float[] sub_x, @NativeType("float *") float[] sub_y, int codepoint) {
+ if (CHECKS) {
+ check(output, (out_stride != 0 ? out_stride : out_w) * out_h);
+ check(sub_x, 1);
+ check(sub_y, 1);
+ }
+ nstbtt_MakeCodepointBitmapSubpixelPrefilter(info.address(), memAddress(output), out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, oversample_x, oversample_y, sub_x, sub_y, codepoint);
+ }
+
+ /** Array version of: {@link #nstbtt_GetCodepointBitmapBox} */
+ public static native void nstbtt_GetCodepointBitmapBox(long font, int codepoint, float scale_x, float scale_y, int[] ix0, int[] iy0, int[] ix1, int[] iy1);
+
+ /** Array version of: {@link #stbtt_GetCodepointBitmapBox GetCodepointBitmapBox} */
+ public static void stbtt_GetCodepointBitmapBox(@NativeType("stbtt_fontinfo const *") STBTTFontinfo font, int codepoint, float scale_x, float scale_y, @Nullable @NativeType("int *") int[] ix0, @Nullable @NativeType("int *") int[] iy0, @Nullable @NativeType("int *") int[] ix1, @Nullable @NativeType("int *") int[] iy1) {
+ if (CHECKS) {
+ checkSafe(ix0, 1);
+ checkSafe(iy0, 1);
+ checkSafe(ix1, 1);
+ checkSafe(iy1, 1);
+ }
+ nstbtt_GetCodepointBitmapBox(font.address(), codepoint, scale_x, scale_y, ix0, iy0, ix1, iy1);
+ }
+
+ /** Array version of: {@link #nstbtt_GetCodepointBitmapBoxSubpixel} */
+ public static native void nstbtt_GetCodepointBitmapBoxSubpixel(long font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int[] ix0, int[] iy0, int[] ix1, int[] iy1);
+
+ /** Array version of: {@link #stbtt_GetCodepointBitmapBoxSubpixel GetCodepointBitmapBoxSubpixel} */
+ public static void stbtt_GetCodepointBitmapBoxSubpixel(@NativeType("stbtt_fontinfo const *") STBTTFontinfo font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, @Nullable @NativeType("int *") int[] ix0, @Nullable @NativeType("int *") int[] iy0, @Nullable @NativeType("int *") int[] ix1, @Nullable @NativeType("int *") int[] iy1) {
+ if (CHECKS) {
+ checkSafe(ix0, 1);
+ checkSafe(iy0, 1);
+ checkSafe(ix1, 1);
+ checkSafe(iy1, 1);
+ }
+ nstbtt_GetCodepointBitmapBoxSubpixel(font.address(), codepoint, scale_x, scale_y, shift_x, shift_y, ix0, iy0, ix1, iy1);
+ }
+
+ /** Array version of: {@link #nstbtt_GetGlyphBitmap} */
+ public static native long nstbtt_GetGlyphBitmap(long info, float scale_x, float scale_y, int glyph, int[] width, int[] height, int[] xoff, int[] yoff);
+
+ /** Array version of: {@link #stbtt_GetGlyphBitmap GetGlyphBitmap} */
+ @Nullable
+ @NativeType("unsigned char *")
+ public static ByteBuffer stbtt_GetGlyphBitmap(@NativeType("stbtt_fontinfo const *") STBTTFontinfo info, float scale_x, float scale_y, int glyph, @NativeType("int *") int[] width, @NativeType("int *") int[] height, @Nullable @NativeType("int *") int[] xoff, @Nullable @NativeType("int *") int[] yoff) {
+ if (CHECKS) {
+ check(width, 1);
+ check(height, 1);
+ checkSafe(xoff, 1);
+ checkSafe(yoff, 1);
+ }
+ long __result = nstbtt_GetGlyphBitmap(info.address(), scale_x, scale_y, glyph, width, height, xoff, yoff);
+ return memByteBufferSafe(__result, width[0] * height[0]);
+ }
+
+ /** Array version of: {@link #nstbtt_GetGlyphBitmapSubpixel} */
+ public static native long nstbtt_GetGlyphBitmapSubpixel(long info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int[] width, int[] height, int[] xoff, int[] yoff);
+
+ /** Array version of: {@link #stbtt_GetGlyphBitmapSubpixel GetGlyphBitmapSubpixel} */
+ @Nullable
+ @NativeType("unsigned char *")
+ public static ByteBuffer stbtt_GetGlyphBitmapSubpixel(@NativeType("stbtt_fontinfo const *") STBTTFontinfo info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, @NativeType("int *") int[] width, @NativeType("int *") int[] height, @Nullable @NativeType("int *") int[] xoff, @Nullable @NativeType("int *") int[] yoff) {
+ if (CHECKS) {
+ check(width, 1);
+ check(height, 1);
+ checkSafe(xoff, 1);
+ checkSafe(yoff, 1);
+ }
+ long __result = nstbtt_GetGlyphBitmapSubpixel(info.address(), scale_x, scale_y, shift_x, shift_y, glyph, width, height, xoff, yoff);
+ return memByteBufferSafe(__result, width[0] * height[0]);
+ }
+
+ /** Array version of: {@link #nstbtt_MakeGlyphBitmapSubpixelPrefilter} */
+ public static native void nstbtt_MakeGlyphBitmapSubpixelPrefilter(long info, long output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float[] sub_x, float[] sub_y, int glyph);
+
+ /** Array version of: {@link #stbtt_MakeGlyphBitmapSubpixelPrefilter MakeGlyphBitmapSubpixelPrefilter} */
+ public static void stbtt_MakeGlyphBitmapSubpixelPrefilter(@NativeType("stbtt_fontinfo const *") STBTTFontinfo info, @NativeType("unsigned char *") ByteBuffer output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, @NativeType("float *") float[] sub_x, @NativeType("float *") float[] sub_y, int glyph) {
+ if (CHECKS) {
+ check(output, (out_stride != 0 ? out_stride : out_w) * out_h);
+ check(sub_x, 1);
+ check(sub_y, 1);
+ }
+ nstbtt_MakeGlyphBitmapSubpixelPrefilter(info.address(), memAddress(output), out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, oversample_x, oversample_y, sub_x, sub_y, glyph);
+ }
+
+ /** Array version of: {@link #nstbtt_GetGlyphBitmapBox} */
+ public static native void nstbtt_GetGlyphBitmapBox(long font, int glyph, float scale_x, float scale_y, int[] ix0, int[] iy0, int[] ix1, int[] iy1);
+
+ /** Array version of: {@link #stbtt_GetGlyphBitmapBox GetGlyphBitmapBox} */
+ public static void stbtt_GetGlyphBitmapBox(@NativeType("stbtt_fontinfo const *") STBTTFontinfo font, int glyph, float scale_x, float scale_y, @Nullable @NativeType("int *") int[] ix0, @Nullable @NativeType("int *") int[] iy0, @Nullable @NativeType("int *") int[] ix1, @Nullable @NativeType("int *") int[] iy1) {
+ if (CHECKS) {
+ checkSafe(ix0, 1);
+ checkSafe(iy0, 1);
+ checkSafe(ix1, 1);
+ checkSafe(iy1, 1);
+ }
+ nstbtt_GetGlyphBitmapBox(font.address(), glyph, scale_x, scale_y, ix0, iy0, ix1, iy1);
+ }
+
+ /** Array version of: {@link #nstbtt_GetGlyphBitmapBoxSubpixel} */
+ public static native void nstbtt_GetGlyphBitmapBoxSubpixel(long font, int glyph, float scale_x, float scale_y, float shift_x, float shift_y, int[] ix0, int[] iy0, int[] ix1, int[] iy1);
+
+ /** Array version of: {@link #stbtt_GetGlyphBitmapBoxSubpixel GetGlyphBitmapBoxSubpixel} */
+ public static void stbtt_GetGlyphBitmapBoxSubpixel(@NativeType("stbtt_fontinfo const *") STBTTFontinfo font, int glyph, float scale_x, float scale_y, float shift_x, float shift_y, @Nullable @NativeType("int *") int[] ix0, @Nullable @NativeType("int *") int[] iy0, @Nullable @NativeType("int *") int[] ix1, @Nullable @NativeType("int *") int[] iy1) {
+ if (CHECKS) {
+ checkSafe(ix0, 1);
+ checkSafe(iy0, 1);
+ checkSafe(ix1, 1);
+ checkSafe(iy1, 1);
+ }
+ nstbtt_GetGlyphBitmapBoxSubpixel(font.address(), glyph, scale_x, scale_y, shift_x, shift_y, ix0, iy0, ix1, iy1);
+ }
+
+ /** Array version of: {@link #nstbtt_GetGlyphSDF} */
+ public static native long nstbtt_GetGlyphSDF(long font, float scale, int glyph, int padding, byte onedge_value, float pixel_dist_scale, int[] width, int[] height, int[] xoff, int[] yoff);
+
+ /** Array version of: {@link #stbtt_GetGlyphSDF GetGlyphSDF} */
+ @Nullable
+ @NativeType("unsigned char *")
+ public static ByteBuffer stbtt_GetGlyphSDF(@NativeType("stbtt_fontinfo const *") STBTTFontinfo font, float scale, int glyph, int padding, @NativeType("unsigned char") byte onedge_value, float pixel_dist_scale, @NativeType("int *") int[] width, @NativeType("int *") int[] height, @NativeType("int *") int[] xoff, @NativeType("int *") int[] yoff) {
+ if (CHECKS) {
+ check(width, 1);
+ check(height, 1);
+ check(xoff, 1);
+ check(yoff, 1);
+ }
+ long __result = nstbtt_GetGlyphSDF(font.address(), scale, glyph, padding, onedge_value, pixel_dist_scale, width, height, xoff, yoff);
+ return memByteBufferSafe(__result, width[0] * height[0]);
+ }
+
+ /** Array version of: {@link #nstbtt_GetCodepointSDF} */
+ public static native long nstbtt_GetCodepointSDF(long font, float scale, int codepoint, int padding, byte onedge_value, float pixel_dist_scale, int[] width, int[] height, int[] xoff, int[] yoff);
+
+ /** Array version of: {@link #stbtt_GetCodepointSDF GetCodepointSDF} */
+ @Nullable
+ @NativeType("unsigned char *")
+ public static ByteBuffer stbtt_GetCodepointSDF(@NativeType("stbtt_fontinfo const *") STBTTFontinfo font, float scale, int codepoint, int padding, @NativeType("unsigned char") byte onedge_value, float pixel_dist_scale, @NativeType("int *") int[] width, @NativeType("int *") int[] height, @NativeType("int *") int[] xoff, @NativeType("int *") int[] yoff) {
+ if (CHECKS) {
+ check(width, 1);
+ check(height, 1);
+ check(xoff, 1);
+ check(yoff, 1);
+ }
+ long __result = nstbtt_GetCodepointSDF(font.address(), scale, codepoint, padding, onedge_value, pixel_dist_scale, width, height, xoff, yoff);
+ return memByteBufferSafe(__result, width[0] * height[0]);
+ }
+
+}
\ No newline at end of file
diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBVorbis.java b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBVorbis.java
new file mode 100644
index 00000000..3ef94620
--- /dev/null
+++ b/lwjgl3-fcl/src/main/java/org/lwjgl/stb/STBVorbis.java
@@ -0,0 +1,967 @@
+/*
+ * Copyright LWJGL. All rights reserved.
+ * License terms: https://www.lwjgl.org/license
+ * MACHINE GENERATED FILE, DO NOT EDIT
+ */
+package org.lwjgl.stb;
+
+import javax.annotation.*;
+
+import java.nio.*;
+
+import org.lwjgl.*;
+
+import org.lwjgl.system.*;
+
+import static org.lwjgl.system.Checks.*;
+import static org.lwjgl.system.MemoryStack.*;
+import static org.lwjgl.system.MemoryUtil.*;
+
+import org.lwjgl.system.libc.LibCStdlib;
+
+/**
+ * Native bindings to stb_vorbis.c from the stb library.
+ *
+ * {@link #STBTT_MS_LANG_ENGLISH MS_LANG_ENGLISH} {@link #STBTT_MS_LANG_CHINESE MS_LANG_CHINESE} {@link #STBTT_MS_LANG_DUTCH MS_LANG_DUTCH} {@link #STBTT_MS_LANG_FRENCH MS_LANG_FRENCH} {@link #STBTT_MS_LANG_GERMAN MS_LANG_GERMAN} {@link #STBTT_MS_LANG_HEBREW MS_LANG_HEBREW} {@link #STBTT_MS_LANG_ITALIAN MS_LANG_ITALIAN} {@link #STBTT_MS_LANG_JAPANESE MS_LANG_JAPANESE} {@link #STBTT_MS_LANG_KOREAN MS_LANG_KOREAN} {@link #STBTT_MS_LANG_RUSSIAN MS_LANG_RUSSIAN} {@link #STBTT_MS_LANG_SPANISH MS_LANG_SPANISH} {@link #STBTT_MS_LANG_SWEDISH MS_LANG_SWEDISH} {@link #STBTT_MAC_LANG_ENGLISH MAC_LANG_ENGLISH} {@link #STBTT_MAC_LANG_ARABIC MAC_LANG_ARABIC} {@link #STBTT_MAC_LANG_DUTCH MAC_LANG_DUTCH} {@link #STBTT_MAC_LANG_FRENCH MAC_LANG_FRENCH} {@link #STBTT_MAC_LANG_GERMAN MAC_LANG_GERMAN} {@link #STBTT_MAC_LANG_HEBREW MAC_LANG_HEBREW} {@link #STBTT_MAC_LANG_ITALIAN MAC_LANG_ITALIAN} {@link #STBTT_MAC_LANG_JAPANESE MAC_LANG_JAPANESE} {@link #STBTT_MAC_LANG_KOREAN MAC_LANG_KOREAN} {@link #STBTT_MAC_LANG_RUSSIAN MAC_LANG_RUSSIAN} {@link #STBTT_MAC_LANG_SPANISH MAC_LANG_SPANISH} {@link #STBTT_MAC_LANG_SWEDISH MAC_LANG_SWEDISH} {@link #STBTT_MAC_LANG_CHINESE_SIMPLIFIED MAC_LANG_CHINESE_SIMPLIFIED} {@link #STBTT_MAC_LANG_CHINESE_TRAD MAC_LANG_CHINESE_TRAD} Limitations
+ *
+ *
+ *
+ *
+ * THREAD SAFETY
+ *
+ * PUSHDATA API
+ *
+ * PULLING INPUT API
+ *
+ * Enum values:
+ *
+ *
+ *
+ */
+ public static final int
+ VORBIS__no_error = 0,
+ VORBIS_need_more_data = 1,
+ VORBIS_invalid_api_mixing = 2,
+ VORBIS_outofmem = 3,
+ VORBIS_feature_not_supported = 4,
+ VORBIS_too_many_channels = 5,
+ VORBIS_file_open_failure = 6,
+ VORBIS_seek_without_length = 7,
+ VORBIS_unexpected_eof = 10,
+ VORBIS_seek_invalid = 11,
+ VORBIS_invalid_setup = 20,
+ VORBIS_invalid_stream = 21,
+ VORBIS_missing_capture_pattern = 30,
+ VORBIS_invalid_stream_structure_version = 31,
+ VORBIS_continued_packet_flag_invalid = 32,
+ VORBIS_incorrect_stream_serial_number = 33,
+ VORBIS_invalid_first_page = 34,
+ VORBIS_bad_packet_type = 35,
+ VORBIS_cant_find_last_page = 36,
+ VORBIS_seek_failed = 37,
+ VORBIS_ogg_skeleton_not_supported = 38;
+
+ static { LibSTB.initialize(); }
+
+ protected STBVorbis() {
+ throw new UnsupportedOperationException();
+ }
+
+ // --- [ stb_vorbis_get_info ] ---
+
+ /** Unsafe version of: {@link #stb_vorbis_get_info get_info} */
+ public static native void nstb_vorbis_get_info(long f, long __result);
+
+ /**
+ * Returns general information about the specified file.
+ *
+ * @param f an ogg vorbis file decoder
+ */
+ @NativeType("stb_vorbis_info")
+ public static STBVorbisInfo stb_vorbis_get_info(@NativeType("stb_vorbis *") long f, @NativeType("stb_vorbis_info") STBVorbisInfo __result) {
+ if (CHECKS) {
+ check(f);
+ }
+ nstb_vorbis_get_info(f, __result.address());
+ return __result;
+ }
+
+ // --- [ stb_vorbis_get_error ] ---
+
+ /** Unsafe version of: {@link #stb_vorbis_get_error get_error} */
+ public static native int nstb_vorbis_get_error(long f);
+
+ /**
+ * Returns the last error detected (clears it, too).
+ *
+ * @param f an ogg vorbis file decoder
+ */
+ public static int stb_vorbis_get_error(@NativeType("stb_vorbis *") long f) {
+ if (CHECKS) {
+ check(f);
+ }
+ return nstb_vorbis_get_error(f);
+ }
+
+ // --- [ stb_vorbis_close ] ---
+
+ /** Unsafe version of: {@link #stb_vorbis_close close} */
+ public static native void nstb_vorbis_close(long f);
+
+ /**
+ * Closes an ogg vorbis file and free all memory in use
+ *
+ * @param f an ogg vorbis file decoder
+ */
+ public static void stb_vorbis_close(@NativeType("stb_vorbis *") long f) {
+ if (CHECKS) {
+ check(f);
+ }
+ nstb_vorbis_close(f);
+ }
+
+ // --- [ stb_vorbis_get_sample_offset ] ---
+
+ /** Unsafe version of: {@link #stb_vorbis_get_sample_offset get_sample_offset} */
+ public static native int nstb_vorbis_get_sample_offset(long f);
+
+ /**
+ * Returns the offset (in samples) from the beginning of the file that will be returned by the next decode, if it is known, or -1 otherwise. After a
+ * {@link #stb_vorbis_flush_pushdata flush_pushdata} call, this may take a while before it becomes valid again.
+ *
+ *
+ *
+ *
+ * Channel coercion rules
+ *
+ *
+ *
+ *
+ * M N output
+ * 1 k sum(Ck) for all k
+ * 2 * stereo L, stereo R
+ * k l k > l, the first l channels, then 0s
+ * k l k <= l, the first k channelsLayout
+ *
+ *
+ */
+@NativeType("struct stb_vorbis_alloc")
+public class STBVorbisAlloc extends Struct implements NativeResource {
+
+ /** The struct size in bytes. */
+ public static final int SIZEOF;
+
+ /** The struct alignment in bytes. */
+ public static final int ALIGNOF;
+
+ /** The struct member offsets. */
+ public static final int
+ ALLOC_BUFFER,
+ ALLOC_BUFFER_LENGTH_IN_BYTES;
+
+ static {
+ Layout layout = __struct(
+ __member(POINTER_SIZE),
+ __member(4)
+ );
+
+ SIZEOF = layout.getSize();
+ ALIGNOF = layout.getAlignment();
+
+ ALLOC_BUFFER = layout.offsetof(0);
+ ALLOC_BUFFER_LENGTH_IN_BYTES = layout.offsetof(1);
+ }
+
+ /**
+ * Creates a {@code STBVorbisAlloc} instance at the current position of the specified {@link ByteBuffer} container. Changes to the buffer's content will be
+ * visible to the struct instance and vice versa.
+ *
+ *
+ * struct stb_vorbis_alloc {
+ * char * alloc_buffer;
+ * int alloc_buffer_length_in_bytes;
+ * }Layout
+ *
+ *
+ */
+@NativeType("struct stb_vorbis_info")
+public class STBVorbisInfo extends Struct implements NativeResource {
+
+ /** The struct size in bytes. */
+ public static final int SIZEOF;
+
+ /** The struct alignment in bytes. */
+ public static final int ALIGNOF;
+
+ /** The struct member offsets. */
+ public static final int
+ SAMPLE_RATE,
+ CHANNELS,
+ SETUP_MEMORY_REQUIRED,
+ SETUP_TEMP_MEMORY_REQUIRED,
+ TEMP_MEMORY_REQUIRED,
+ MAX_FRAME_SIZE;
+
+ static {
+ Layout layout = __struct(
+ __member(4),
+ __member(4),
+ __member(4),
+ __member(4),
+ __member(4),
+ __member(4)
+ );
+
+ SIZEOF = layout.getSize();
+ ALIGNOF = layout.getAlignment();
+
+ SAMPLE_RATE = layout.offsetof(0);
+ CHANNELS = layout.offsetof(1);
+ SETUP_MEMORY_REQUIRED = layout.offsetof(2);
+ SETUP_TEMP_MEMORY_REQUIRED = layout.offsetof(3);
+ TEMP_MEMORY_REQUIRED = layout.offsetof(4);
+ MAX_FRAME_SIZE = layout.offsetof(5);
+ }
+
+ /**
+ * Creates a {@code STBVorbisInfo} instance at the current position of the specified {@link ByteBuffer} container. Changes to the buffer's content will be
+ * visible to the struct instance and vice versa.
+ *
+ *
+ * struct stb_vorbis_info {
+ * unsigned int sample_rate;
+ * int channels;
+ * unsigned int setup_memory_required;
+ * unsigned int setup_temp_memory_required;
+ * unsigned int temp_memory_required;
+ * int max_frame_size;
+ * }
+ *
+ */
+@org.lwjgl.system.NonnullDefault
+package org.lwjgl.stb;
+
diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/system/APIUtil.java b/lwjgl3-fcl/src/main/java/org/lwjgl/system/APIUtil.java
new file mode 100644
index 00000000..753a17a9
--- /dev/null
+++ b/lwjgl3-fcl/src/main/java/org/lwjgl/system/APIUtil.java
@@ -0,0 +1,520 @@
+/*
+ * Copyright LWJGL. All rights reserved.
+ * License terms: https://www.lwjgl.org/license
+ */
+package org.lwjgl.system;
+
+import org.lwjgl.*;
+import org.lwjgl.system.fcl.*;
+import org.lwjgl.system.linux.*;
+import org.lwjgl.system.macosx.*;
+import org.lwjgl.system.windows.*;
+
+import javax.annotation.*;
+import java.io.*;
+import java.lang.reflect.*;
+import java.net.*;
+import java.nio.*;
+import java.nio.file.*;
+import java.util.*;
+import java.util.function.*;
+import java.util.jar.*;
+import java.util.regex.*;
+import java.util.stream.*;
+
+import static org.lwjgl.system.Checks.*;
+import static org.lwjgl.system.MemoryUtil.*;
+import static org.lwjgl.system.Pointer.*;
+
+/**
+ * Utility class useful to API bindings. [INTERNAL USE ONLY]
+ *
+ *
+ *
+ */
+public interface CallbackI extends Pointer {
+
+ /**
+ * Returns the dyncall signature for this callback function. [INTERNAL API]
+ *
+ * @return the dyncall signature
+ */
+ String getSignature();
+
+ @Override
+ default long address() {
+ return Callback.create(getSignature(), this);
+ }
+
+ /** A {@code Callback} with no return value. */
+ interface V extends CallbackI {
+ /**
+ * Will be called by native code.
+ *
+ * @param args pointer to a {@code DCArgs} iterator
+ */
+ void callback(long args);
+ }
+
+ /** A {@code Callback} that returns a boolean value. */
+ interface Z extends CallbackI {
+ /**
+ * Will be called by native code.
+ *
+ * @param args pointer to a {@code DCArgs} iterator
+ *
+ * @return the value to store to the result {@code DCValue}
+ */
+ boolean callback(long args);
+ }
+
+ /** A {@code Callback} that returns a byte value. */
+ interface B extends CallbackI {
+ /**
+ * Will be called by native code.
+ *
+ * @param args pointer to a {@code DCArgs} iterator
+ *
+ * @return the value to store to the result {@code DCValue}
+ */
+ byte callback(long args);
+ }
+
+ /** A {@code Callback} that returns a short value. */
+ interface S extends CallbackI {
+ /**
+ * Will be called by native code.
+ *
+ * @param args pointer to a {@code DCArgs} iterator
+ *
+ * @return the value to store to the result {@code DCValue}
+ */
+ short callback(long args);
+ }
+
+ /** A {@code Callback} that returns an int value. */
+ interface I extends CallbackI {
+ /**
+ * Will be called by native code.
+ *
+ * @param args pointer to a {@code DCArgs} iterator
+ *
+ * @return the value to store to the result {@code DCValue}
+ */
+ int callback(long args);
+ }
+
+ /** A {@code Callback} that returns a long value. */
+ interface J extends CallbackI {
+ /**
+ * Will be called by native code.
+ *
+ * @param args pointer to a {@code DCArgs} iterator
+ *
+ * @return the value to store to the result {@code DCValue}
+ */
+ long callback(long args);
+ }
+
+ /** A {@code Callback} that returns a C long value. */
+ interface N extends CallbackI {
+ /**
+ * Will be called by native code.
+ *
+ * @param args pointer to a {@code DCArgs} iterator
+ *
+ * @return the value to store to the result {@code DCValue}
+ */
+ long callback(long args);
+ }
+
+ /** A {@code Callback} that returns a float value. */
+ interface F extends CallbackI {
+ /**
+ * Will be called by native code.
+ *
+ * @param args pointer to a {@code DCArgs} iterator
+ *
+ * @return the value to store to the result {@code DCValue}
+ */
+ float callback(long args);
+ }
+
+ /** A {@code Callback} that returns a double value. */
+ interface D extends CallbackI {
+ /**
+ * Will be called by native code.
+ *
+ * @param args pointer to a {@code DCArgs} iterator
+ *
+ * @return the value to store to the result {@code DCValue}
+ */
+ double callback(long args);
+ }
+
+ /** A {@code Callback} that returns a pointer value. */
+ interface P extends CallbackI {
+ /**
+ * Will be called by native code.
+ *
+ * @param args pointer to a {@code DCArgs} iterator
+ *
+ * @return the value to store to the result {@code DCValue}
+ */
+ long callback(long args);
+ }
+
+}
+
diff --git a/lwjgl3-fcl/src/main/java/org/lwjgl/system/CheckIntrinsics.java b/lwjgl3-fcl/src/main/java/org/lwjgl/system/CheckIntrinsics.java
new file mode 100644
index 00000000..1aa3f14b
--- /dev/null
+++ b/lwjgl3-fcl/src/main/java/org/lwjgl/system/CheckIntrinsics.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright LWJGL. All rights reserved.
+ * License terms: https://www.lwjgl.org/license
+ */
+package org.lwjgl.system;
+
+/**
+ * Simple index checks.
+ *
+ *
+ * Usage: Dynamic
+ */
+ public static final Configuration
+ *
+ *
+ *
+ * Type: String or a {@link Function Function<String, String>} instance
+ * Usage: Static