/**
* @param dxObject a pointer to the DirectX resource that will be shared
* @param shareHandle the share handle that the OS generated for the resource
*/
public static int wglDXSetResourceShareHandleNV(long dxObject, long shareHandle) {
long __functionAddress = getInstance().DXSetResourceShareHandleNV;
if (CHECKS) {
checkPointer(dxObject);
checkPointer(shareHandle);
}
return callPPI(__functionAddress, dxObject, shareHandle);
}
public static int wglDXUnregisterObjectNV(long device, long object) {
long __functionAddress = getInstance().DXUnregisterObjectNV;
if (CHECKS) {
checkPointer(device);
checkPointer(object);
}
return callPPI(__functionAddress, device, object);
}
/**
* 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(long display, long context) {
long __functionAddress = getInstance().FreeContextEXT;
if (LWJGLUtil.CHECKS) {
checkFunctionAddress(__functionAddress);
checkPointer(display);
checkPointer(context);
}
nglXFreeContextEXT(display, context, __functionAddress);
}
/** Unsafe version of {@link #eglCreatePixmapSurfaceHI CreatePixmapSurfaceHI} */
@JavadocExclude
public static long neglCreatePixmapSurfaceHI(long dpy, long config, long pixmap) {
long __functionAddress = getInstance().CreatePixmapSurfaceHI;
if (CHECKS) {
checkPointer(dpy);
checkPointer(config);
}
return callPPPP(__functionAddress, dpy, config, pixmap);
}
/**
* @param dxObject a pointer to the DirectX resource that will be shared
* @param shareHandle the share handle that the OS generated for the resource
*/
public static int wglDXSetResourceShareHandleNV(long dxObject, long shareHandle) {
long __functionAddress = getInstance().DXSetResourceShareHandleNV;
if (LWJGLUtil.CHECKS) {
checkFunctionAddress(__functionAddress);
checkPointer(dxObject);
checkPointer(shareHandle);
}
return nwglDXSetResourceShareHandleNV(dxObject, shareHandle, __functionAddress);
}
/**
* 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:<br>
* {@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}
*/
public static long wglDXRegisterObjectNV(
long device, long dxResource, int name, int type, int access) {
long __functionAddress = getInstance().DXRegisterObjectNV;
if (CHECKS) {
checkPointer(device);
checkPointer(dxResource);
}
return callPPIIIP(__functionAddress, device, dxResource, name, type, access);
}
/**
* @param device
* @param object
*/
public static int wglDXUnregisterObjectNV(long device, long object) {
long __functionAddress = getInstance().DXUnregisterObjectNV;
if (LWJGLUtil.CHECKS) {
checkFunctionAddress(__functionAddress);
checkPointer(device);
checkPointer(object);
}
return nwglDXUnregisterObjectNV(device, object, __functionAddress);
}
/** Unsafe version of {@link #eglSwapBuffersWithDamageEXT SwapBuffersWithDamageEXT} */
@JavadocExclude
public static boolean neglSwapBuffersWithDamageEXT(
long dpy, long surface, long rects, int n_rects) {
long __functionAddress = getInstance().SwapBuffersWithDamageEXT;
if (CHECKS) {
checkPointer(dpy);
checkPointer(surface);
}
return callPPPIZ(__functionAddress, dpy, surface, rects, n_rects);
}
/** Unsafe version of {@link #glXQueryContextInfoEXT QueryContextInfoEXT} */
@JavadocExclude
public static int nglXQueryContextInfoEXT(long display, long context, int attribute, long value) {
long __functionAddress = getInstance().QueryContextInfoEXT;
if (LWJGLUtil.CHECKS) {
checkFunctionAddress(__functionAddress);
checkPointer(display);
checkPointer(context);
}
return nglXQueryContextInfoEXT(display, context, attribute, value, __functionAddress);
}
/** Unsafe version of {@link #eglCreatePbufferFromClientBuffer CreatePbufferFromClientBuffer} */
@JavadocExclude
public static long neglCreatePbufferFromClientBuffer(
long dpy, int buftype, long buffer, long config, long attrib_list) {
long __functionAddress = getInstance().CreatePbufferFromClientBuffer;
if (CHECKS) {
checkPointer(dpy);
checkPointer(buffer);
checkPointer(config);
}
return callPIPPPP(__functionAddress, dpy, buftype, buffer, config, attrib_list);
}
/**
* 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 x<sub>0</sub> coordinate
* @param srcY0 the source Y<sub>0</sub> coordinate
* @param srcX1 the source X<sub>1</sub> coordinate
* @param srcY1 the source Y<sub>1</sub> coordinate
* @param dstX0 the destination X<sub>0</sub> coordinate
* @param dstY0 the destination Y<sub>0</sub> coordinate
* @param dstX1 the destination X<sub>1</sub> coordinate
* @param dstY1 the destination Y<sub>1</sub> coordinate
* @param mask the bitwise OR of a number of values indicating which buffers are to be copied. One
* or more of:<br>
* {@link GL11#GL_COLOR_BUFFER_BIT}, {@link GL11#GL_DEPTH_BUFFER_BIT}, {@link
* GL11#GL_STENCIL_BUFFER_BIT}
* @param filter the interpolation method to apply if the image is stretched. One of:<br>
* {@link GL11#GL_LINEAR}, {@link GL11#GL_NEAREST}
*/
public static void wglBlitContextFramebufferAMD(
long dstCtx,
int srcX0,
int srcY0,
int srcX1,
int srcY1,
int dstX0,
int dstY0,
int dstX1,
int dstY1,
int mask,
int filter) {
long __functionAddress = getInstance().BlitContextFramebufferAMD;
if (LWJGLUtil.CHECKS) {
checkFunctionAddress(__functionAddress);
checkPointer(dstCtx);
}
nwglBlitContextFramebufferAMD(
dstCtx,
srcX0,
srcY0,
srcX1,
srcY1,
dstX0,
dstY0,
dstX1,
dstY1,
mask,
filter,
__functionAddress);
}
/**
* Unsafe version of {@link #glXCreateAssociatedContextAttribsAMD
* CreateAssociatedContextAttribsAMD}
*/
@JavadocExclude
public static long nglXCreateAssociatedContextAttribsAMD(
int id, long share_context, long attribList) {
long __functionAddress = getInstance().CreateAssociatedContextAttribsAMD;
if (LWJGLUtil.CHECKS) checkPointer(share_context);
return callIPPP(__functionAddress, id, share_context, attribList);
}
public static void glXBlitContextFramebufferAMD(
long dstCtx,
int srcX0,
int srcY0,
int srcX1,
int srcY1,
int dstX0,
int dstY0,
int dstX1,
int dstY1,
int mask,
int filter) {
long __functionAddress = getInstance().BlitContextFramebufferAMD;
if (LWJGLUtil.CHECKS) checkPointer(dstCtx);
callPIIIIIIIIIIV(
__functionAddress,
dstCtx,
srcX0,
srcY0,
srcX1,
srcY1,
dstX0,
dstY0,
dstX1,
dstY1,
mask,
filter);
}
/** @param device */
public static int wglDXCloseDeviceNV(long device) {
long __functionAddress = getInstance().DXCloseDeviceNV;
if (LWJGLUtil.CHECKS) {
checkFunctionAddress(__functionAddress);
checkPointer(device);
}
return nwglDXCloseDeviceNV(device, __functionAddress);
}
/**
* 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
*/
public static long glXImportContextEXT(long display, long contextID) {
long __functionAddress = getInstance().ImportContextEXT;
if (LWJGLUtil.CHECKS) {
checkFunctionAddress(__functionAddress);
checkPointer(display);
}
return nglXImportContextEXT(display, contextID, __functionAddress);
}
/**
* Returns the XID of a GLXContext.
*
* @param context the context
*/
public static long glXGetContextIDEXT(long context) {
long __functionAddress = getInstance().GetContextIDEXT;
if (LWJGLUtil.CHECKS) {
checkFunctionAddress(__functionAddress);
checkPointer(context);
}
return nglXGetContextIDEXT(context, __functionAddress);
}
/**
* Makes an associated context current in the current thread.
*
* @param hglrc a context handle created by calling {@link #wglCreateAssociatedContextAMD
* CreateAssociatedContextAMD}
*/
public static int wglMakeAssociatedContextCurrentAMD(long hglrc) {
long __functionAddress = getInstance().MakeAssociatedContextCurrentAMD;
if (LWJGLUtil.CHECKS) {
checkFunctionAddress(__functionAddress);
checkPointer(hglrc);
}
return nwglMakeAssociatedContextCurrentAMD(hglrc, __functionAddress);
}
/**
* Determine which GPU a context is attached to.
*
* <p>Unassociated contexts are created by calling {@link
* org.lwjgl.system.windows.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
*/
public static int wglGetContextGPUIDAMD(long hglrc) {
long __functionAddress = getInstance().GetContextGPUIDAMD;
if (LWJGLUtil.CHECKS) {
checkFunctionAddress(__functionAddress);
checkPointer(hglrc);
}
return nwglGetContextGPUIDAMD(hglrc, __functionAddress);
}
/**
* Modifies the access mode of an interop object, if a different access mode is required after the
* object has been registered.
*
* @param object the GL/DirectX interop object
* @param access the new access mode. One of:<br>
* {@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}
*/
public static int wglDXObjectAccessNV(long object, int access) {
long __functionAddress = getInstance().DXObjectAccessNV;
if (LWJGLUtil.CHECKS) {
checkFunctionAddress(__functionAddress);
checkPointer(object);
}
return nwglDXObjectAccessNV(object, access, __functionAddress);
}
/** Unsafe version of {@link #wglDXUnlockObjectsNV DXUnlockObjectsNV} */
@JavadocExclude
public static int nwglDXUnlockObjectsNV(long device, int count, long objects) {
long __functionAddress = getInstance().DXUnlockObjectsNV;
if (LWJGLUtil.CHECKS) {
checkFunctionAddress(__functionAddress);
checkPointer(device);
}
return nwglDXUnlockObjectsNV(device, count, objects, __functionAddress);
}
/**
* Deletes an affinity-DC.
*
* @param hdc a handle of an affinity-DC to delete
*/
public static int wglDeleteDCNV(long hdc) {
long __functionAddress = getInstance().DeleteDCNV;
if (CHECKS) checkPointer(hdc);
return callPI(__functionAddress, hdc);
}
/** Unsafe version of {@link #wglEnumGpusFromAffinityDCNV EnumGpusFromAffinityDCNV} */
@JavadocExclude
public static int nwglEnumGpusFromAffinityDCNV(long affinityDC, int gpuIndex, long gpu) {
long __functionAddress = getInstance().EnumGpusFromAffinityDCNV;
if (CHECKS) checkPointer(affinityDC);
return callPIPI(__functionAddress, affinityDC, gpuIndex, gpu);
}
/** Unsafe version of {@link #wglEnumGpuDevicesNV EnumGpuDevicesNV} */
@JavadocExclude
public static int nwglEnumGpuDevicesNV(long gpu, int deviceIndex, long gpuDevice) {
long __functionAddress = getInstance().EnumGpuDevicesNV;
if (CHECKS) checkPointer(gpu);
return callPIPI(__functionAddress, gpu, deviceIndex, gpuDevice);
}
/** Unsafe version of {@link #wglDXUnlockObjectsNV DXUnlockObjectsNV} */
@JavadocExclude
public static int nwglDXUnlockObjectsNV(long device, int count, long objects) {
long __functionAddress = getInstance().DXUnlockObjectsNV;
if (CHECKS) checkPointer(device);
return callPIPI(__functionAddress, device, count, objects);
}
/**
* 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
*/
public static long wglDXOpenDeviceNV(long dxDevice) {
long __functionAddress = getInstance().DXOpenDeviceNV;
if (CHECKS) checkPointer(dxDevice);
return callPP(__functionAddress, dxDevice);
}
public static int wglDXCloseDeviceNV(long device) {
long __functionAddress = getInstance().DXCloseDeviceNV;
if (CHECKS) checkPointer(device);
return callPI(__functionAddress, device);
}
/**
* Determines which GPU a context is attached to.
*
* @param ctx the GLXContext
*/
public static int glXGetContextGPUIDAMD(long ctx) {
long __functionAddress = getInstance().GetContextGPUIDAMD;
if (LWJGLUtil.CHECKS) checkPointer(ctx);
return callPI(__functionAddress, ctx);
}
/**
* Makes an associated context current in the current thread.
*
* @param ctx the GLXContext
*/
public static int glXMakeAssociatedContextCurrentAMD(long ctx) {
long __functionAddress = getInstance().MakeAssociatedContextCurrentAMD;
if (LWJGLUtil.CHECKS) checkPointer(ctx);
return callPI(__functionAddress, ctx);
}
/**
* Creates an associated context.
*
* @param id
* @param share_list
*/
public static long glXCreateAssociatedContextAMD(int id, long share_list) {
long __functionAddress = getInstance().CreateAssociatedContextAMD;
if (LWJGLUtil.CHECKS) checkPointer(share_list);
return callIPP(__functionAddress, id, share_list);
}
/**
* Modifies the access mode of an interop object, if a different access mode is required after the
* object has been registered.
*
* @param object the GL/DirectX interop object
* @param access the new access mode. One of:<br>
* {@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}
*/
public static int wglDXObjectAccessNV(long object, int access) {
long __functionAddress = getInstance().DXObjectAccessNV;
if (CHECKS) checkPointer(object);
return callPII(__functionAddress, object, access);
}
