Replaces #287, since I can't update @rbiermann's branch in-place in their repository. @dgkoch @pdaniell-nv I suggest adding the KHR extension to this branch. Unfortunately, the changes in #287 directly updated the headers rather than adding the new interfaces to gl.xml / wgl.xml. As a result regenerating the headers will not actually include the interfaces for the new extensions. If you can attempt to add the interfaces for the new extensions introduced in #287 that would be great. If not I'll attempt to do it, but I can't guarantee I'll have time by Sunday evening, with the Vulkan update taking up my time. In terms of just publishing the specs, the branch should be fine as is.
diff --git a/extensions/NV/WGL_NV_multigpu_context.txt b/extensions/NV/WGL_NV_multigpu_context.txt new file mode 100644 index 0000000..c150206 --- /dev/null +++ b/extensions/NV/WGL_NV_multigpu_context.txt
@@ -0,0 +1,146 @@ +Name + + NV_multigpu_context + +Name Strings + + WGL_NV_multigpu_context + +Contact + + Ralf Biermann (rbiermann 'at' nvidia.com) + +Contributors + + Joshua Schnarr, NVIDIA + Ingo Esser, NVIDIA + Robert Menzel, NVIDIA + +Notice + + Copyright (c) 2019 NVIDIA + +Status + + Complete. + +Version + + Last Modified Date: 2019-05-29 + Author Revision: 4 + +Number + + OpenGL Extension #542 + +Dependencies + + WGL_NV_multigpu_context is written against the + WGL_ARB_create_context specification, which is required. + + This extension interacts with NV_gpu_multicast. + This extension interacts with WGL_ARB_make_current_read. + +Overview + + 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 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. + +New Procedures and Functions + + None + +New Tokens (WGL) + + Accepted as an attribute name in the <*attrib_list> argument to + wglCreateContextAttribsARB: + + WGL_CONTEXT_MULTIGPU_ATTRIB_NV 0x20AA + + Accepted as an attribute value for WGL_CONTEXT_MULTIGPU_ATTRIB_NV in + the <*attrib_list> argument to wglCreateContextAttribsARB: + + 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 + +Additions to WGL_ARB_create_context and WGL_ARB_make_current_read + + Add a new paragraph to the description of wglCreateContextAttribsARB, as + defined by WGL_ARB_create_context: + + "The attribute name WGL_CONTEXT_MULTIGPU_ATTRIB_NV indicates the + preferred multi-GPU rendering mode for the OpenGL context. + This specified mode precedes other selected configuration settings." + + Add a new paragraph to the description of wglMakeCurrent and + wglMakeContextCurrentARB: + + "With OpenGL on Windows, a thread can only have one current rendering context + and a device context can only be used by a single thread at a time. + Violating this by using the same device context with multiple rendering + contexts does not normally return an error, but can lead to undefined and + undesirable behavior. + When multigpu context attributes are used, however, wglMakeCurrent and + wglMakeContextCurrentARB will return FALSE and set ERROR_INVALID_OPERATION + if a HDC passed to the function is already current with a rendering context + using an alternate multigpu attribute." + +GLX Protocol + + None. + +Errors for WGL + + A GL error ERROR_INVALID_PARAMETER is generated when a value for + WGL_CONTEXT_MULTIGPU_ATTRIB_NV passed into a wglCreateContextAttribsARB + attribute list is not an accepted value. + + A GL error ERROR_NOT_SUPPORTED is generated when an unsupported SLI rendering + mode value is passed as value of attribute WGL_CONTEXT_MULTIGPU_ATTRIB_NV in a + wglCreateContextAttribsARB attribute list. + + A GL error ERROR_NOT_SUPPORTED is generated when passing a device context HDC + to wglMakeCurrent or wglMakeContextCurrentARB if the HDC is already current with + a rendering context using a multigpu attribute in a different thread. + +New State + + None. + +Issues + + 1. Is MULTICAST mode supported in a multi-display configuration where displays attached + to multiple GPUs are linked together in a desktop configuration spanning multiple GPUs? + + RESOLVED: Not by default. + + A dedicated attribute value WGL_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV has to be + specified when a linked multi-GPU display configuration is considered for multicast rendering + by the application creating the context. + + +Revision History + + Rev. Date Author Changes + ---- ---------- -------- --------------------------------------------- + 1 2017-02-21 rbiermann Initial draft + 2 2018-09-17 rbiermann Updated attribute list and spec proposal + 3 2019-05-08 rbiermann Added multi-display multicast mode + 4 2019-05-29 rbiermann Added behavior of multithreaded wglMakeCurrent \ No newline at end of file
diff --git a/extensions/NVX/NVX_gpu_multicast2.txt b/extensions/NVX/NVX_gpu_multicast2.txt new file mode 100644 index 0000000..4d63eec --- /dev/null +++ b/extensions/NVX/NVX_gpu_multicast2.txt
@@ -0,0 +1,249 @@ +Name + + NVX_gpu_multicast2 + +Name Strings + + GL_NVX_gpu_multicast2 + +Contact + + Joshua Schnarr, NVIDIA Corporation (jschnarr 'at' nvidia.com) + Ingo Esser, NVIDIA Corporation (iesser 'at' nvidia.com) + +Contributors + + Robert Menzel, NVIDIA + Ralf Biermann, NVIDIA + +Status + + Complete. + +Version + + Last Modified Date: July 23, 2019 + Author Revision: 8 + +Number + + OpenGL Extension #543 + +Dependencies + + This extension is written against the OpenGL 4.6 specification + (Compatibility Profile), dated October 24, 2016. + + This extension requires NV_gpu_multicast. + + This extension requires EXT_device_group. + + This extension requires NV_viewport_array. + + This extension requires NV_clip_space_w_scaling. + + This extension requires NVX_progress_fence. + + +Overview + + This extension provides additional mechanisms that influence multicast rendering which is + simultaneous rendering to multiple GPUs. + +New Procedures and Functions + + uint AsyncCopyImageSubDataNVX( + sizei waitSemaphoreCount, const uint *waitSemaphoreArray, const uint64 *waitValueArray, + uint srcGpu, GLbitfield dstGpuMask, + uint srcName, GLenum srcTarget, int srcLevel, int srcX, int srcY, int srcZ, + uint dstName, GLenum dstTarget, int dstLevel, int dstX, int dstY, int dstZ, + sizei srcWidth, sizei srcHeight, sizei srcDepth, + sizei signalSemaphoreCount, const uint *signalSemaphoreArray, const uint64 *signalValueArray); + + sync AsyncCopyBufferSubDataNVX( + sizei waitSemaphoreCount, const uint *waitSemaphoreArray, const uint64 *fenceValueArray, + uint readGpu, GLbitfield writeGpuMask, + uint readBuffer, uint writeBuffer, + GLintptr readOffset, GLintptr writeOffset, sizeiptr size, + sizei signalSemaphoreCount, const uint *signalSemaphoreArray, const uint64 *signalValueArray); + + void UploadGpuMaskNVX(bitfield mask); + + void MulticastViewportArrayvNVX(uint gpu, uint first, sizei count, const float *v); + + void MulticastScissorArrayvNVX(uint gpu, uint first, sizei count, const int *v); + + void MulticastViewportPositionWScaleNVX(uint gpu, uint index, float xcoeff, float ycoeff); + + +New Tokens + + Accepted by the <pname> parameter of GetIntegerv and GetInteger64v: + + UPLOAD_GPU_MASK_NVX 0x954A + +Additions to Chapter 20 (Multicast Rendering) added to the OpenGL 4.5 (Compatibility Profile) +Specification by NV_gpu_multicast + + Additions to Section 20.1 (Controlling Individual GPUs) + + Texture data uploads using the functions TexImage1D, TexImage2D, TexImage3D, + TexSubImage1D, TexSubImage2D and TexSubImage3D are restricted to a specific set of GPUs with + + void UploadGpuMaskNVX(bitfield mask); + + This command also restricts buffer object data uploads using the functions BufferStorage, + NamedBufferStorage, BufferSubData and NamedBufferSubData to the specified set of GPUs. + + Further this command also restricts buffer object clears using the functions ClearBufferData, + ClearNamedBufferData, ClearBufferSubData and ClearNamedBufferSubData. + + The following errors apply to UploadGpuMaskNVX: + + INVALID_VALUE is generated + * if <mask> is zero, + * if <mask> is greater than or equal to 2^n, where n is equal to MULTICAST_GPUS_NV + + If the command does not generate an error, UPLOAD_GPU_MASK_NVX is set to <mask>. + + The default value of UPLOAD_GPU_MASK_NVX is (2^n)-1. + + If a function restricted by UploadGpuMaskNVX operates on textures or buffer objects + with GPU-shared storage type (as opposed to per-GPU storage), UPLOAD_GPU_MASK_NVX is ignored. + + Modify Section 20.2 (Multi-GPU Buffer Storage) + + Append the following paragraphs: + + To initiate a copy of buffer data without waiting for it to complete, use the following command: + + void AsyncCopyBufferSubDataNVX( + sizei waitSemaphoreCount, const uint *waitSemaphoreArray, const uint64 *fenceValueArray, + uint readGpu, GLbitfield writeGpuMask, + uint readBuffer, uint writeBuffer, + GLintptr readOffset, GLintptr writeOffset, sizeiptr size, + sizei signalSemaphoreCount, const uint *signalSemaphoreArray, const uint64 *signalValueArray); + + This command behaves equivalently to MulticastCopyBufferSubDataNV, except that it may be + performed concurrently with commands submitted in the future. + Fence semaphore objects created with CreateProgressFenceNVX are used for synchronization of one or + multiple copies. + An array of <waitSemaphoreCount> synchronization objects can be specified in the <waitSemaphoresArray> + parameter as a pointer to the array of semaphore objects. + The copy will wait for all fence semaphores in the <waitSemaphoreArray> array to be reach or exceed + their corresponding fence value in <fenceValueArray> before starting the transfer. + A signal operation for each of the <signalSemaphoreCount> semaphores in <signalSemaphoresArray> is written + after the copy with the corresponding fence value in <signalValueArray>. + To wait for the copy to complete, use WaitSemaphoreui64NVX or ClientWaitSemaphoreui64NVX to wait + for the semaphores in <signalSemaphoreArray> to be signalled with the fence values in <signalValueArray>. + + Modify Section 20.3.1 (Copying Image Data Between GPUs) + + Insert the following paragraphs above the line starting "To copy pixel values": + + To initiate a copy of texel data without waiting for it to complete, use the following command: + + void AsyncCopyImageSubDataNVX( + sizei waitSemaphoreCount, const uint *waitSemaphoreArray, const uint64 *waitValueArray, + uint srcGpu, GLbitfield dstGpuMask, + uint srcName, GLenum srcTarget, int srcLevel, int srcX, int srcY, int srcZ, + uint dstName, GLenum dstTarget, int dstLevel, int dstX, int dstY, int dstZ, + sizei srcWidth, sizei srcHeight, sizei srcDepth, + sizei signalSemaphoreCount, const uint *signalSemaphoreArray, const uint64 *signalValueArray); + + This command behaves equivalently to MulticastCopyImageSubDataNV, except that it may be + performed concurrently with commands submitted in the future. + Fence semaphore objects created with CreateProgressFenceNVX are used for synchronization of one or + multiple copies. An array of <waitSemaphoreCount> synchronization objects can be specified in the + <waitSemaphoreArray> parameter as a pointer to the array of semaphore objects. + The copy will wait for all fence semaphores in the <waitSemaphoresArray> array to be reach or exceed + their corresponding fence value in <fenceValueArray> before starting the transfer. + A signal operation for each of the <signalSemaphoreCount> semaphores in <signalSemaphoreArray> is written + after the copy with the corresponding fence value in <signalValueArray>. + To wait for the copy to complete, use WaitSemaphoreui64NVX or ClientWaitSemaphoreui64NVX to wait + for the semaphores in <signalSemaphoresArray> to be signalled with the fence values in <signalValueArray>. + +Additions to Chapter 13 (Fixed-Function Vertex Post-Processing) added to the OpenGL 4.5 (Compatibility Profile) + + Modify Section 13.6 (Coordinate transformations) + + Viewport transformation parameters for multiple viewports are specified using + + MulticastViewportArrayvNVX(uint gpu, uint first, sizei count, const float * v); + + where the array of viewport parameters can be controlled for each multicast GPU, respectively. + + A set of scissor rectangles that are each applied to the corresponding viewport is specified + using + + MulticastScissorArrayvNVX(uint gpu, uint first, sizei count, const int *v); + + where the rectangle parameters can be controlled for each multicast GPU, respectively. + + + If 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 can be controlled for each multicast GPU, respectively, by the command + + MulticastViewportPositionWScaleNVX(uint gpu, uint index, float xcoeff, float ycoeff); + + An error INVALID_VALUE error is generated if <gpu> is greater than or equal to MULTICAST_GPUS_NV. + +Additions to the OpenGL Shading Language Specification, Version 4.50 + + Including the following line in a shader can be used to enumerate multicast GPUs + by using the shader built-in variable gl_DeviceIndex: + + #extension GL_EXT_device_group : enable + + Each multicast GPU contains a unique device index in the gl_DeviceIndex variable. + +Errors + + Relaxation of INVALID_ENUM errors + --------------------------------- + GetIntegerv and GetInteger64v now accept new tokens as + described in the "New Tokens" section. + +New State + + Additions to Table 23.6 Buffer Object State + Initial + Get Value Type Get Command Value Description Sec. Attribute + -------------------------- ------ ----------- ----- ----------------------- ---- --------- + UPLOAD_GPU_MASK_NVX Z+ GetIntegerv * Mask of GPUs that 20.1 - + restricts buffer data + writes + * See section 20.1 + + +New Implementation Dependent State + + None. + +Sample Code + + None. + +Issues + + None. + +Revision History + + Rev. Date Author Changes + ---- -------- -------- ----------------------------------------------- + 1 09/20/17 jschnarr initial draft + 2 02/23/18 rbiermann updated draft with new functions + 3 05/23/18 rbiermann updated draft with new ViewportArray and AsyncCopy functions + 4 06/08/18 rbiermann added NVX_progress_fence for synchronization objects + 5 08/15/18 rbiermann updated draft with gl_deviceIndex + 6 04/16/19 rbiermann updated draft with UploadGpuMaskNVX + 7 07/19/19 rbiermann updated draft with modifications of UploadGpuMaskNVX section + 8 07/23/19 rbiermann updated draft with support of Clear(Named)Buffer(Sub)Data by UploadGpuMaskNVX +
diff --git a/extensions/NVX/NVX_progress_fence.txt b/extensions/NVX/NVX_progress_fence.txt new file mode 100644 index 0000000..3721ed9 --- /dev/null +++ b/extensions/NVX/NVX_progress_fence.txt
@@ -0,0 +1,182 @@ +Name + + NVX_progress_fence + +Name Strings + + GL_NVX_progress_fence + +Contributors + + Ingo Esser, NVIDIA + Joshua Schnarr, NVIDIA + Ralf Biermann, NVIDIA + +Contact + + Ralf Biermann, NVIDIA corporation (rbiermann'at' nvidia.com) + +Status + + Complete. + +Version + + Last Modified Date: August 15, 2018 + Author Revision: 2 + +Number + + OpenGL Extension #541 + +Dependencies + + This extension is written against the OpenGL 4.5 and OpenGL ES 3.2 specifications. + + This extension requires EXT_external_objects. + + This extension requires EXT_external_objects_win32 + + This extension interacts with NV_gpu_multicast. + +Overview + + This extension uses the concept of GL semaphores as defined in + GL_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 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 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 ClientWaitSemaphoreui64NVX. + This blocks the CPU until the specified fence value is reached. + +New Procedures and Functions + + uint CreateProgressFenceNVX(); + + void SignalSemaphoreui64NVX(uint signalGpu, + sizei fenceObjectCount, + const uint *semaphoreArray, + const uint64 *fenceValueArray); + + void WaitSemaphoreui64NVX(uint waitGpu, + sizei fenceObjectCount, + const uint *semaphoreArray, + const uint64 *fenceValueArray); + + void ClientWaitSemaphoreui64NVX(sizei fenceObjectCount, + const uint *semaphoreArray, + const uint64 *fenceValueArray); + +New Types + + None + +New Tokens + + None + +Additions to Chapter 4 of the OpenGL 4.5 Specification (Event Model) + + Addition to Section 4.2, "Semaphore Objects + + + A command + + uint CreateProgressFenceNVX(); + + creates a named progress fence semaphore object. + + A set of progress fence objects can be deleted by passing the names in the + array <semaphores> to the command + + void DeleteSemaphoresEXT(sizei n, const uint *semaphores); + + Progress fence operations can be performed on named semaphore objects. The + command + + void SignalSemaphoreui64NVX(uint signalGpu, + sizei fenceObjectCount, + const uint *semaphoreArray, + const uint64 *fenceValueArray); + + SignalSemaphoreui64NVX inserts a signal operation for each of the <fenceObjectCount> + semaphores in <semaphoreArray>. Each signal writes the corresponding fence value in + <fenceValueArray>. + + If the GL context uses NV_gpu_multicast to control multiple GPUs, the + <signalGpu> parameter is required to specify the GPU that signals the + fence value to the fence object. Otherwise <signalGpu> must be 0. + + If a value in <semaphoreArray> is not the name of a semaphore object, + an INVALID_VALUE error is generated. + + If NV_gpu_multicast is supported, an INVALID_VALUE error is generated if <signalGpu> + is greater than or equal to MULTICAST_GPUS_NV. Otherwise, an INVALID_VALUE error is + generated if <signalGpu> != 0. + + The command + + void WaitSemaphoreui64NVX(uint waitGpu, + sizei fenceObjectCount, + const uint *semaphoreArray, + const uint64 *fenceValueArray); + + inserts a wait command into the GL server command stream of a specified GPU <waitGpu> + for each of the <fenceObjectCount> progress fence objects in <semaphoreArray> which + blocks <waitGpu> until all fence objects reach or exceed the associated fence value + in <fenceValueArray>. + + If a value in <semaphoreArray> is not the name of a semaphore object, + an INVALID_VALUE error is generated. + + The command + + void ClientWaitSemaphoreui64NVX(sizei fenceObjectCount, + const uint *semaphoreArray, + const uint64 *fenceValueArray); + + blocks the CPU until each of the <fenceObjectCount> fence objects in a + specified array <semaphoreArray> reaches the corresponding fence value + in <fenceValueArray>, respectively. + + If a value in <semaphoreArray> is not the name of a semaphore object, + an INVALID_VALUE error is generated. + + The commands SignalSemaphoreui64NVX, WaitSemaphoreui64NVX and + ClientWaitSemaphoreui64NVX accept semaphore object names as input in + <semaphoreArray> that were created by CreateProgressFenceNVX or imported + from a handle of the type HANDLE_TYPE_D3D12_FENCE_EXT. + If a value in <semaphoreArray> is not the name of such a semaphore object, + an INVALID_VALUE error is generated. + + The command + + boolean IsSemaphoreEXT(uint semaphore); + + can be used with progress fence semaphores and returns TRUE if <semaphore> + is the name of a semaphore as defined in EXT_external_objects. + +Issues + + 1) Are Vulkan semaphores imported via the GL_EXT_memory_object_win32 supported + by GL_NVX_progress_fence as input parameters? + + RESOLVED: No. As Vulkan semaphores currently do not support progress fence + operation, these are not compatible with progress fence semaphores. + +Revision History + + Revision 1, 2018-08-14 (Ralf Biermann) + - Initial specification proposal. + + Revision 2, 2018-08-15 (Ralf Biermann) + - Adding Vulkan semaphore limitation to Issues.
diff --git a/extensions/glext.php b/extensions/glext.php index 2c238f4..dbdfc6f 100644 --- a/extensions/glext.php +++ b/extensions/glext.php
@@ -1019,4 +1019,10 @@ </li> <li value=540><a href="extensions/MESA/MESA_framebuffer_flip_y.txt">GL_MESA_framebuffer_flip_y</a> </li> +<li value=541><a href="extensions/NVX/NVX_progress_fence.txt">GL_NVX_progress_fence</a> +</li> +<li value=542><a href="extensions/NV/WGL_NV_multigpu_context.txt">WGL_NV_multigpu_context</a> +</li> +<li value=543><a href="extensions/NVX/NVX_gpu_multicast2.txt">GL_NVX_gpu_multicast2</a> +</li> </ol>
diff --git a/extensions/registry.py b/extensions/registry.py index 521efd4..b603b7c 100644 --- a/extensions/registry.py +++ b/extensions/registry.py
@@ -3422,6 +3422,18 @@ 'supporters' : { 'NVIDIA' }, 'url' : 'extensions/NV/NV_gpu_multicast.txt', }, + 'GL_NVX_gpu_multicast2' : { + 'number' : 543, + 'flags' : { 'public' }, + 'supporters' : { 'NVIDIA' }, + 'url' : 'extensions/NVX/NVX_gpu_multicast2.txt', + }, + 'GL_NVX_progress_fence' : { + 'number' : 541, + 'flags' : { 'public' }, + 'supporters' : { 'NVIDIA' }, + 'url' : 'extensions/NVX/NVX_progress_fence.txt', + }, 'GL_NV_gpu_program4' : { 'number' : 322, 'flags' : { 'public' }, @@ -5514,4 +5526,10 @@ 'supporters' : { 'KHR' }, 'url' : 'extensions/OML/WGL_OML_sync_control.txt', }, + 'WGL_NV_multigpu_context' : { + 'number' : 542, + 'flags' : { 'public' }, + 'supporters' : { 'NVIDIA' }, + 'url' : 'extensions/NV/WGL_NV_multigpu_context.txt', + }, }
diff --git a/xml/gl.xml b/xml/gl.xml index a25e941..a0a873e 100644 --- a/xml/gl.xml +++ b/xml/gl.xml
@@ -47824,6 +47824,25 @@ <command name="glMulticastGetQueryObjectui64vNV"/> </require> </extension> + <extension name="GL_NVX_gpu_multicast2" supported="gl"> + <require> + <enum name="GL_UPLOAD_GPU_MASK_NV"/> + <command name="glUploadGpuMaskNVX"/> + <command name="glMulticastViewportArrayvNVX"/> + <command name="glMulticastViewportPositionWScaleNVX"/> + <command name="glMulticastScissorArrayvNVX"/> + <command name="glAsyncCopyBufferSubDataNVX"/> + <command name="glAsyncCopyImageSubDataNVX"/> + </require> + </extension> + <extension name="GL_NVX_progress_fence" supported="gl"> + <require> + <command name="glCreateProgressFenceNVX"/> + <command name="glSignalSemaphoreui64NVX"/> + <command name="glWaitSemaphoreui64NVX"/> + <command name="glClientWaitSemaphoreui64NVX"/> + </require> + </extension> <extension name="GL_NV_memory_attachment" supported="gl|glcore|gles2"> <require> <enum name="GL_ATTACHED_MEMORY_OBJECT_NV"/>
diff --git a/xml/wgl.xml b/xml/wgl.xml index c3b3630..4d94a36 100644 --- a/xml/wgl.xml +++ b/xml/wgl.xml
@@ -1985,5 +1985,14 @@ <command name="wglWaitForSbcOML"/> </require> </extension> + <extension name="WGL_NV_multigpu_context" supported="wgl"> + <require> + <enum name="WGL_CONTEXT_MULTIGPU_ATTRIB_NV"/> + <enum name="WGL_CONTEXT_MULTIGPU_ATTRIB_SINGLE_NV"/> + <enum name="WGL_CONTEXT_MULTIGPU_ATTRIB_AFR_NV"/> + <enum name="WGL_CONTEXT_MULTIGPU_ATTRIB_MULTICAST_NV"/> + <enum name="WGL_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV"/> + </require> + </extension> </extensions> </registry>