import org.lwjgl.BufferChecks; //导入依赖的package包/类
/**
 * Constructs a new Cursor, with the given parameters. Mouse must have been created before you can create
 * Cursor objects. Cursor images are in ARGB format, but only one bit transparancy is guaranteed to be supported.
 * So to maximize portability, lwjgl applications should only create cursor images with 0x00 or 0xff as alpha values.
 * The constructor will copy the images and delays, so there's no need to keep them around.
 *
 * @param width cursor image width
 * @param height cursor image height
 * @param xHotspot the x coordinate of the cursor hotspot
 * @param yHotspot the y coordinate of the cursor hotspot
 * @param numImages number of cursor images specified. Must be 1 if animations are not supported.
 * @param images A buffer containing the images. The origin is at the lower left corner, like OpenGL.
 * @param delays An int buffer of animation frame delays, if numImages is greater than 1, else null
 * @throws LWJGLException if the cursor could not be created for any reason
 */
public Cursor(int width, int height, int xHotspot, int yHotspot, int numImages, IntBuffer images, IntBuffer delays) throws LWJGLException {
	synchronized (OpenGLPackageAccess.global_lock) {
		if ((getCapabilities() & CURSOR_ONE_BIT_TRANSPARENCY) == 0)
			throw new LWJGLException("Native cursors not supported");
		BufferChecks.checkBufferSize(images, width*height*numImages);
		if (delays != null)
			BufferChecks.checkBufferSize(delays, numImages);
		if (!Mouse.isCreated())
			throw new IllegalStateException("Mouse must be created before creating cursor objects");
		if (width*height*numImages > images.remaining())
			throw new IllegalArgumentException("width*height*numImages > images.remaining()");
		if (xHotspot >= width || xHotspot < 0)
			throw new IllegalArgumentException("xHotspot > width || xHotspot < 0");
		if (yHotspot >= height || yHotspot < 0)
			throw new IllegalArgumentException("yHotspot > height || yHotspot < 0");

		Sys.initialize();

		// Hmm
		yHotspot = height - 1 - yHotspot;

		// create cursor (or cursors if multiple images supplied)
		cursors = createCursors(width, height, xHotspot, yHotspot, numImages, images, delays);
	}
}
 

import org.lwjgl.BufferChecks; //导入依赖的package包/类
/**
 * Returns the available EGLConfigs on the speficied display. The number of available EGLConfigs
 * is returned in the num_config parameter. The configs array may be null. If it is null, a new
 * array will be allocated, with size equal to the result of {@link #eglGetConfigsNum(EGLDisplay)}  eglGetConfigsNum}.
 * If it is not null, no more than {@code configs.length} EGLConfigs will be returned. If the array is bigger
 * than the number of available EGLConfigs, the remaining array elements will not be affected.
 *
 * @param dpy        the EGLDisplay
 * @param configs    the EGLConfigs array
 * @param num_config the number of available EGLConfigs returned
 *
 * @return the available EGLConfigs
 *
 * @throws org.lwjgl.LWJGLException if an EGL error occurs
 */
static EGLConfig[] eglGetConfigs(EGLDisplay dpy, EGLConfig[] configs, IntBuffer num_config) throws LWJGLException {
	//LWJGLUtil.log("eglGetConfigs");
	BufferChecks.checkBuffer(num_config, 1);

	if ( configs == null ) {
		if ( !neglGetConfigs(dpy.getPointer(), 0L, 0, MemoryUtil.getAddress(num_config)) )
			throwEGLError("Failed to get number of available EGL configs.");

		configs = new EGLConfig[num_config.get(num_config.position())];
	}

	final PointerBuffer configs_buffer = APIUtil.getBufferPointer(configs.length);
	if ( !neglGetConfigs(dpy.getPointer(), MemoryUtil.getAddress0(configs_buffer), configs.length, MemoryUtil.getAddress(num_config)) )
		throwEGLError("Failed to get EGL configs.");

	final int config_size = num_config.get(num_config.position());
	for ( int i = 0; i < config_size; i++ )
		configs[i] = new EGLConfig(dpy, configs_buffer.get(i));

	return configs;
}
 

import org.lwjgl.BufferChecks; //导入依赖的package包/类
/**
 * Queries an attribute associated with the current context. This method is the cross-platform
 * equivalent of glXQueryContext and wglQueryCurrentContextNV.
 *
 * @param attrib the attribute to query
 * @param value  the buffer to store the value in
 */
public static boolean glQueryContextNV(int attrib, IntBuffer value) {
	checkExtension();

	BufferChecks.checkBuffer(value, 1);
	ContextGL ctx = ContextGL.getCurrentContext();
	return nglQueryContextNV(ctx.getPeerInfo().getHandle(), ctx.getHandle(), attrib, value, value.position());
}
 

import org.lwjgl.BufferChecks; //导入依赖的package包/类
/**
 * Returns the available EGLConfigs on the speficied display that satisfy the specified list of attributes.
 * The number of available EGLConfigs is returned in the num_config parameter. The configs array may be null.
 * If it is null, a new array will be allocated, with size equal to the result of {@link #eglGetConfigsNum(EGLDisplay)}  eglGetConfigsNum}.
 * If it is not null, no more than {@code configs.length} EGLConfigs will be returned. If the array is bigger
 * than the number of available EGLConfigs, the remaining array elements will not be affected.
 *
 * @param dpy         the EGLDisplay
 * @param attrib_list the attribute list (may be null)
 * @param configs     the EGLConfigs array
 * @param num_config  the number of available EGLConfigs returned
 *
 * @return the available EGLConfigs that satisfy the attribute list
 *
 * @throws org.lwjgl.LWJGLException if an EGL error occurs
 */
static EGLConfig[] eglChooseConfig(EGLDisplay dpy, IntBuffer attrib_list, EGLConfig[] configs, IntBuffer num_config) throws LWJGLException {
	//LWJGLUtil.log("eglChooseConfig");
	checkAttribList(attrib_list);
	BufferChecks.checkBuffer(num_config, 1);

	int config_size;
	if ( configs == null ) {
		if ( !neglChooseConfig(dpy.getPointer(), MemoryUtil.getAddressSafe(attrib_list), 0L, 0, MemoryUtil.getAddress(num_config)) )
			throwEGLError("Failed to get number of available EGL configs.");

		config_size = num_config.get(num_config.position());
	} else
		config_size = configs.length;

	//LWJGLUtil.log("config_size = " + config_size);
	PointerBuffer configs_buffer = APIUtil.getBufferPointer(config_size);
	if ( !neglChooseConfig(dpy.getPointer(), MemoryUtil.getAddressSafe(attrib_list), MemoryUtil.getAddress0(configs_buffer), config_size, MemoryUtil.getAddress(num_config)) )
		throwEGLError("Failed to choose EGL config.");

	// Get the true number of configurations (the first neglChooseConfig call may return more than the second)
	config_size = num_config.get(num_config.position());
	if ( configs == null )
		configs = new EGLConfig[config_size];
	for ( int i = 0; i < config_size; i++ )
		configs[i] = new EGLConfig(dpy, configs_buffer.get(i));

	return configs;
}
 

import org.lwjgl.BufferChecks; //导入依赖的package包/类
/**
 * Enumerate the available video output devices. This method is the cross-platform
 * equivalent of glXEnumerateVideoDevicesNV and wglEnumerateVideoDevicesNV. Since they are
 * not really compatible, this method works like the WGL version. That is, you first
 * call it with a null devices buffer, get the number of devices, then call it again
 * with an appropriately sized buffer.
 *
 * @param devices the buffer to store devices in
 *
 * @return the number of available video output devices
 */
public static int glEnumerateVideoDevicesNV(LongBuffer devices) {
	checkExtension();

	if ( devices != null )
		BufferChecks.checkBuffer(devices, 1);
	return nglEnumerateVideoDevicesNV(getPeerInfo(), devices, devices == null ? 0 : devices.position());
}
 

import org.lwjgl.BufferChecks; //导入依赖的package包/类
/**
 * Binds the video output device specified to one of the context's available video output slots.
 * This method is the cross-platform equivalent of glXBindVideoDeviceNV and wglBindVideoDeviceNV.
 * To release a video device without binding another device to the same slot, call it with
 * video_device set to 0 (will use INVALID_HANDLE_VALUE on WGL).
 *
 * @param video_slot   the video slot
 * @param video_device the video device
 * @param attrib_list  the attributes to use
 *
 * @return true if the binding was successful
 */
public static boolean glBindVideoDeviceNV(int video_slot, long video_device, IntBuffer attrib_list) {
	checkExtension();

	if ( attrib_list != null )
		BufferChecks.checkNullTerminated(attrib_list);
	return nglBindVideoDeviceNV(getPeerInfo(), video_slot, video_device, attrib_list, attrib_list == null ? 0 : attrib_list.position());
}
 

import org.lwjgl.BufferChecks; //导入依赖的package包/类
/**
 * Enumerate the available video capture devices. This method is the cross-platform
 * equivalent of glXEnumerateVideoCaptureDevicesNV and wglEnumerateVideoCaptureDevicesNV.
 * Since they are not really compatible, this method works like the WGL version. That is,
 * you first call it with a null devices buffer, get the number of devices, then call it
 * again with an appropriately sized buffer.
 *
 * @param devices the buffer to store devices in
 *
 * @return the number of available video capture devices
 */
public static int glEnumerateVideoCaptureDevicesNV(LongBuffer devices) {
	checkExtension();

	if ( devices != null )
		BufferChecks.checkBuffer(devices, 1);
	return nglEnumerateVideoCaptureDevicesNV(getPeerInfo(), devices, devices == null ? 0 : devices.position());
}
 

import org.lwjgl.BufferChecks; //导入依赖的package包/类
/**
 * Use this method to query the unique ID of the physical device backing a
 * video capture device handle.
 *
 * @param device    the device
 * @param attribute the attribute to query
 * @param value     the buffer to store the value in
 *
 * @return true if the query was successful
 */
public static boolean glQueryVideoCaptureDeviceNV(long device, int attribute, IntBuffer value) {
	checkExtension();

	BufferChecks.checkBuffer(value, 1);
	return nglQueryVideoCaptureDeviceNV(getPeerInfo(), device, attribute, value, value.position());
}
 

import org.lwjgl.BufferChecks; //导入依赖的package包/类
/**
 * Initializes the specified EGL display.
 *
 * @param dpy     the EGL display to initialize
 * @param version the EGL major and minor version will be returned in this buffer.
 *
 * @throws org.lwjgl.LWJGLException if an EGL error occurs
 */
static void eglInitialize(EGLDisplay dpy, IntBuffer version) throws LWJGLException {
	//LWJGLUtil.log("eglInitialize");
	BufferChecks.checkBuffer(version, 2);
	if ( !neglInitialize(dpy.getPointer(), MemoryUtil.getAddress(version)) )
		throwEGLError("Failed to initialize EGL display.");
}
 

import org.lwjgl.BufferChecks; //导入依赖的package包/类
/**
 * Returns the value of the specified EGL surface attribute in the value parameter.
 *
 * @param dpy       the EGL display
 * @param surface   the EGL surface
 * @param attribute the surface attribute
 * @param value     the attribute value will be returned here
 *
 * @throws org.lwjgl.LWJGLException if an EGL error occurs
 */
public static void eglQuerySurface(EGLDisplay dpy, EGLSurface surface, int attribute, IntBuffer value) throws LWJGLException {
	//LWJGLUtil.log("eglQuerySurface");
	BufferChecks.checkBuffer(value, 1);
	if ( !neglQuerySurface(dpy.getPointer(), surface.getPointer(), attribute, MemoryUtil.getAddress(value)) )
		throwEGLError("Failed to query surface attribute.");
}
 

import org.lwjgl.BufferChecks; //导入依赖的package包/类
/**
 * Returns the value of the specified EGL context attribute in the value parameter.
 *
 * @param dpy       the EGL display
 * @param ctx       the EGL context
 * @param attribute the context attribute
 * @param value     the attribute value will be returned here
 *
 * @throws org.lwjgl.LWJGLException if an EGL error occurs
 */
public static void eglQueryContext(EGLDisplay dpy, EGLContext ctx, int attribute, IntBuffer value) throws LWJGLException {
	//LWJGLUtil.log("eglQueryContext");
	BufferChecks.checkBuffer(value, 1);
	if ( !neglQueryContext(dpy.getPointer(), ctx.getPointer(), attribute, MemoryUtil.getAddress(value)) )
		throwEGLError("Failed to query context attribute.");
}