Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
* @param buffer the name of a buffer object
*/
public static native void glBindBuffer(int target, int buffer);
// --- [ glDeleteBuffers ] ---
/**
* Unsafe version of: {@link #glDeleteBuffers DeleteBuffers}
*
* @param n the number of buffer objects to be deleted
*/
public static native void nglDeleteBuffers(int n, long buffers);
/**
*
*
* Deletes named buffer objects.
*
* @param buffers an array of buffer objects to be deleted
*/
public static void glDeleteBuffers(IntBuffer buffers) {
nglDeleteBuffers(buffers.remaining(), memAddress(buffers));
}
/**
*
*
* Determines if a name corresponds to a buffer object.
*
* @param buffer a value that may be the name of a buffer object
*/
public static native boolean glIsBuffer(int buffer);
// --- [ glBufferData ] ---
/**
* Unsafe version of: {@link #glBufferData BufferData}
*
* @param size the size in bytes of the buffer object's new data store
*/
public static native void nglBufferData(int target, long size, long data, int usage);
/**
*
*
* Creates and initializes a buffer object's data store.
*
*
{@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:
*
*
*
STREAM - The data store contents will be modified once and used at most a few times.
*
STATIC - The data store contents will be modified once and used many times.
*
DYNAMIC - The data store contents will be modified repeatedly and used many times.
*
*
*
The nature of access may be one of these:
*
*
*
DRAW - The data store contents are modified by the application, and used as the source for GL drawing and image specification commands.
*
READ - The data store contents are modified by reading data from the GL, and used to return that data when queried by the application.
*
COPY - The data store contents are modified by reading data from the GL, and used as the source for GL drawing and image specification commands.
*
*
* @param target the target buffer object. One of:
*
* Creates and initializes a buffer object's data store.
*
*
{@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:
*
*
*
STREAM - The data store contents will be modified once and used at most a few times.
*
STATIC - The data store contents will be modified once and used many times.
*
DYNAMIC - The data store contents will be modified repeatedly and used many times.
*
*
*
The nature of access may be one of these:
*
*
*
DRAW - The data store contents are modified by the application, and used as the source for GL drawing and image specification commands.
*
READ - The data store contents are modified by reading data from the GL, and used to return that data when queried by the application.
*
COPY - The data store contents are modified by reading data from the GL, and used as the source for GL drawing and image specification commands.
*
*
* @param target the target buffer object. One of:
* @param data a pointer to data that will be copied into the data store for initialization, or {@code NULL} if no data is to be copied
* @param usage the expected usage pattern of the data store. One of:
{@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}
*/
public static void glBufferData(int target, ByteBuffer data, int usage) {
nglBufferData(target, data.remaining(), memAddress(data), usage);
}
/**
*
*
* Creates and initializes a buffer object's data store.
*
*
{@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:
*
*
*
STREAM - The data store contents will be modified once and used at most a few times.
*
STATIC - The data store contents will be modified once and used many times.
*
DYNAMIC - The data store contents will be modified repeatedly and used many times.
*
*
*
The nature of access may be one of these:
*
*
*
DRAW - The data store contents are modified by the application, and used as the source for GL drawing and image specification commands.
*
READ - The data store contents are modified by reading data from the GL, and used to return that data when queried by the application.
*
COPY - The data store contents are modified by reading data from the GL, and used as the source for GL drawing and image specification commands.
*
*
* @param target the target buffer object. One of:
* @param data a pointer to data that will be copied into the data store for initialization, or {@code NULL} if no data is to be copied
* @param usage the expected usage pattern of the data store. One of:
{@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}
*/
public static void glBufferData(int target, ShortBuffer data, int usage) {
nglBufferData(target, data.remaining() << 1, memAddress(data), usage);
}
/**
*
*
* Creates and initializes a buffer object's data store.
*
*
{@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:
*
*
*
STREAM - The data store contents will be modified once and used at most a few times.
*
STATIC - The data store contents will be modified once and used many times.
*
DYNAMIC - The data store contents will be modified repeatedly and used many times.
*
*
*
The nature of access may be one of these:
*
*
*
DRAW - The data store contents are modified by the application, and used as the source for GL drawing and image specification commands.
*
READ - The data store contents are modified by reading data from the GL, and used to return that data when queried by the application.
*
COPY - The data store contents are modified by reading data from the GL, and used as the source for GL drawing and image specification commands.
*
*
* @param target the target buffer object. One of:
* @param data a pointer to data that will be copied into the data store for initialization, or {@code NULL} if no data is to be copied
* @param usage the expected usage pattern of the data store. One of:
{@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}
*/
public static void glBufferData(int target, IntBuffer data, int usage) {
nglBufferData(target, data.remaining() << 2, memAddress(data), usage);
}
/**
*
*
* Creates and initializes a buffer object's data store.
*
*
{@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:
*
*
*
STREAM - The data store contents will be modified once and used at most a few times.
*
STATIC - The data store contents will be modified once and used many times.
*
DYNAMIC - The data store contents will be modified repeatedly and used many times.
*
*
*
The nature of access may be one of these:
*
*
*
DRAW - The data store contents are modified by the application, and used as the source for GL drawing and image specification commands.
*
READ - The data store contents are modified by reading data from the GL, and used to return that data when queried by the application.
*
COPY - The data store contents are modified by reading data from the GL, and used as the source for GL drawing and image specification commands.
*
*
* @param target the target buffer object. One of:
* @param data a pointer to data that will be copied into the data store for initialization, or {@code NULL} if no data is to be copied
* @param usage the expected usage pattern of the data store. One of:
{@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}
*/
public static void glBufferData(int target, FloatBuffer data, int usage) {
nglBufferData(target, data.remaining() << 2, memAddress(data), usage);
}
/**
*
*
* Creates and initializes a buffer object's data store.
*
*
{@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:
*
*
*
STREAM - The data store contents will be modified once and used at most a few times.
*
STATIC - The data store contents will be modified once and used many times.
*
DYNAMIC - The data store contents will be modified repeatedly and used many times.
*
*
*
The nature of access may be one of these:
*
*
*
DRAW - The data store contents are modified by the application, and used as the source for GL drawing and image specification commands.
*
READ - The data store contents are modified by reading data from the GL, and used to return that data when queried by the application.
*
COPY - The data store contents are modified by reading data from the GL, and used as the source for GL drawing and image specification commands.
*
*
* @param target the target buffer object. One of:
* @param data a pointer to data that will be copied into the data store for initialization, or {@code NULL} if no data is to be copied
* @param usage the expected usage pattern of the data store. One of:
{@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}
*/
public static void glBufferData(int target, DoubleBuffer data, int usage) {
nglBufferData(target, data.remaining() << 3, memAddress(data), usage);
}
// --- [ glBufferSubData ] ---
/**
* Unsafe version of: {@link #glBufferSubData BufferSubData}
*
* @param size the size in bytes of the data store region being replaced
*/
public static native void nglBufferSubData(int target, long offset, long size, long data);
/**
*
* @param offset the offset into the buffer object's data store where data replacement will begin, measured in bytes
* @param data a pointer to the new data that will be copied into the data store
*/
public static void glBufferSubData(int target, long offset, ByteBuffer data) {
nglBufferSubData(target, offset, data.remaining(), memAddress(data));
}
/**
*
* @param offset the offset into the buffer object's data store where data replacement will begin, measured in bytes
* @param data a pointer to the new data that will be copied into the data store
*/
public static void glBufferSubData(int target, long offset, ShortBuffer data) {
nglBufferSubData(target, offset, data.remaining() << 1, memAddress(data));
}
/**
*
* @param offset the offset into the buffer object's data store where data replacement will begin, measured in bytes
* @param data a pointer to the new data that will be copied into the data store
*/
public static void glBufferSubData(int target, long offset, IntBuffer data) {
nglBufferSubData(target, offset, data.remaining() << 2, memAddress(data));
}
/**
*
* @param offset the offset into the buffer object's data store where data replacement will begin, measured in bytes
* @param data a pointer to the new data that will be copied into the data store
*/
public static void glBufferSubData(int target, long offset, FloatBuffer data) {
nglBufferSubData(target, offset, data.remaining() << 2, memAddress(data));
}
/**
*
* @param offset the offset into the buffer object's data store where data replacement will begin, measured in bytes
* @param data a pointer to the new data that will be copied into the data store
*/
public static void glBufferSubData(int target, long offset, DoubleBuffer data) {
nglBufferSubData(target, offset, data.remaining() << 3, memAddress(data));
}
// --- [ glGetBufferSubData ] ---
/**
* Unsafe version of: {@link #glGetBufferSubData GetBufferSubData}
*
* @param size the size in bytes of the data store region being returned
*/
public static native void nglGetBufferSubData(int target, long offset, long size, long data);
/**
*
* @param offset the offset into the buffer object's data store from which data will be returned, measured in bytes
* @param data a pointer to the location where buffer object data is returned
*/
public static void glGetBufferSubData(int target, long offset, ByteBuffer data) {
nglGetBufferSubData(target, offset, data.remaining(), memAddress(data));
}
/**
*
* @param offset the offset into the buffer object's data store from which data will be returned, measured in bytes
* @param data a pointer to the location where buffer object data is returned
*/
public static void glGetBufferSubData(int target, long offset, ShortBuffer data) {
nglGetBufferSubData(target, offset, data.remaining() << 1, memAddress(data));
}
/**
*
* @param offset the offset into the buffer object's data store from which data will be returned, measured in bytes
* @param data a pointer to the location where buffer object data is returned
*/
public static void glGetBufferSubData(int target, long offset, IntBuffer data) {
nglGetBufferSubData(target, offset, data.remaining() << 2, memAddress(data));
}
/**
*
* @param offset the offset into the buffer object's data store from which data will be returned, measured in bytes
* @param data a pointer to the location where buffer object data is returned
*/
public static void glGetBufferSubData(int target, long offset, FloatBuffer data) {
nglGetBufferSubData(target, offset, data.remaining() << 2, memAddress(data));
}
/**
*
* @param offset the offset into the buffer object's data store from which data will be returned, measured in bytes
* @param data a pointer to the location where buffer object data is returned
*/
public static void glGetBufferSubData(int target, long offset, DoubleBuffer data) {
nglGetBufferSubData(target, offset, data.remaining() << 3, memAddress(data));
}
// --- [ glMapBuffer ] ---
/** Unsafe version of: {@link #glMapBuffer MapBuffer} */
public static native long nglMapBuffer(int target, int access);
/**
*
{@link #glMapBuffer(int, int)} - Calls {@link #glGetBufferParameteriv GetBufferParameteriv} to retrieve the buffer size and a new ByteBuffer instance is always returned.
*
{@link #glMapBuffer(int, int, ByteBuffer)} - Calls {@link #glGetBufferParameteriv GetBufferParameteriv} to retrieve the buffer size and the {@code old_buffer} parameter is reused if not null.
*
{@link #glMapBuffer(int, int, long, ByteBuffer)} - The buffer size is explicitly specified and the {@code old_buffer} parameter is reused if not null. This is the most efficient method.
*
*
* @param target the target buffer object being mapped. One of:
* @param access the access policy, indicating whether it will be possible to read from, write to, or both read from and write to the buffer object's mapped data store. One of:
{@link #GL_READ_ONLY READ_ONLY}
{@link #GL_WRITE_ONLY WRITE_ONLY}
{@link #GL_READ_WRITE READ_WRITE}
*/
public static ByteBuffer glMapBuffer(int target, int access) {
long __result = nglMapBuffer(target, access);
return memByteBuffer(__result, glGetBufferParameteri(target, GL_BUFFER_SIZE));
}
/**
*
{@link #glMapBuffer(int, int)} - Calls {@link #glGetBufferParameteriv GetBufferParameteriv} to retrieve the buffer size and a new ByteBuffer instance is always returned.
*
{@link #glMapBuffer(int, int, ByteBuffer)} - Calls {@link #glGetBufferParameteriv GetBufferParameteriv} to retrieve the buffer size and the {@code old_buffer} parameter is reused if not null.
*
{@link #glMapBuffer(int, int, long, ByteBuffer)} - The buffer size is explicitly specified and the {@code old_buffer} parameter is reused if not null. This is the most efficient method.
*
*
* @param target the target buffer object being mapped. One of:
* @param access the access policy, indicating whether it will be possible to read from, write to, or both read from and write to the buffer object's mapped data store. One of:
{@link #GL_READ_ONLY READ_ONLY}
{@link #GL_WRITE_ONLY WRITE_ONLY}
{@link #GL_READ_WRITE READ_WRITE}
*/
public static ByteBuffer glMapBuffer(int target, int access, ByteBuffer old_buffer) {
long __result = nglMapBuffer(target, access);
int length = glGetBufferParameteri(target, GL_BUFFER_SIZE);
return apiGetMappedBuffer(old_buffer, __result, length);
}
/**
*
{@link #glMapBuffer(int, int)} - Calls {@link #glGetBufferParameteriv GetBufferParameteriv} to retrieve the buffer size and a new ByteBuffer instance is always returned.
*
{@link #glMapBuffer(int, int, ByteBuffer)} - Calls {@link #glGetBufferParameteriv GetBufferParameteriv} to retrieve the buffer size and the {@code old_buffer} parameter is reused if not null.
*
{@link #glMapBuffer(int, int, long, ByteBuffer)} - The buffer size is explicitly specified and the {@code old_buffer} parameter is reused if not null. This is the most efficient method.
*
*
* @param target the target buffer object being mapped. One of:
* @param access the access policy, indicating whether it will be possible to read from, write to, or both read from and write to the buffer object's mapped data store. One of:
{@link #GL_READ_ONLY READ_ONLY}
{@link #GL_WRITE_ONLY WRITE_ONLY}
{@link #GL_READ_WRITE READ_WRITE}
*/
public static ByteBuffer glMapBuffer(int target, int access, long length, ByteBuffer old_buffer) {
long __result = nglMapBuffer(target, access);
return apiGetMappedBuffer(old_buffer, __result, (int)length);
}
// --- [ glUnmapBuffer ] ---
/**
*
*
* Relinquishes the mapping of a buffer object and invalidates the pointer to its data store.
*
*
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:
*
* Deletes named query objects.
*
* @param ids an array of query objects to be deleted
*/
public static void glDeleteQueries(IntBuffer ids) {
nglDeleteQueries(ids.remaining(), memAddress(ids));
}
/**
*
*
* Determine if a name corresponds to a query object.
*
* @param id a value that may be the name of a query object
*/
public static native boolean glIsQuery(int id);
// --- [ glBeginQuery ] ---
/**
*
*
* Marks the end of the sequence of commands to be tracked for the active query specified by {@code target}.
*
* @param target the query object target. One of:
*
* Returns the integer value of a query object parameter.
*
* @param id the name of a query object
* @param pname the symbolic name of a query object parameter. One of:
*
* Returns the integer value of a query object parameter.
*
* @param id the name of a query object
* @param pname the symbolic name of a query object parameter. One of:
*
* Unsigned version of {@link #glGetQueryObjectiv GetQueryObjectiv}.
*
* @param id the name of a query object
* @param pname the symbolic name of a query object parameter. One of:
*
* Unsigned version of {@link #glGetQueryObjectiv GetQueryObjectiv}.
*
* @param id the name of a query object
* @param pname the symbolic name of a query object parameter. One of:
