Пример #1
0
 /**
  * @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);
 }
Пример #2
0
 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);
 }
Пример #4
0
 /** 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);
 }
Пример #5
0
 /**
  * @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);
 }
Пример #6
0
 /**
  * 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);
 }
Пример #7
0
 /**
  * @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);
 }
Пример #10
0
 /** 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);
 }
Пример #12
0
 /**
  * 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);
 }
Пример #13
0
 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);
 }
Пример #14
0
 /** @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);
 }
Пример #19
0
 /**
  * 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);
 }
Пример #20
0
 /** 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);
 }
Пример #21
0
 /**
  * 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);
 }
Пример #22
0
 /** 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);
 }
Пример #23
0
 /** 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);
 }
Пример #24
0
 /** 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);
 }
Пример #25
0
 /**
  * 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);
 }
Пример #26
0
 public static int wglDXCloseDeviceNV(long device) {
   long __functionAddress = getInstance().DXCloseDeviceNV;
   if (CHECKS) checkPointer(device);
   return callPI(__functionAddress, device);
 }
Пример #27
0
 /**
  * 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);
 }
Пример #28
0
 /**
  * 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);
 }
Пример #29
0
 /**
  * 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);
 }
Пример #30
0
 /**
  * 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);
 }